meta-sovereign 0.49.13 → 0.49.15

package/js/src/server/routes-telegram-channel-manage.js

@@ -0,0 +1,79 @@
+// Managing a channel or group (R-Y216): the routes of the POSTS table in
+// routes-telegram.js, each validated strictly before the account is asked.
+// The source validates again; this keeps junk off the account. Deleting a
+// chat for everyone is `remove-chat` with the action `destroy`.
+//
+// Its routes:
+//   POST /api/telegram/channel-username-check {chat, username} -> { ok,
+//                       status } whether the public link is free, or a
+//                       code: invalid, taken, too-many-public (R-Y216)
+//   POST /api/telegram/channel-username-save {chat, username} -> { ok } the
+//                       public link set; '' makes the chat private
+//   POST /api/telegram/public-channels {} -> { ok, channels } the user's
+//                       public channels, for "Revoke link"
+//   POST /api/telegram/public-link-revoke {chat} -> { ok } one of them
+//                       made private
+//   POST /api/telegram/usernames-deactivate {chat} -> { ok } every
+//                       collectible username of the chat deactivated
+//   POST /api/telegram/channel-color-save {chat, forProfile, color?, emoji?}
+//                       -> { ok } the name or profile colour (boosts needed)
+//   POST /api/telegram/channel-emoji-status {chat, documentId, until?} ->
+//                       { ok } the channel's emoji status (null removes it)
+//   POST /api/telegram/inactive-channels {} -> { ok, channels } channels the
+//                       user could leave when there are too many
+//   POST /api/telegram/leave-channels {chats} -> { ok, left } the chosen
+//                       inactive channels left
+
+import { route } from './routes-telegram-admin-extras.js';
+
+const CHANNEL = /^-100\d{1,20}$/;
+const NAME = /^[A-Za-z][A-Za-z0-9_]{3,30}[A-Za-z0-9]$/;
+const DIGITS = /^\d{1,20}$/;
+const MAX_LEAVE = 100;
+
+const channelOf = (b) => CHANNEL.test(String(b.chat ?? ''));
+const nameOf = (b) => typeof b.username === 'string' && NAME.test(b.username);
+const WHAT = 'chat required';
+
+export const CHANNEL_MANAGE_POSTS = {
+  'channel-username-check': route(
+    'channelUsernameCheck',
+    'chat and username required',
+    (b) => channelOf(b) && nameOf(b)
+  ),
+  'channel-username-save': route(
+    'channelUsernameSave',
+    'chat and username required',
+    (b) => channelOf(b) && (b.username === '' || nameOf(b))
+  ),
+  'public-channels': route('publicChannels', WHAT, () => true),
+  'public-link-revoke': route('publicLinkRevoke', WHAT, channelOf),
+  'usernames-deactivate': route('usernamesDeactivate', WHAT, channelOf),
+  'channel-color-save': route(
+    'channelColorSave',
+    'chat and colour required',
+    (b) =>
+      channelOf(b) &&
+      typeof b.forProfile === 'boolean' &&
+      (b.color === undefined || Number.isInteger(b.color)) &&
+      (b.emoji === undefined || DIGITS.test(String(b.emoji)))
+  ),
+  'channel-emoji-status': route(
+    'channelEmojiStatusSet',
+    'chat and status required',
+    (b) =>
+      channelOf(b) &&
+      (b.documentId === null || DIGITS.test(String(b.documentId))) &&
+      (b.until === undefined || Number.isInteger(b.until))
+  ),
+  'inactive-channels': route('inactiveChannels', WHAT, () => true),
+  'leave-channels': route(
+    'leaveChannels',
+    'chats required',
+    (b) =>
+      Array.isArray(b.chats) &&
+      b.chats.length > 0 &&
+      b.chats.length <= MAX_LEAVE &&
+      b.chats.every((x) => CHANNEL.test(String(x)))
+  ),
+};

package/js/src/server/routes-telegram-emoji-groups.js

@@ -0,0 +1,20 @@
+// The emoji panel's Premium flag and category groups (R-Y214): the route
+// of the POSTS table in routes-telegram.js, validated before the account
+// is asked.
+//
+// Its routes:
+//   POST /api/telegram/emoji-panel-info {status?} -> { ok, premium, groups:
+//                       [{ title, iconEmojiId, emoticons }] } whether the
+//                       account has Premium and Telegram's emoji groups
+//                       (status: true, the emoji status picker's)
+
+import { route } from './routes-telegram-admin-extras.js';
+
+export const EMOJI_GROUPS_POSTS = {
+  'emoji-panel-info': route(
+    'emojiPanelInfo',
+    'status must be true or false',
+    (b) => b.status === undefined || typeof b.status === 'boolean',
+    (b) => ({ status: b.status === true })
+  ),
+};

package/js/src/server/routes-telegram-storage.js

@@ -0,0 +1,73 @@
+// Local storage management, reaction notifications, resetting the
+// notification settings and Telegram's automatic-download preset (R-Y215):
+// the routes of the POSTS table in routes-telegram.js, each validated
+// strictly before the account is asked.
+//
+// Its routes:
+//   POST /api/telegram/storage-usage {} -> { ok, total, kinds, chats,
+//                       limits } the media cache by kind (photos, videos,
+//                       voice, files, stickers, other) and by chat
+//   POST /api/telegram/storage-clear {kind} | {all: true} -> { ok,
+//                       removed: { bytes, files } } only files inside the
+//                       media cache are removed
+//   POST /api/telegram/storage-limits {} -> { ok, maxGb, olderDays }
+//   POST /api/telegram/storage-limits-set {maxGb, olderDays} -> { ok, ...,
+//                       removed } maxGb 0, 1, 5 or 20; olderDays 0, 7, 30
+//                       or 365 (0 is none); applied at once
+//   POST /api/telegram/reaction-notify {} -> { ok, messages, stories,
+//                       previews, sound } who is told of reactions
+//                       ('nobody', 'contacts', 'all')
+//   POST /api/telegram/reaction-notify-set {messages?, stories?, previews?,
+//                       sound?} -> the same row
+//   POST /api/telegram/notify-reset {} -> { ok } every notification
+//                       setting back to Telegram's default
+//   POST /api/telegram/auto-download-preset {} -> { ok, medium: {
+//                       disabled, photoMax, videoMax, fileMax } } bytes
+
+import { validClear, validLimits } from '../sources/telegram-storage.js';
+import { validReactionChange } from '../sources/telegram-notify-extras.js';
+import { route } from './routes-telegram-admin-extras.js';
+
+const anyone = () => true;
+const nothing = () => ({});
+
+export const STORAGE_POSTS = {
+  'storage-usage': route('storageUsage', 'not supported', anyone, nothing),
+  'storage-clear': route(
+    'storageClear',
+    'a kind or all required',
+    validClear,
+    (b) => (b.all === true ? { all: true } : { kind: b.kind })
+  ),
+  'storage-limits': route('storageLimits', 'not supported', anyone, nothing),
+  'storage-limits-set': route(
+    'storageLimitsSet',
+    'maxGb and olderDays required',
+    validLimits,
+    (b) => ({ maxGb: b.maxGb, olderDays: b.olderDays })
+  ),
+  'reaction-notify': route(
+    'reactionNotifyGet',
+    'not supported',
+    anyone,
+    nothing
+  ),
+  'reaction-notify-set': route(
+    'reactionNotifySet',
+    'a change required',
+    validReactionChange,
+    (b) => ({
+      messages: b.messages,
+      stories: b.stories,
+      previews: b.previews,
+      sound: b.sound,
+    })
+  ),
+  'notify-reset': route('notifyResetAll', 'not supported', anyone, nothing),
+  'auto-download-preset': route(
+    'autoDownloadPreset',
+    'not supported',
+    anyone,
+    nothing
+  ),
+};

package/js/src/server/routes-telegram-translate-chat.js

@@ -0,0 +1,31 @@
+// The translate bar and the summary (R-Y213): routes of the POSTS table in
+// routes-telegram.js, validated strictly before the account is asked.
+//
+// Its routes:
+//   POST /api/telegram/translate-account {} -> { ok, premium } whether the
+//                       account has Premium (the bar is offered only then)
+//   POST /api/telegram/summarize {chat, id, to?} -> { ok, text, entities }
+//                       a long message summarized (messages.summarizeText);
+//                       refusals come as { ok: false, code }
+
+import { route } from './routes-telegram-admin-extras.js';
+
+const LANG = /^[a-z]{2,3}(-[A-Za-z]{2,4})?$/;
+
+export const TRANSLATE_CHAT_POSTS = {
+  'translate-account': route(
+    'translateAccount',
+    'nothing required',
+    () => true,
+    () => ({})
+  ),
+  summarize: route(
+    'summarizeMessage',
+    'chat and id required',
+    (b) =>
+      /^-?\d{1,20}$/.test(String(b.chat ?? '')) &&
+      Number.isInteger(b.id) &&
+      b.id > 0 &&
+      (b.to === undefined || (typeof b.to === 'string' && LANG.test(b.to)))
+  ),
+};

package/js/src/server/routes-telegram-yextras.js

@@ -0,0 +1,17 @@
+// The route tables of the R-Y213..R-Y216 features in one spread, so that
+// routes-telegram.js stays under its line limit. Each table documents its
+// own routes in its file's header:
+//   routes-telegram-translate-chat.js (R-Y213), -emoji-groups.js (R-Y214),
+//   -storage.js (R-Y215), -channel-manage.js (R-Y216).
+
+import { TRANSLATE_CHAT_POSTS } from './routes-telegram-translate-chat.js';
+import { EMOJI_GROUPS_POSTS } from './routes-telegram-emoji-groups.js';
+import { STORAGE_POSTS } from './routes-telegram-storage.js';
+import { CHANNEL_MANAGE_POSTS } from './routes-telegram-channel-manage.js';
+
+export const YEXTRAS_POSTS = {
+  ...TRANSLATE_CHAT_POSTS,
+  ...EMOJI_GROUPS_POSTS,
+  ...STORAGE_POSTS,
+  ...CHANNEL_MANAGE_POSTS,
+};

package/js/src/server/routes-telegram.js

@@ -206,6 +206,7 @@ import { WEB_APPS_POSTS } from './routes-telegram-web-apps.js';
 import { BOT_LOGIN_POSTS } from './routes-telegram-bot-login.js';
 import { ADMIN_POSTS } from './routes-telegram-admin.js';
 import { GROUP_EXTRAS_POSTS } from './routes-telegram-group-extras.js';
+import { YEXTRAS_POSTS } from './routes-telegram-yextras.js';
 import {
   INSTANT_VIEW_GETS,
   INSTANT_VIEW_POSTS,
@@ -1020,6 +1021,7 @@ const POSTS = {
       : [400, { error: 'chat and a change required', code: 'bad-request' }],
   ...ADMIN_POSTS,
   ...EPHEMERAL_POSTS,
+  ...YEXTRAS_POSTS,
   ...GROUP_EXTRAS_POSTS,
   ...INSTANT_VIEW_POSTS,
   ...STICKER_EXTRAS_POSTS,

package/js/src/sources/telegram-actions.js

@@ -26,7 +26,8 @@
  *   ./telegram-scheduled.js (R-Y102), chat folders ./telegram-folders.js
  *   (R-Y103); translating messages is ./telegram-translate.js (R-Y132);
  *   message effects are ./telegram-effects.js (R-Y149); emoji statuses
- *   ./telegram-emoji-status.js (R-Y162).
+ *   ./telegram-emoji-status.js (R-Y162); the translate bar and summaries
+ *   ./telegram-translate-chat.js (R-Y213).
  */
 
 import { updatesOfResult, entitiesOf } from './telegram-catchup.js';
@@ -45,6 +46,7 @@ import { createChatSearch } from './telegram-search.js';
 import { createGlobalSearch } from './telegram-global.js';
 import { createFileSender } from './telegram-upload.js';
 import { createChatRemoval } from './telegram-chat-removal.js';
+import { createChannelManage } from './telegram-channel-manage.js';
 import { createScheduled } from './telegram-scheduled.js';
 import { createFolders } from './telegram-folders.js';
 import { createFolderEdit } from './telegram-folder-edit.js';
@@ -78,6 +80,7 @@ import { createReadersActions } from './telegram-readers.js';
 import { createMapActions } from './telegram-map.js';
 import { createChatEdit } from './telegram-chat-edit.js';
 import { createTranslate } from './telegram-translate.js';
+import { createTranslateChat } from './telegram-translate-chat.js';
 import { createTranscribe } from './telegram-transcribe.js';
 import { createEphemeral } from './telegram-ephemeral.js';
 import { createEffects } from './telegram-effects.js';
@@ -97,6 +100,9 @@ import { createTopicAdmin } from './telegram-topic-admin.js';
 import { createChatReactions } from './telegram-chat-reactions.js';
 import { createChatSettings } from './telegram-chat-settings.js';
 import { createGroupExtras } from './telegram-group-extras.js';
+import { createEmojiGroups } from './telegram-emoji-groups.js';
+import { createStorage } from './telegram-storage.js';
+import { createNotifyExtras } from './telegram-notify-extras.js';
 import { createNotifySettings } from './telegram-notify-settings.js';
 import { createRingtones } from './telegram-ringtones.js';
 import { createPinnedOrder } from './telegram-pinned-order.js';
@@ -499,7 +505,11 @@ export const createActions = (env, tools, { mediaDir = null } = {}) => {
 // exporting the account's data (R-Y212); a group's sticker set and emoji
 // pack, pinned topics reordered, new chats in a shared folder and the
 // new-contacts notification (R-Y211); ephemeral messages (R-Y223); deleted
-// messages marked with the one tombstone shape (R-Z7).
+// messages marked with the one tombstone shape (R-Z7); custom emoji in the
+// composer and the emoji panel's category groups (R-Y214); the media
+// cache's management, reaction notifications and resetting notifications
+// (R-Y215); a channel's public link, look and deletion, and inactive
+// channels to leave (R-Y216).
 const chatActions = (env, context) => {
   const { held, ...files } = createFileSender(env, context);
   const { uploads, drop } = held;
@@ -522,6 +532,7 @@ const chatActions = (env, context) => {
     ...createGlobalSearch(env, context),
     ...files,
     ...createChatRemoval(env, context),
+    ...createChannelManage(env, context),
     ...createScheduled(env, context),
     ...createFolders(env, context),
     ...createFolderEdit(env, context),
@@ -560,6 +571,7 @@ const chatActions = (env, context) => {
     ...createApps(env, { ...context, offer: inlineOffer }),
     ...createMapActions(env, context),
     ...createTranslate(env, context),
+    ...createTranslateChat(env, context),
     ...createTranscribe(env, context),
     ...createEphemeral(env, context),
     ...createStories(env, context),
@@ -623,6 +635,9 @@ const chatActions = (env, context) => {
     ...createCalendar(env, context),
     ...createTopPeers(env, context),
     ...createGroupExtras(env, context),
+    ...createEmojiGroups(env, context),
+    ...createStorage(env, context),
+    ...createNotifyExtras(env, context),
   };
 };
 

package/js/src/sources/telegram-channel-manage.js

@@ -0,0 +1,263 @@
+/**
+ * Managing a channel or group, as Telegram Desktop's Edit has it (R-Y216;
+ * learned, never copied):
+ * - `channelUsernameCheck({ chat, username })` — channels.checkUsername
+ *   → `{ ok, status: 'available' }`; USERNAME_INVALID, USERNAME_OCCUPIED
+ *   and CHANNELS_ADMIN_PUBLIC_TOO_MUCH come back as codes;
+ * - `channelUsernameSave({ chat, username })` — channels.updateUsername
+ *   (an empty name makes the chat private);
+ * - `publicChannels()` — channels.getAdminedPublicChannels → `{ ok,
+ *   channels: [{ chat, title, username }] }`, for the limit's "Revoke link";
+ * - `publicLinkRevoke({ chat })` — one of those channels made private;
+ * - `usernamesDeactivate({ chat })` — channels.deactivateAllUsernames;
+ * - `channelColorSave({ chat, forProfile, color?, emoji? })` —
+ *   channels.updateColor (name colour or profile colour, with a background
+ *   emoji); BOOSTS_REQUIRED comes back as `boosts`;
+ * - `channelEmojiStatusSet({ chat, documentId|null, until? })` —
+ *   channels.updateEmojiStatus;
+ * - `inactiveChannels()` — channels.getInactiveChannels → `{ ok, channels:
+ *   [{ chat, title, date, broadcast }] }`, for the "too many channels" case;
+ * - `leaveChannels({ chats })` — channels.leaveChannel on the chosen ones,
+ *   only those Telegram lists as inactive.
+ * Deleting a chat is `removeChat` with the `destroy` action.
+ * Telegram's errors become codes the page shows as text.
+ */
+
+import { connected, runIn } from './telegram-stickers.js';
+import { quietFailureOf } from './telegram-chat-settings.js';
+
+const CODES = {
+  USERNAME_INVALID: 'invalid',
+  USERNAME_PURCHASE_AVAILABLE: 'taken',
+  USERNAME_OCCUPIED: 'taken',
+  USERNAME_NOT_MODIFIED: 'not-modified',
+  CHANNELS_ADMIN_PUBLIC_TOO_MUCH: 'too-many-public',
+  CHAT_ADMIN_REQUIRED: 'not-admin',
+  CHAT_NOT_MODIFIED: 'not-modified',
+  CHANNEL_PRIVATE: 'no-access',
+  CHANNEL_INVALID: 'no-access',
+  BOOSTS_REQUIRED: 'boosts',
+  COLOR_INVALID: 'invalid',
+  DOCUMENT_INVALID: 'invalid',
+  EMOJI_STATUS_INVALID: 'invalid',
+  FLOOD_WAIT: 'flood',
+};
+
+const failure = quietFailureOf(CODES);
+const bad = (code = 'bad-request') => ({ ok: false, error: code, code });
+
+const CHANNEL = /^-100\d{1,20}$/;
+const NAME = /^[A-Za-z][A-Za-z0-9_]{3,30}[A-Za-z0-9]$/;
+const EMOJI = /^\d{1,20}$/;
+const MAX_COLOR = 20;
+const MAX_LEAVE = 100;
+const MAX_UNTIL_SECONDS = 366 * 24 * 3600;
+
+const text = (value) => String(value?.value ?? value);
+const idOf = (raw) => `-100${text(raw.id)}`;
+
+const nameOk = (username) =>
+  typeof username === 'string' && (username === '' || NAME.test(username));
+
+const colorOk = ({ forProfile, color, emoji }) =>
+  typeof forProfile === 'boolean' &&
+  (color === undefined ||
+    (Number.isInteger(color) && color >= 0 && color <= MAX_COLOR)) &&
+  (emoji === undefined || EMOJI.test(String(emoji)));
+
+const statusOk = (r, seconds) =>
+  (r.documentId === null || EMOJI.test(String(r.documentId))) &&
+  (r.until === undefined ||
+    (Number.isInteger(r.until) &&
+      r.until > seconds &&
+      r.until <= seconds + MAX_UNTIL_SECONDS));
+
+const publicOf = (raw) =>
+  raw?.className === 'Channel'
+    ? { chat: idOf(raw), title: raw.title ?? '', username: raw.username ?? '' }
+    : null;
+
+const inactiveOf = (answer) =>
+  (answer?.chats ?? [])
+    .map((raw, i) => ({ raw, date: Number(answer.dates?.[i]) || 0 }))
+    .filter(({ raw }) => raw?.className === 'Channel');
+
+// The shared helpers of the actions below.
+const kitOf = (env, userClient) => {
+  const ask = (c, key, request) =>
+    runIn(env, `channel-manage:${key}`, () => c.client.invoke(request));
+  const withChannel = (c, chat, use) =>
+    runIn(env, `channel-manage:${chat}`, () =>
+      env.connection.withPeer(c.client, chat, use)
+    );
+  // An action that runs `use(request)(c)` for a request that passed `valid`.
+  const guarded = (valid, use) => async (request) =>
+    valid(request ?? {})
+      ? connected(env, userClient, failure, use(request ?? {}))
+      : bad();
+  // An action of one request on the chat's channel.
+  const onChannel = (valid, make) =>
+    guarded(
+      (r) => CHANNEL.test(String(r.chat ?? '')) && valid(r),
+      (r) => async (c) => {
+        await withChannel(c, String(r.chat), (peer) =>
+          c.client.invoke(make(c, peer, r))
+        );
+        return { ok: true };
+      }
+    );
+  const plain = (use) => async () =>
+    connected(env, userClient, failure, async (c) => ({
+      ok: true,
+      ...(await use(c)),
+    }));
+  const admined = async (c) =>
+    (
+      (await ask(c, 'admined', new c.Api.channels.GetAdminedPublicChannels({})))
+        ?.chats ?? []
+    ).filter((x) => x?.className === 'Channel');
+  // The inactive channels Telegram lists, with their dates.
+  const inactive = async (c) =>
+    inactiveOf(
+      await ask(c, 'inactive', new c.Api.channels.GetInactiveChannels())
+    );
+  return { ask, withChannel, guarded, onChannel, plain, admined, inactive };
+};
+
+const createPublicLink = ({
+  ask,
+  withChannel,
+  guarded,
+  onChannel,
+  admined,
+  plain,
+}) => ({
+  channelUsernameCheck: guarded(
+    (r) => CHANNEL.test(String(r.chat ?? '')) && NAME.test(r.username ?? ''),
+    (r) => async (c) => {
+      const free = await withChannel(c, String(r.chat), (peer) =>
+        c.client.invoke(
+          new c.Api.channels.CheckUsername({
+            channel: peer,
+            username: r.username,
+          })
+        )
+      );
+      return free === false ? bad('taken') : { ok: true, status: 'available' };
+    }
+  ),
+  channelUsernameSave: onChannel(
+    (r) => nameOk(r.username),
+    (c, peer, r) =>
+      new c.Api.channels.UpdateUsername({
+        channel: peer,
+        username: r.username,
+      })
+  ),
+  publicChannels: plain(async (c) => ({
+    channels: (await admined(c)).map(publicOf).filter(Boolean),
+  })),
+  publicLinkRevoke: guarded(
+    (r) => CHANNEL.test(String(r.chat ?? '')),
+    (r) => async (c) => {
+      const found = (await admined(c)).find((x) => idOf(x) === r.chat);
+      if (!found) {
+        return bad('no-access');
+      }
+      await ask(
+        c,
+        'revoke',
+        new c.Api.channels.UpdateUsername({
+          channel: new c.Api.InputChannel({
+            channelId: found.id,
+            accessHash: found.accessHash,
+          }),
+          username: '',
+        })
+      );
+      return { ok: true };
+    }
+  ),
+  usernamesDeactivate: onChannel(
+    () => true,
+    (c, peer) => new c.Api.channels.DeactivateAllUsernames({ channel: peer })
+  ),
+});
+
+const createLook = (env, { onChannel }) => ({
+  channelColorSave: onChannel(colorOk, (c, peer, r) => {
+    const { forProfile, color, emoji } = r;
+    return new c.Api.channels.UpdateColor({
+      channel: peer,
+      ...(forProfile ? { forProfile: true } : {}),
+      ...(color === undefined ? {} : { color }),
+      ...(emoji === undefined
+        ? {}
+        : { backgroundEmojiId: c.helpers.returnBigInt(String(emoji)) }),
+    });
+  }),
+  channelEmojiStatusSet: onChannel(
+    (r) => statusOk(r, (env.now ?? Date.now)() / 1000),
+    (c, peer, r) =>
+      new c.Api.channels.UpdateEmojiStatus({
+        channel: peer,
+        emojiStatus:
+          r.documentId === null
+            ? new c.Api.EmojiStatusEmpty()
+            : new c.Api.EmojiStatus({
+                documentId: c.helpers.returnBigInt(String(r.documentId)),
+                ...(r.until === undefined ? {} : { until: r.until }),
+              }),
+      })
+  ),
+});
+
+const createInactive = ({ ask, guarded, plain, inactive }) => ({
+  inactiveChannels: plain(async (c) => ({
+    channels: (await inactive(c)).map(({ raw, date }) => ({
+      chat: idOf(raw),
+      title: raw.title ?? '',
+      date,
+      broadcast: Boolean(raw.broadcast),
+    })),
+  })),
+  leaveChannels: guarded(
+    (r) =>
+      Array.isArray(r.chats) &&
+      r.chats.length > 0 &&
+      r.chats.length <= MAX_LEAVE &&
+      r.chats.every((x) => CHANNEL.test(String(x))),
+    (r) => async (c) => {
+      const listed = new Map(
+        (await inactive(c)).map((x) => [idOf(x.raw), x.raw])
+      );
+      const left = [];
+      for (const chat of new Set(r.chats.map(String))) {
+        const raw = listed.get(chat);
+        if (raw) {
+          await ask(
+            c,
+            'leave',
+            new c.Api.channels.LeaveChannel({
+              channel: new c.Api.InputChannel({
+                channelId: raw.id,
+                accessHash: raw.accessHash,
+              }),
+            })
+          );
+          left.push(chat);
+        }
+      }
+      return { ok: true, left };
+    }
+  ),
+});
+
+export const createChannelManage = (env, { userClient }) => {
+  const kit = kitOf(env, userClient);
+  return {
+    ...createPublicLink(kit),
+    ...createLook(env, kit),
+    ...createInactive(kit),
+  };
+};

package/js/src/sources/telegram-chat-info.js

@@ -24,6 +24,7 @@ import { settingsInfo } from './telegram-chat-settings.js';
 import { birthdayOf, colorOf } from './telegram-profile-extras.js';
 import { monoforumInfo } from './telegram-channel-dm-shape.js';
 import { groupStickersInfo } from './telegram-group-extras.js';
+import { statusOf as emojiStatusOf } from './telegram-emoji-status.js';
 import { ALL_ADMIN_RIGHTS } from './telegram-admin-rights.js';
 
 const CHAT = /^-?\d{1,20}$/;
@@ -166,6 +167,20 @@ const usernamesInfo = (entity) => {
     : {};
 };
 
+// A channel's name colour, profile colour and emoji status, for those who
+// may change them (R-Y216): the creator, or an admin with the change-info right.
+const lookInfo = (entity) =>
+  entity.creator || entity.adminRights?.changeInfo
+    ? {
+        canAppearance: true,
+        look: {
+          color: colorOf(entity.color),
+          profileColor: colorOf(entity.profileColor),
+          status: emojiStatusOf(entity.emojiStatus),
+        },
+      }
+    : {};
+
 // What the user may do with administrators and the history new members see
 // (R-Y204): their own rights (the creator has all), who may add admins, and
 // whether the history is hidden from new members.
@@ -288,6 +303,7 @@ const fetchChannel = async (client, Api, inputPeer, peers) => {
     ...wallpaperOf(full),
     ...usernamesInfo(entity),
     ...collectibleOf(entity),
+    ...lookInfo(entity),
     ...inviteOf(entity, full),
     // The group's sticker set and emoji pack (R-Y211).
     ...groupStickersInfo(entity, full),

package/js/src/sources/telegram-chat-removal.js

@@ -12,6 +12,9 @@
  * - `leave` — a basic group: the user leaves it (messages.deleteChatUser)
  *   and its history goes; a supergroup or channel:
  *   channels.leaveChannel.
+ * - `destroy` — the owner deletes a group or channel for everyone
+ *   (channels.deleteChannel, messages.deleteChat; R-Y216), no undo; the
+ *   chat leaves the list like a left one.
  *
  * Telegram deletes history a part at a time (`offset` says there is
  * more); it is asked again until done. The chat's stored messages are
@@ -25,7 +28,12 @@
 import { markDeleted as tombstone } from '../storage/soft-delete.js';
 
 const SOURCE = 'telegram';
-export const REMOVAL_ACTIONS = Object.freeze(['clear', 'delete', 'leave']);
+export const REMOVAL_ACTIONS = Object.freeze([
+  'clear',
+  'delete',
+  'leave',
+  'destroy',
+]);
 const MAX_ROUNDS = 100;
 
 const kindOf = (chat) => {
@@ -42,7 +50,7 @@ export const removalAllowed = (chat, action) => {
   if (action === 'delete') {
     return kind === 'personal';
   }
-  if (action === 'leave') {
+  if (action === 'leave' || action === 'destroy') {
     return kind !== 'personal';
   }
   return action === 'clear';
@@ -84,6 +92,9 @@ export const createChatRemoval = (env, { userClient, apply }) => {
   };
 
   const askChannel = async (client, Api, peer, { action, chat }) => {
+    if (action === 'destroy') {
+      return client.invoke(new Api.channels.DeleteChannel({ channel: peer }));
+    }
     if (action === 'leave') {
       return client.invoke(new Api.channels.LeaveChannel({ channel: peer }));
     }
@@ -101,6 +112,14 @@ export const createChatRemoval = (env, { userClient, apply }) => {
     if (kind === 'channel') {
       return askChannel(client, Api, peer, { action, chat });
     }
+    if (kind === 'group' && action === 'destroy') {
+      const { helpers } = await env.importer();
+      return client.invoke(
+        new Api.messages.DeleteChat({
+          chatId: helpers.returnBigInt(String(chat).slice(1)),
+        })
+      );
+    }
     if (kind === 'group' && action === 'leave') {
       const { helpers } = await env.importer();
       const left = await client.invoke(