meta-sovereign 0.49.14 → 0.49.16

package/js/src/server/background-jobs.js

@@ -78,14 +78,16 @@ export const backgroundJobs = ({ ctx, store, log, later, backups }) => {
   });
   const purge = cachePurgeFor({ store, log, later });
   return {
+    // Returns a promise settled once a backup in flight has finished.
     stopJobs: () => {
-      backup.stopBackups();
+      const backupDone = backup.stopBackups();
       audience.stopAudienceSync();
       purge.stopCachePurge();
       // The other timers and pollers the server started with the port.
       ctx.autoImport?.close();
       ctx.whatsappSignIn?.stop().catch(() => {});
       ctx.stopPulls?.();
+      return backupDone;
     },
   };
 };

package/js/src/server/backup-job.js

@@ -87,5 +87,6 @@ export const backupJobFor = ({ ctx, store, log, later, backups }) => {
       });
     });
   }
+  // Resolves once a backup in flight has finished (and pruned).
   return { stopBackups: () => scheduler?.stop() };
 };

package/js/src/server/index.js

@@ -916,13 +916,13 @@ export const startServer = async ({
         bus?.close();
         ctx.replies.close().catch(() => {});
         ctx.closeAutomations().catch(() => {});
-        ctx.stopJobs();
+        const jobsDone = ctx.stopJobs();
         ctx.chatIndex.close();
         stopAll(telegramAccount, ctx.telegramAccounts, ctx.telegramExtras);
         wsHandle?.close();
         signaling?.close();
         closeFront();
-        server.close(() => resolve());
+        server.close(() => Promise.resolve(jobsDone).then(resolve, resolve));
         for (const socket of sockets) {
           socket.destroy();
         }

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-contact-extras.js

@@ -0,0 +1,102 @@
+// Contact notes, share-my-contact links, phone links, photos for contacts,
+// suggested birthdays, synced contacts and blocking from Replies (R-Y217):
+// the routes of the POSTS table in routes-telegram.js, each validated
+// strictly before the account is asked.
+//
+// Its routes:
+//   POST /api/telegram/contact-note {chat, note} -> { ok, note } the private
+//                       note on a contact (at most 128 characters, "" clears)
+//   POST /api/telegram/contact-token {} -> { ok, url, expires } the link
+//                       t.me/contact/<token> to share the user's contact
+//   POST /api/telegram/contact-token-open {token} -> { ok, chat, name } the
+//                       person that link names
+//   POST /api/telegram/phone-resolve {phone} -> { ok, found, chat?, name? }
+//                       the person with that number (t.me/+<digits>)
+//   POST /api/telegram/contact-photo {chat, mode, token?} -> { ok, mode }
+//                       mode save (only the user sees it), suggest, or reset
+//                       (the personal photo removed; no token)
+//   POST /api/telegram/birthday-suggest {chat, day, month, year?} -> { ok }
+//   POST /api/telegram/saved-contacts {} -> { ok, count } the imported
+//                       contacts Telegram keeps
+//   POST /api/telegram/saved-contacts-reset {} -> { ok } those deleted
+//   POST /api/telegram/block-from-replies {msgId, deleteMessage?,
+//                       deleteHistory?, reportSpam?} -> { ok } the sender
+//                       of a message of the Replies chat blocked
+
+import { route } from './routes-telegram-admin-extras.js';
+import {
+  MODES,
+  NOTE_MAX,
+  PHONE_DIGITS,
+  TOKEN,
+  USER,
+  validMsgId,
+} from '../sources/telegram-contact-extras.js';
+
+const UPLOAD = /^[a-f0-9]{32}$/;
+const user = (b) => USER.test(String(b.chat ?? ''));
+const flag = (v) => v === undefined || typeof v === 'boolean';
+const always = () => true;
+
+export const CONTACT_EXTRAS_POSTS = {
+  'contact-note': route(
+    'contactNote',
+    'chat and note required',
+    (b) => user(b) && typeof b.note === 'string' && b.note.length <= NOTE_MAX,
+    (b) => ({ chat: String(b.chat), note: b.note })
+  ),
+  'contact-token': route('contactToken', 'unsupported', always, () => ({})),
+  'contact-token-open': route(
+    'contactTokenOpen',
+    'token required',
+    (b) => typeof b.token === 'string' && TOKEN.test(b.token),
+    (b) => ({ token: b.token })
+  ),
+  'phone-resolve': route(
+    'phoneResolve',
+    'phone required',
+    (b) =>
+      typeof b.phone === 'string' &&
+      PHONE_DIGITS.test(b.phone.replace(/^\+/, '')),
+    (b) => ({ phone: b.phone })
+  ),
+  'contact-photo': route(
+    'contactPhoto',
+    'chat, mode and token required',
+    (b) =>
+      user(b) &&
+      MODES.includes(b.mode) &&
+      (b.mode === 'reset'
+        ? b.token === undefined
+        : typeof b.token === 'string' && UPLOAD.test(b.token)),
+    (b) => ({ chat: String(b.chat), mode: b.mode, token: b.token })
+  ),
+  'birthday-suggest': route(
+    'birthdaySuggest',
+    'chat, day and month required',
+    (b) => user(b) && Number.isInteger(b.day) && Number.isInteger(b.month),
+    ({ chat, day, month, year }) => ({ chat: String(chat), day, month, year })
+  ),
+  'saved-contacts': route('savedContacts', 'unsupported', always, () => ({})),
+  'saved-contacts-reset': route(
+    'savedContactsReset',
+    'unsupported',
+    always,
+    () => ({})
+  ),
+  'block-from-replies': route(
+    'blockFromReplies',
+    'msgId required',
+    (b) =>
+      validMsgId(b.msgId) &&
+      flag(b.deleteMessage) &&
+      flag(b.deleteHistory) &&
+      flag(b.reportSpam),
+    ({ msgId, deleteMessage, deleteHistory, reportSpam }) => ({
+      msgId,
+      deleteMessage,
+      deleteHistory,
+      reportSpam,
+    })
+  ),
+};

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-security-extras.js

@@ -0,0 +1,64 @@
+// More of Privacy and Security (R-Y218): the routes of the POSTS table in
+// routes-telegram.js, each validated strictly before the account is asked.
+// A code in a body is passed on and never kept.
+//
+// Its routes:
+//   POST /api/telegram/login-email-send {email} -> { ok, pattern, length }
+//   POST /api/telegram/login-email-verify {code} -> { ok, email }
+//   POST /api/telegram/recovery-request -> { ok, pattern } a code mailed to
+//                       the recovery email
+//   POST /api/telegram/recovery-confirm {code} -> { ok } the password gone
+//   POST /api/telegram/password-reset -> { ok, result: 'ok' | 'wait' |
+//                       'failed-wait', until }
+//   POST /api/telegram/password-reset-cancel -> { ok }
+//   POST /api/telegram/passkeys -> { ok, passkeys: [{ id, name, created,
+//                       lastUsed }] }
+//   POST /api/telegram/passkey-options -> { ok, options } WebAuthn JSON
+//   POST /api/telegram/passkey-register {id, rawId, clientData,
+//                       attestation} -> { ok, passkey } (base64url strings)
+//   POST /api/telegram/passkey-delete {id} -> { ok }
+//   POST /api/telegram/sign-in-codes -> { ok, codes } fresh codes from 777000
+//   POST /api/telegram/invalidate-codes {codes: ['12345']} -> { ok }
+
+import { route } from './routes-telegram-admin-extras.js';
+
+const EMAIL = /^[^\s@]{1,64}@[^\s@]{1,255}$/;
+const CODE = /^[0-9A-Za-z]{1,16}$/;
+const str = (v, max) =>
+  typeof v === 'string' && v.length > 0 && v.length <= max;
+const nothing = () => true;
+const code = (b) => CODE.test(String(b.code ?? ''));
+
+export const SECURITY_EXTRAS_POSTS = {
+  'login-email-send': route('loginEmailSend', 'a valid email required', (b) =>
+    EMAIL.test(String(b.email ?? ''))
+  ),
+  'login-email-verify': route('loginEmailVerify', 'the code required', code),
+  'recovery-request': route('recoveryRequest', 'no body', nothing),
+  'recovery-confirm': route('recoveryConfirm', 'the code required', code),
+  'password-reset': route('passwordReset', 'no body', nothing),
+  'password-reset-cancel': route('passwordResetCancel', 'no body', nothing),
+  passkeys: route('passkeys', 'no body', nothing),
+  'passkey-options': route('passkeyOptions', 'no body', nothing),
+  'passkey-register': route(
+    'passkeyRegister',
+    'id, rawId, clientData and attestation required',
+    (b) =>
+      ['id', 'rawId', 'clientData', 'attestation'].every((k) =>
+        str(b[k], 100_000)
+      )
+  ),
+  'passkey-delete': route('passkeyDelete', 'the passkey id required', (b) =>
+    str(b.id, 1024)
+  ),
+  'sign-in-codes': route('signInCodes', 'no body', nothing),
+  'invalidate-codes': route(
+    'invalidateCodes',
+    'one to ten codes required',
+    (b) =>
+      Array.isArray(b.codes) &&
+      b.codes.length > 0 &&
+      b.codes.length <= 10 &&
+      b.codes.every((v) => /^\d{5,6}$/.test(String(v)))
+  ),
+};

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,
@@ -242,6 +243,7 @@ import { FOLDER_EDIT_POSTS } from './routes-telegram-folder-edit.js';
 import { CHATLIST_POSTS } from './routes-telegram-chatlists.js';
 import { STICKER_SETTINGS_POSTS } from './routes-telegram-sticker-settings.js';
 import { CHAT_THEME_POSTS } from './routes-telegram-chat-themes.js';
+import { CONTACT_EXTRAS_POSTS } from './routes-telegram-contact-extras.js';
 import { CLOUD_THEME_POSTS } from './routes-telegram-cloud-themes.js';
 import { COMMON_CHATS_POSTS } from './routes-telegram-common-chats.js';
 import { STATS_POSTS } from './routes-telegram-stats.js';
@@ -266,6 +268,7 @@ import { EMOJI_STATUS_POSTS } from './routes-telegram-emoji-status.js';
 import { ROUND_POSTS } from './routes-telegram-round.js';
 import { PRIVACY_POSTS } from './routes-telegram-privacy.js';
 import { SECURITY_POSTS } from './routes-telegram-security.js';
+import { SECURITY_EXTRAS_POSTS } from './routes-telegram-security-extras.js';
 import { SHARE_POSTS } from './routes-telegram-share.js';
 import { INLINE_POSTS } from './routes-telegram-inline.js';
 import { MESSAGE_LINK_POSTS } from './routes-telegram-message-links.js';
@@ -1020,6 +1023,8 @@ const POSTS = {
       : [400, { error: 'chat and a change required', code: 'bad-request' }],
   ...ADMIN_POSTS,
   ...EPHEMERAL_POSTS,
+  ...YEXTRAS_POSTS,
+  ...CONTACT_EXTRAS_POSTS,
   ...GROUP_EXTRAS_POSTS,
   ...INSTANT_VIEW_POSTS,
   ...STICKER_EXTRAS_POSTS,
@@ -1069,6 +1074,7 @@ const POSTS = {
   ...ROUND_POSTS,
   ...PRIVACY_POSTS,
   ...SECURITY_POSTS,
+  ...SECURITY_EXTRAS_POSTS,
   ...SHARE_POSTS,
   ...INLINE_POSTS,
   ...TTL_POSTS,