rsshub 1.0.0-master.fb6d4f3 → 1.0.0-master.fb7e42c

package/lib/routes/telegram/tglib/channel.ts

@@ -1,160 +1,191 @@
-import InvalidParameterError from '@/errors/types/invalid-parameter';
-import { client, decodeMedia, getClient, getFilename, getMediaLink, streamDocument, streamThumbnail } from './client';
-import { returnBigInt } from 'telegram/Helpers.js';
-import { HTMLParser } from 'telegram/extensions/html.js';
+/* eslint-disable no-await-in-loop */
 import { DataItem } from '@/types';
-import type { Api } from 'telegram';
+import { Context } from 'hono';
+import { Api } from 'telegram';
+import { HTMLParser } from 'telegram/extensions/html.js';
+import { getClient, getDocument, getFilename, unwrapMedia } from './client';
+import { getDisplayName } from 'telegram/Utils.js';
+import cache from '@/utils/cache';
+import { returnBigInt } from 'telegram/Helpers.js';
 
-function parseRange(range, length) {
-    if (!range) {
-        return [];
+export function getGeoLink(geo: Api.GeoPoint) {
+    return `<a href="https://www.google.com/maps/search/?api=1&query=${geo.lat}%2C${geo.long}" target="_blank">Geo LatLon: ${geo.lat}, ${geo.long}</a>`;
+}
+
+export async function getPollResults(client, message, m: Api.MessageMediaPoll) {
+    const resultsUpdateResponse = await client.invoke(new Api.messages.GetPollResults({ peer: message.peerId, msgId: message.id }));
+    let results: Api.PollResults;
+    if (resultsUpdateResponse?.updates[0] instanceof Api.UpdateMessagePoll) {
+        results = resultsUpdateResponse.updates[0].results as Api.PollResults;
     }
-    const [typ, segstr] = range.split('=');
-    if (typ !== 'bytes') {
-        throw new InvalidParameterError(`unsupported range: ${typ}`);
+    const txt = `<h4>${m.poll.quiz ? 'Quiz' : 'Poll'}: ${m.poll.question.text}</h4>
+        <div><ul>${m.poll.answers
+            .map((a) => {
+                let answerTxt = a.text.text;
+                const result = results.results?.find((r) => r.option.buffer === a.option.buffer);
+                if (result && results.totalVoters) {
+                    answerTxt = `<strong>${Math.round((result.voters / results.totalVoters) * 100)}%</strong>: ${answerTxt}`;
+                }
+                return `<li>${answerTxt}</li>`;
+            })
+            .join('')}</ul></div>
+    `;
+    return txt;
+}
+
+export function getMediaLink(src: string, m: Api.TypeMessageMedia) {
+    const doc = getDocument(m);
+    const mime = doc ? doc.mimeType : '';
+
+    if (m instanceof Api.MessageMediaPhoto || mime.startsWith('image/')) {
+        return `<img src="${src}" alt=""/>`;
     }
-    const segs = segstr.split(',').map((s) => s.trim());
-    const parsedSegs = [];
-    for (const seg of segs) {
-        const range = seg
-            .split('-', 2)
-            .filter((v) => !!v)
-            .map((elem) => returnBigInt(elem));
-        if (range.length < 2) {
-            if (seg.startsWith('-')) {
-                range.unshift(0);
-            } else {
-                range.push(length);
-            }
-        }
-        parsedSegs.push(range);
+    if (doc && mime.startsWith('video/')) {
+        const vid = (doc.attributes.find((t) => t instanceof Api.DocumentAttributeVideo) ?? { w: 1080, h: 720 }) as { w: number; h: number };
+        return `<video controls preload="metadata" poster="${src}?thumb" width="${vid.w / 2}" height="${vid.h / 2}"><source src="${src}" type="${mime}"></video>`;
+    }
+    if (doc && mime.startsWith('audio/')) {
+        return `<div>${getAudioTitle(m)}</div><div><audio src="${src}"></audio></div>`;
     }
-    return parsedSegs;
-}
 
-async function getMedia(ctx) {
-    const media = await decodeMedia(ctx.req.param('username'), ctx.req.param('media'));
-    if (!media) {
-        ctx.status = 500;
-        return ctx.res.end();
+    if (doc && mime.startsWith('application/')) {
+        let linkText = `${getFilename(m)} (${humanFileSize(doc.size.valueOf())})`;
+        if (mime.endsWith('x-tgsticker')) {
+            linkText = ''; // remove filename, it's only an animated sticker
+        }
+        if ((doc.thumbs?.length ?? 0) > 0) {
+            linkText = `<div><img src="${src}?thumb" alt=""/></div><div>${linkText}</div>`;
+        }
+        return `<a href="${src}" target="_blank">${linkText}</a>`;
+    }
+    if ((m instanceof Api.MessageMediaGeo || m instanceof Api.MessageMediaGeoLive) && m.geo instanceof Api.GeoPoint) {
+        return getGeoLink(m.geo);
+    }
+    if (m instanceof Api.MessageMediaWebPage) {
+        return ''; // a link without a document attach, usually is in the message text, so we can skip here
+    }
+    if (m instanceof Api.MessageMediaContact) {
+        return `Contact: <a href="tel:${m.phoneNumber}" target="_blank">${m.firstName} ${m.lastName} ${m.phoneNumber}</a>`;
+        // TODO: download vCard as media ?
     }
-    if (ctx.res.closed) {
-        // console.log(`prematurely closed ${ctx.req.param('media')}`);
-        return;
+    if (m instanceof Api.MessageMediaInvoice) {
+        let description = m.description;
+        if (m.photo?.url) {
+            description = `<img src="${m.photo?.url}" /><br />${description}`;
+        }
+        return `<h4>${m.test ? 'TEST ' : ''}Invoice: ${m.title}</h4><div>${description}</div>`;
     }
 
-    if (media.document) {
-        ctx.status = 200;
-        let stream;
-        if ('thumb' in ctx.req.query()) {
-            try {
-                stream = streamThumbnail(media);
-                ctx.set('Content-Type', 'image/jpeg');
-            } catch {
-                ctx.status = 404;
-                return ctx.res.end();
-            }
-        } else {
-            ctx.set('Content-Type', media.document.mimeType);
-
-            ctx.set('Accept-Ranges', 'bytes');
-            const range = parseRange(ctx.get('Range'), media.document.size - 1);
-            if (range.length > 1) {
-                ctx.status = 416; // range not satisfiable
-                return ctx.res.end();
-            }
-            if (range.length === 1) {
-                // console.log(`${ctx.method} ${ctx.req.url} Range: ${ctx.get('Range')}`);
-                ctx.status = 206; // partial content
-                const [offset, limit] = range[0];
-                ctx.set('Content-Length', limit - offset + 1);
-                ctx.set('Content-Range', `bytes ${offset}-${limit}/${media.document.size}`);
-
-                const stream = streamDocument(media.document, '', offset, limit);
-                for await (const chunk of stream) {
-                    ctx.res.write(chunk);
-                    if (ctx.res.closed) {
-                        break;
-                    }
-                }
-                return ctx.res.end();
-            }
+    return m.className;
+}
 
-            ctx.set('Content-Length', media.document.size);
-            if (media.document.mimeType.startsWith('application/')) {
-                ctx.set('Content-Disposition', `attachment; filename="${encodeURIComponent(getFilename(media))}"`);
-            }
-            stream = streamDocument(media.document);
-        }
-        // const addr = JSON.stringify(ctx.res.socket.address());
-        // console.log(`streaming ${ctx.req.param('media')} to ${addr}`);
+function humanFileSize(size: number) {
+    const i = size === 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
+    return (size / Math.pow(1024, i)).toFixed(2) + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
+}
 
-        for await (const chunk of stream) {
-            if (ctx.res.closed) {
-                // console.log(`closed ${addr}`);
-                break;
-            }
-            // console.log(`writing ${chunk.length / 1024} to ${addr}`);
-            ctx.res.write(chunk);
-        }
-        if ('close' in stream) {
-            stream.close();
+export function getAudioTitle(x: Api.TypeMessageMedia) {
+    if (x instanceof Api.MessageMediaDocument && x.document instanceof Api.Document) {
+        const attr = x.document.attributes.find((x) => x instanceof Api.DocumentAttributeAudio);
+        if (attr) {
+            return `${attr.performer} - ${attr.title} (${humanDuration(attr.duration)})`;
         }
-    } else if (media.photo) {
-        ctx.status = 200;
-        ctx.set('Content-Type', 'image/jpeg');
-        const buf = await client.downloadMedia(media);
-        ctx.res.write(buf);
+    }
+    return getFilename(x);
+}
+
+export function humanDuration(seconds: number) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const remainingSeconds = seconds % 60;
+
+    // Format time components with leading zeros if necessary
+    const paddedMinutes = String(minutes).padStart(2, '0');
+    const paddedSeconds = String(remainingSeconds).padStart(2, '0');
+
+    // Construct the time string conditionally
+    if (hours > 0) {
+        return `${hours}:${paddedMinutes}:${paddedSeconds}`; // Show hours, minutes, and seconds
+    } else if (minutes > 0) {
+        return `${minutes}:${paddedSeconds}`; // Show minutes and seconds
     } else {
-        ctx.status = 415;
-        ctx.write(media.className);
+        return `0:${paddedSeconds}`; // Show only seconds
     }
-    return ctx.res.end();
 }
 
-export default async function handler(ctx) {
-    const { username } = ctx.req.param();
+export default async function handler(ctx: Context) {
     const client = await getClient();
+    const username = ctx.req.param('username');
 
-    const item: DataItem[] = [];
-    const chat = (await client.getInputEntity(username)) as Api.InputPeerChannel;
-    const channelInfo = await client.getEntity(chat);
-
-    if (channelInfo.className !== 'Channel') {
-        throw new Error(`${username} is not a channel`);
+    let peerCache = await cache.get(`telegram:inputEntity:${username}`);
+    if (!peerCache) {
+        const p = await client.getInputEntity(username);
+        peerCache = JSON.stringify(p.toJSON());
+        await cache.set(`telegram:inputEntity:${username}`, peerCache);
     }
+    const peerData = JSON.parse(peerCache, (k, v) => (k === 'channelId' || k === 'accessHash' ? returnBigInt(v) : v));
+    const peer = new Api.InputPeerChannel(peerData);
+
+    const entity = await client.getEntity(peer);
 
     let attachments: string[] = [];
-    const messages = await client.getMessages(chat, { limit: 50 });
+    const messages = await client.getMessages(peer, { limit: 50 });
 
+    let i = 0;
+    const item: DataItem[] = [];
     for (const message of messages) {
-        if (message.media) {
+        let text = message.text; // must not be HTML
+
+        if (message.fwdFrom?.fromId) {
+            const fwdFrom = await client.getEntity(message.fwdFrom.fromId);
+            text = `Forwarded From: ${getDisplayName(fwdFrom)}: ${text}`;
+        }
+        const media = await unwrapMedia(message.media, message.peerId);
+        if (message.media instanceof Api.MessageMediaStory && media) {
+            // if successfully loaded the story
+            const storyFrom = await client.getEntity(message.media.peer);
+            text = `Story From: ${getDisplayName(storyFrom)}: ${text}`;
+        }
+        if (media) {
+            if (media instanceof Api.MessageMediaPoll) {
+                attachments.push(await getPollResults(client, message, media));
+                continue;
+            }
             // messages that have no text are shown as if they're one post
             // because in TG only 1 attachment per message is possible
-            attachments.push(getMediaLink(ctx, chat, username, message));
+            const src = `${new URL(ctx.req.url).origin}/telegram/media/${username}/${message.id}`;
+            attachments.push(getMediaLink(src, media));
         }
-        if (message.text !== '') {
-            let description = attachments.join('\n');
+        if (message.replyMarkup instanceof Api.ReplyInlineMarkup) {
+            for (const buttonRow of message.replyMarkup.rows) {
+                for (const button of buttonRow.buttons) {
+                    if (button instanceof Api.KeyboardButtonUrl) {
+                        attachments.push(`<div><a href="${button.url}" target="_blank">${button.text}</a></div>`);
+                    }
+                }
+            }
+        }
+        if (text !== '' || ++i === messages.length - 1) {
+            let description = attachments.join('<br/>\n');
             attachments = []; // emitting these, buffer other ones
 
-            if (message.text) {
+            if (text) {
                 description += `<p>${HTMLParser.unparse(message.message, message.entities).replaceAll('\n', '<br/>')}</p>`;
             }
 
             const title = message.text ? message.text.slice(0, 80) + (message.text.length > 80 ? '...' : '') : new Date(message.date * 1000).toUTCString();
-
             item.push({
                 title,
                 description,
                 pubDate: new Date(message.date * 1000).toUTCString(),
                 link: `https://t.me/s/${username}/${message.id}`,
-                author: `${channelInfo.title} (@${username})`,
+                author: getDisplayName(message.sender ?? entity),
             });
         }
     }
 
     return {
-        title: channelInfo.title,
+        title: getDisplayName(entity),
         language: null,
         link: `https://t.me/${username}`,
         item,
@@ -162,5 +193,3 @@ export default async function handler(ctx) {
         description: `@${username} on Telegram`,
     };
 }
-
-export { getMedia };

package/lib/routes/telegram/tglib/client.ts

@@ -1,7 +1,6 @@
 import { Api, TelegramClient } from 'telegram';
 import { UserAuthParams } from 'telegram/client/auth';
 import { StringSession } from 'telegram/sessions/index.js';
-import { getAppropriatedPartSize } from 'telegram/Utils.js';
 
 import { config } from '@/config';
 import ConfigNotFoundError from '@/errors/types/config-not-found';
@@ -34,160 +33,59 @@ export async function getClient(authParams?: UserAuthParams, session?: string) {
                 : undefined,
     });
 
-    await client.connect();
+    await client.start(
+        Object.assign(authParams ?? {}, {
+            onError: (err: Error) => {
+                throw new Error('Cannot start TG: ' + err);
+            },
+        }) as any
+    );
     return client;
 }
 
-function humanFileSize(size) {
-    const i = size === 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
-    return (size / Math.pow(1024, i)).toFixed(2) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
-}
-
-/**
- * https://core.telegram.org/api/files#stripped-thumbnails
- * @param bytes Buffer
- * @returns Buffer jpeg
- */
-function ExpandInlineBytes(bytes) {
-    if (bytes.length < 3 || bytes[0] !== 0x1) {
-        return [];
-    }
-    const header = Buffer.from([
-        0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x28, 0x1C, 0x1E, 0x23, 0x1E, 0x19, 0x28, 0x23, 0x21, 0x23, 0x2D, 0x2B,
-        0x28, 0x30, 0x3C, 0x64, 0x41, 0x3C, 0x37, 0x37, 0x3C, 0x7B, 0x58, 0x5D, 0x49, 0x64, 0x91, 0x80, 0x99, 0x96, 0x8F, 0x80, 0x8C, 0x8A, 0xA0, 0xB4, 0xE6, 0xC3, 0xA0, 0xAA, 0xDA, 0xAD, 0x8A, 0x8C, 0xC8, 0xFF, 0xCB, 0xDA, 0xEE,
-        0xF5, 0xFF, 0xFF, 0xFF, 0x9B, 0xC1, 0xFF, 0xFF, 0xFF, 0xFA, 0xFF, 0xE6, 0xFD, 0xFF, 0xF8, 0xFF, 0xDB, 0x00, 0x43, 0x01, 0x2B, 0x2D, 0x2D, 0x3C, 0x35, 0x3C, 0x76, 0x41, 0x41, 0x76, 0xF8, 0xA5, 0x8C, 0xA5, 0xF8, 0xF8, 0xF8,
-        0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8,
-        0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05,
-        0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04,
-        0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1,
-        0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
-        0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
-        0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
-        0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-        0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00,
-        0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62,
-        0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
-        0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
-        0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2,
-        0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3F, 0x00,
-    ]);
-    const footer = Buffer.from([0xFF, 0xD9]);
-    const real = Buffer.alloc(header.length + bytes.length + footer.length);
-    header.copy(real);
-    bytes.copy(real, header.length, 3);
-    bytes.copy(real, 164, 1, 2);
-    bytes.copy(real, 166, 2, 3);
-    footer.copy(real, header.length + bytes.length, 0);
-    return real;
-}
-
-function getMediaLink(ctx, channel: Api.InputPeerChannel, channelName: string, message: Api.Message) {
-    const base = `${ctx.protocol}://${ctx.host}/telegram/channel/${channelName}`;
-    const src = base + `${channel.channelId}_${message.id}`;
-
-    const x = message.media;
-    if (x instanceof Api.MessageMediaPhoto || (x instanceof Api.MessageMediaDocument && x.document.mimeType.startsWith('image/'))) {
-        return `<img src="${src}" alt=""/>`;
-    }
-    if (x instanceof Api.MessageMediaDocument && x.document.mimeType.startsWith('video/')) {
-        const vid = x.document.attributes.find((t) => t.className === 'DocumentAttributeVideo') ?? { w: 1080, h: 720 };
-        return `<video controls preload="metadata" poster="${src}?thumb" width="${vid.w / 2}" height="${vid.h / 2}"><source src="${src}" type="${x.document.mimeType}"></video>`;
-    }
-    if (x instanceof Api.MessageMediaDocument && x.document.mimeType.startsWith('audio/')) {
-        return `<audio src="${src}"></audio>`;
-    }
-
-    let linkText = getFilename(x);
-    if (x instanceof Api.MessageMediaDocument) {
-        linkText += ` (${humanFileSize(x.document.size)})`;
-        return `<a href="${src}" target="_blank"><img src="${src}?thumb" alt=""/><br/>${linkText}</a>`;
-    }
-    return '';
-}
-function getFilename(x) {
+export function getFilename(x: Api.TypeMessageMedia) {
     if (x instanceof Api.MessageMediaDocument) {
-        const docFilename = x.document.attributes.find((a) => a.className === 'DocumentAttributeFilename');
-        if (docFilename) {
-            return docFilename.fileName;
+        for (const a of (x.document as Api.Document).attributes) {
+            if (a instanceof Api.DocumentAttributeFilename) {
+                return a.fileName;
+            }
         }
     }
     return x.className;
 }
 
-function sortThumb(thumb) {
-    if (thumb instanceof Api.PhotoStrippedSize) {
-        return thumb.bytes.length;
+export function getDocument(m: Api.TypeMessageMedia) {
+    if (m instanceof Api.MessageMediaDocument && m.document && !(m.document instanceof Api.DocumentEmpty)) {
+        return m.document;
     }
-    if (thumb instanceof Api.PhotoCachedSize) {
-        return thumb.bytes.length;
+    if (m instanceof Api.MessageMediaWebPage && m.webpage instanceof Api.WebPage && m.webpage.document instanceof Api.Document) {
+        return m.webpage.document;
     }
-    if (thumb instanceof Api.PhotoSize) {
-        return thumb.size;
-    }
-    if (thumb instanceof Api.PhotoSizeProgressive) {
-        return Math.max(...thumb.sizes);
-    }
-    if (thumb instanceof Api.VideoSize) {
-        return thumb.size;
-    }
-    return 0;
 }
 
-function chooseLargestThumb(thumbs) {
-    thumbs = [...thumbs].sort((a, b) => sortThumb(a) - sortThumb(b));
-    return thumbs.pop();
+export async function getStory(entity: Api.TypeEntityLike, id: number) {
+    const result = await (
+        await getClient()
+    ).invoke(
+        new Api.stories.GetStoriesByID({
+            id: [id],
+            peer: entity,
+        })
+    );
+    return result.stories[0] as Api.StoryItem;
 }
 
-function streamThumbnail(x) {
-    if (x instanceof Api.MessageMediaDocument && x.document.thumbs.length > 0) {
-        const size = chooseLargestThumb(x.document.thumbs);
-        if (size instanceof Api.PhotoCachedSize || size instanceof Api.PhotoStrippedSize) {
-            return (function* () {
-                yield ExpandInlineBytes(size.bytes);
-            })();
+export async function unwrapMedia(media: Api.TypeMessageMedia | undefined, backupPeerId?: Api.TypePeer) {
+    if (media instanceof Api.MessageMediaStory) {
+        if (media.story instanceof Api.StoryItem && media.story.media) {
+            return media.story.media;
         }
-        return streamDocument(x.document, size && 'type' in size ? size.type : '');
-    }
-    throw 'not supported';
-}
-
-async function decodeMedia(channelName, x, retry = false) {
-    const [channel, msg] = x.split('_');
-
-    try {
-        const msgs = await client.getMessages(channel, {
-            ids: [Number(msg)],
-        });
-        return msgs[0]?.media;
-    } catch (error) {
-        if (!retry) {
-            // channel likely not seen before, we need to resolve ID and retry
-            await client.getInputEntity(channelName);
-            return decodeMedia(channelName, x, true);
+        let storyItem = await getStory(media.peer, media.id);
+        if (!storyItem?.media && backupPeerId) {
+            // it's possible the story got hidden by the original user, but we've saved it into Saved Messages - we can still get it
+            storyItem = await getStory(backupPeerId, media.id);
         }
-        throw error;
-    }
-}
-
-function streamDocument(obj, thumbSize = '', offset, limit) {
-    const chunkSize = (obj.size ? getAppropriatedPartSize(obj.size) : 64) * 1024;
-    const iterFileParams = {
-        file: new Api.InputDocumentFileLocation({
-            id: obj.id,
-            accessHash: obj.accessHash,
-            fileReference: obj.fileReference,
-            thumbSize,
-        }),
-        chunkSize,
-        dcId: obj.dcId,
-    };
-    if (offset) {
-        iterFileParams.offset = offset;
-    }
-    if (limit) {
-        iterFileParams.limit = limit;
+        return storyItem?.media;
     }
-    return client.iterDownload(iterFileParams);
+    return media;
 }
-
-export { client, getMediaLink, decodeMedia, getFilename, streamDocument, streamThumbnail };

package/lib/routes/tesla/cx.ts

@@ -147,7 +147,7 @@ async function handler(ctx) {
                       alt: item.venueName ?? item.title,
                   }
                 : undefined,
-            description: item.description?.replace(/\["|"]/g, '') ?? undefined,
+            description: item.description?.replaceAll(/\["|"]/g, '') ?? undefined,
             data: item.parkingLocationId
                 ? {
                       title: item.venueName ?? item.title,

package/lib/routes/test/index.ts

@@ -6,6 +6,7 @@ import cache from '@/utils/cache';
 import { fetchArticle } from '@/utils/wechat-mp';
 import ConfigNotFoundError from '@/errors/types/config-not-found';
 import InvalidParameterError from '@/errors/types/invalid-parameter';
+import CaptchaError from '@/errors/types/captcha';
 
 let cacheIndex = 0;
 
@@ -32,6 +33,9 @@ async function handler(ctx) {
     if (ctx.req.param('id') === 'invalid-parameter-error') {
         throw new InvalidParameterError('Test invalid parameter error');
     }
+    if (ctx.req.param('id') === 'captcha-error') {
+        throw new CaptchaError('Test captcha error');
+    }
     if (ctx.req.param('id') === 'redirect') {
         ctx.set('redirect', '/test/1');
         return;

package/lib/routes/thegadgetflow/namespace.ts

@@ -0,0 +1,7 @@
+import type { Namespace } from '@/types';
+
+export const namespace: Namespace = {
+    name: 'Gadget Flow',
+    url: 'thegadgetflow.com',
+    lang: 'en',
+};

package/lib/routes/thegadgetflow/rss.ts

@@ -0,0 +1,99 @@
+import { Route } from '@/types';
+import got from '@/utils/got';
+import { parseDate } from '@/utils/parse-date';
+import { art } from '@/utils/render';
+import path from 'node:path';
+import { load } from 'cheerio';
+import cache from '@/utils/cache';
+
+export const route: Route = {
+    path: '/:category?',
+    categories: ['shopping'],
+    example: '/thegadgetflow/cool-gadgets-gifts',
+    parameters: { category: 'category name, can be found in url' },
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    radar: [
+        {
+            source: ['thegadgetflow.com/categories/:category'],
+            target: '/:category',
+        },
+    ],
+    name: 'Category',
+    maintainers: ['EthanWng97'],
+    handler,
+};
+
+async function handler(ctx) {
+    const baseUrl = 'https://thegadgetflow.com';
+    const categoryApiPath = '/wp-json/wp/v2/categories';
+    const postApiPath = '/wp-json/wp/v2/posts';
+
+    // get category number
+    const categorySlug = ctx.req.param('category') || '';
+
+    let category;
+    if (categorySlug) {
+        category = await cache.tryGet(`${baseUrl}${categoryApiPath}`, async () => {
+            const { data } = await got(`${baseUrl}${categoryApiPath}`, {
+                searchParams: { slug: categorySlug },
+            });
+            if (!data || data.length === 0) {
+                throw new Error(`Category "${categorySlug}" not found`);
+            }
+            return data[0];
+        });
+    }
+
+    const categoryId = category?.id;
+    const categoryName = category?.name;
+    const categoryLink = category?.link;
+
+    // get posts
+    const postsUrl = `${baseUrl}${postApiPath}`;
+    const postsResponse = await got(postsUrl, {
+        searchParams: {
+            per_page: ctx.req.query('limit') ? Number.parseInt(ctx.req.query('limit')) : 10,
+            _embed: '',
+            ...(categoryId && { categories: categoryId }),
+        },
+    });
+
+    const items = postsResponse.data.map((item) => {
+        const featuredMedia = item._embedded?.['wp:featuredmedia']?.find((v) => v.id === item.featured_media);
+        const image = featuredMedia?.source_url;
+        const altText = featuredMedia?.alt_text || featuredMedia?.title?.rendered;
+        let caption;
+        if (featuredMedia?.caption?.rendered) {
+            caption = load(featuredMedia?.caption?.rendered);
+        }
+
+        const single = {
+            title: item.title.rendered,
+            description: art(path.join(__dirname, 'templates/description.art'), {
+                content: item.content.rendered,
+                image,
+                altText,
+                caption: caption?.text() || '',
+            }),
+            link: item.link,
+            pubDate: parseDate(item.date_gmt),
+            updated: parseDate(item.modified_gmt),
+            // image,
+            author: item._embedded.author[0].name,
+        };
+        return single;
+    });
+
+    return {
+        title: categoryName ? `Gadget Flow - ${categoryName}` : 'Gadget Flow',
+        link: categoryLink || `${baseUrl}/${categorySlug}`,
+        item: items,
+    };
+}