Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/usr/local/lib/node_modules/homebridge-camera-ui/node_modules/telegraf/lib/core/network/   drwxr-xr-x
Free 13.26 GB of 57.97 GB (22.87%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     client.js (9.63 KB)      -rw-r--r--

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/* eslint @typescript-eslint/restrict-template-expressions: [ "error", { "allowNumber": true, "allowBoolean": true } ] */
const crypto = require("crypto");
const fs = require("fs");
const https = require("https");
const path = require("path");
const node_fetch_1 = require("node-fetch");
const check_1 = require("../helpers/check");
const compact_1 = require("../helpers/compact");
const multipart_stream_1 = require("./multipart-stream");
const error_1 = require("./error");
const url_1 = require("url");
// eslint-disable-next-line @typescript-eslint/no-var-requires
const debug = require('debug')('telegraf:client');
const { isStream } = multipart_stream_1.default;
const WEBHOOK_REPLY_METHOD_ALLOWLIST = new Set([
    'answerCallbackQuery',
    'answerInlineQuery',
    'deleteMessage',
    'leaveChat',
    'sendChatAction',
]);
const DEFAULT_EXTENSIONS = {
    audio: 'mp3',
    photo: 'jpg',
    sticker: 'webp',
    video: 'mp4',
    animation: 'mp4',
    video_note: 'mp4',
    voice: 'ogg',
};
const DEFAULT_OPTIONS = {
    apiRoot: 'https://api.telegram.org',
    apiMode: 'bot',
    webhookReply: true,
    agent: new https.Agent({
        keepAlive: true,
        keepAliveMsecs: 10000,
    }),
    attachmentAgent: undefined,
};
function includesMedia(payload) {
    return Object.values(payload).some((value) => {
        if (Array.isArray(value)) {
            return value.some(({ media }) => media && typeof media === 'object' && (media.source || media.url));
        }
        return (value &&
            typeof value === 'object' &&
            (((0, check_1.hasProp)(value, 'source') && value.source) ||
                ((0, check_1.hasProp)(value, 'url') && value.url) ||
                ((0, check_1.hasPropType)(value, 'media', 'object') &&
                    (((0, check_1.hasProp)(value.media, 'source') && value.media.source) ||
                        ((0, check_1.hasProp)(value.media, 'url') && value.media.url)))));
    });
}
function replacer(_, value) {
    if (value == null)
        return undefined;
    return value;
}
function buildJSONConfig(payload) {
    return Promise.resolve({
        method: 'POST',
        compress: true,
        headers: { 'content-type': 'application/json', connection: 'keep-alive' },
        body: JSON.stringify(payload, replacer),
    });
}
const FORM_DATA_JSON_FIELDS = [
    'results',
    'reply_markup',
    'mask_position',
    'shipping_options',
    'errors',
];
async function buildFormDataConfig(payload, agent) {
    for (const field of FORM_DATA_JSON_FIELDS) {
        if ((0, check_1.hasProp)(payload, field) && typeof payload[field] !== 'string') {
            payload[field] = JSON.stringify(payload[field]);
        }
    }
    const boundary = crypto.randomBytes(32).toString('hex');
    const formData = new multipart_stream_1.default(boundary);
    const tasks = Object.keys(payload).map((key) => attachFormValue(formData, key, payload[key], agent));
    await Promise.all(tasks);
    return {
        method: 'POST',
        compress: true,
        headers: {
            'content-type': `multipart/form-data; boundary=${boundary}`,
            connection: 'keep-alive',
        },
        body: formData,
    };
}
async function attachFormValue(form, id, value, agent) {
    if (value == null) {
        return;
    }
    if (typeof value === 'string' ||
        typeof value === 'boolean' ||
        typeof value === 'number') {
        form.addPart({
            headers: { 'content-disposition': `form-data; name="${id}"` },
            body: `${value}`,
        });
        return;
    }
    if (id === 'thumb') {
        const attachmentId = crypto.randomBytes(16).toString('hex');
        await attachFormMedia(form, value, attachmentId, agent);
        return form.addPart({
            headers: { 'content-disposition': `form-data; name="${id}"` },
            body: `attach://${attachmentId}`,
        });
    }
    if (Array.isArray(value)) {
        const items = await Promise.all(value.map(async (item) => {
            if (typeof item.media !== 'object') {
                return await Promise.resolve(item);
            }
            const attachmentId = crypto.randomBytes(16).toString('hex');
            await attachFormMedia(form, item.media, attachmentId, agent);
            return { ...item, media: `attach://${attachmentId}` };
        }));
        return form.addPart({
            headers: { 'content-disposition': `form-data; name="${id}"` },
            body: JSON.stringify(items),
        });
    }
    if (value &&
        typeof value === 'object' &&
        (0, check_1.hasProp)(value, 'media') &&
        (0, check_1.hasProp)(value, 'type') &&
        typeof value.media !== 'undefined' &&
        typeof value.type !== 'undefined') {
        const attachmentId = crypto.randomBytes(16).toString('hex');
        await attachFormMedia(form, value.media, attachmentId, agent);
        return form.addPart({
            headers: { 'content-disposition': `form-data; name="${id}"` },
            body: JSON.stringify({
                ...value,
                media: `attach://${attachmentId}`,
            }),
        });
    }
    return await attachFormMedia(form, value, id, agent);
}
async function attachFormMedia(form, media, id, agent) {
    var _a, _b, _c;
    let fileName = (_a = media.filename) !== null && _a !== void 0 ? _a : `${id}.${(_b = DEFAULT_EXTENSIONS[id]) !== null && _b !== void 0 ? _b : 'dat'}`;
    if (media.url !== undefined) {
        const res = await (0, node_fetch_1.default)(media.url, { agent });
        return form.addPart({
            headers: {
                'content-disposition': `form-data; name="${id}"; filename="${fileName}"`,
            },
            body: res.body,
        });
    }
    if (media.source) {
        let mediaSource = media.source;
        if (fs.existsSync(media.source)) {
            fileName = (_c = media.filename) !== null && _c !== void 0 ? _c : path.basename(media.source);
            mediaSource = fs.createReadStream(media.source);
        }
        if (isStream(mediaSource) || Buffer.isBuffer(mediaSource)) {
            form.addPart({
                headers: {
                    'content-disposition': `form-data; name="${id}"; filename="${fileName}"`,
                },
                body: mediaSource,
            });
        }
    }
}
async function answerToWebhook(response, payload, options) {
    if (!includesMedia(payload)) {
        if (!response.headersSent) {
            response.setHeader('content-type', 'application/json');
        }
        response.end(JSON.stringify(payload), 'utf-8');
        return true;
    }
    const { headers, body } = await buildFormDataConfig(payload, options.attachmentAgent);
    if (!response.headersSent) {
        for (const [key, value] of Object.entries(headers)) {
            response.setHeader(key, value);
        }
    }
    await new Promise((resolve) => {
        response.on('finish', resolve);
        body.pipe(response);
    });
    return true;
}
function redactToken(error) {
    error.message = error.message.replace(/\/(bot|user)(\d+):[^/]+\//, '/$1$2:[REDACTED]/');
    throw error;
}
class ApiClient {
    constructor(token, options, response) {
        this.token = token;
        this.response = response;
        this.options = {
            ...DEFAULT_OPTIONS,
            ...(0, compact_1.compactOptions)(options),
        };
        if (this.options.apiRoot.startsWith('http://')) {
            this.options.agent = undefined;
        }
    }
    /**
     * If set to `true`, first _eligible_ call will avoid performing a POST request.
     * Note that such a call:
     * 1. cannot report errors or return meaningful values,
     * 2. resolves before bot API has a chance to process it,
     * 3. prematurely confirms the update as processed.
     *
     * https://core.telegram.org/bots/faq#how-can-i-make-requests-in-response-to-updates
     * https://github.com/telegraf/telegraf/pull/1250
     */
    set webhookReply(enable) {
        this.options.webhookReply = enable;
    }
    get webhookReply() {
        return this.options.webhookReply;
    }
    async callApi(method, payload, { signal } = {}) {
        const { token, options, response } = this;
        if (options.webhookReply &&
            (response === null || response === void 0 ? void 0 : response.writableEnded) === false &&
            WEBHOOK_REPLY_METHOD_ALLOWLIST.has(method)) {
            debug('Call via webhook', method, payload);
            // @ts-expect-error
            return await answerToWebhook(response, { method, ...payload }, options);
        }
        if (!token) {
            throw new error_1.default({
                error_code: 401,
                description: 'Bot Token is required',
            });
        }
        debug('HTTP call', method, payload);
        const config = includesMedia(payload)
            ? await buildFormDataConfig({ method, ...payload }, options.attachmentAgent)
            : await buildJSONConfig(payload);
        const apiUrl = new url_1.URL(`./${options.apiMode}${token}/${method}`, options.apiRoot);
        config.agent = options.agent;
        config.signal = signal;
        const res = await (0, node_fetch_1.default)(apiUrl, config).catch(redactToken);
        if (res.status >= 500) {
            const errorPayload = {
                error_code: res.status,
                description: res.statusText,
            };
            throw new error_1.default(errorPayload, { method, payload });
        }
        const data = await res.json();
        if (!data.ok) {
            debug('API call failed', data);
            throw new error_1.default(data, { method, payload });
        }
        return data.result;
    }
}
exports.default = ApiClient;