index.js

import { TelegramClient } from "telegram"; // npm i telegram
import { Api } from "telegram/tl/index.js";
import { StringSession } from "telegram/sessions/index.js";
import schedule from "node-schedule";
import input from "input"; // npm i input
import { promises as fs } from "fs";
import http from "http";
const port = 3000;
const server = http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Server running...');
});
server.listen(port, () => {
    console.log(`Server running at http://localhost:${port}/`);
});
let config;
try {
    config = JSON.parse((await fs.readFile("./config/config.json")).toString());
}
catch (err) {
    console.log("Unable to load config!");
    console.error(err);
    process.exit(1);
}
let tasks;
try {
    tasks = JSON.parse((await fs.readFile("./config/tasks.json")).toString()).tasks;
}
catch (err) {
    console.log("Unable to load schedule!");
    console.error(err);
    process.exit(1);
}
/* RESUME SESSION */
let stringSession = new StringSession("");
try {
    const sessionJson = JSON.parse((await fs.readFile("./config/session.json")).toString());
    stringSession = new StringSession(sessionJson.stringSession);
}
catch (err) {
    console.log("Unable to load existing session. Time to log in!");
}
/* ESTABLISH TELEGRAM CONNECTION */
(async () => {
    const client = new TelegramClient(stringSession, config.api_id, config.api_hash, {
        connectionRetries: 5,
    });
    await client.start({
        phoneNumber: async () => await input.text("number ?"),
        password: async () => await input.password("password?"),
        phoneCode: async () => await input.text("Code ?"),
        onError: (err) => console.log(err),
    });
    console.log("You should now be connected.");
    await saveSession(client.session.save());
    console.log("Session saved");
    // await checkMuted(client, chatId);
    // await muteChat(client, chatId, 300);
    // SETUP SCHEDULE FOR THE FIRST TIME
    let scheduledJobs = []; // Reference to scheduled Jobs, in order to cancel them all if there are changes
    scheduledJobs = restartSchedule(client, scheduledJobs, tasks);
    /* todo: learn declaration files... */
    /* web request handler */
    // jobs.forEach((job) => {
    //   const next = job.nextInvocation();
    //   console.log(`Task scheduled on: "${next}"`);
    //   // job.invoke();
    // });
})();
function restartSchedule(client, jobs, tasks) {
    clearScheduledJobs(jobs);
    const scheduledJobs = startSchedule(client, tasks);
    return scheduledJobs;
}
function startSchedule(client, tasks) {
    let scheduledJobs = [];
    for (const task of tasks) {
        // console.log(task.name);
        // console.log(task.action);
        // console.log(task.chatId);
        for (const occurance of task.occurances) {
            // console.log(occurance.at);
            // console.log(occurance.durationSeconds);
            const res = schedule.scheduleJob(occurance.at, function () {
                muteChat(client, task.chatId, occurance.durationSeconds);
            });
            scheduledJobs.push(res);
        }
    }
    return scheduledJobs;
}
function clearScheduledJobs(scheduledJobs) {
    for (const scheduledJob of scheduledJobs) {
        if (scheduledJob) {
            scheduledJob.cancel();
        }
    }
}
async function checkMuted(client, chatId) {
    const result = await client.invoke(new Api.account.GetNotifySettings({
        peer: chatId,
    }));
    if (result.muteUntil) {
        const until = new Date(result.muteUntil * 1000);
        const minutes = Math.floor((until.valueOf() - Date.now()) / 1000 / 60);
        console.log(`Chat muted for another ${minutes} minutes!`);
    }
    else {
        console.log("Chat not currently muted");
    }
}
async function muteChat(client, chatId, durationSeconds) {
    const muteUntil = parseFloat(((Date.now() + durationSeconds * 1000) / 1000).toFixed(0));
    const result = await client.invoke(new Api.account.UpdateNotifySettings({
        peer: chatId,
        settings: new Api.InputPeerNotifySettings({
            showPreviews: false,
            muteUntil: muteUntil,
        }),
    }));
    await checkMuted(client, chatId);
}
async function saveSession(stringSession) {
    const jsonString = JSON.stringify({ stringSession: stringSession });
    await fs.writeFile("./config/session.json", jsonString);
}
// const getFirstMessage = async function (client: TelegramClient) {
//   const result = await client.invoke(
//     new Api.messages.Search({
//       q: "",
//       filter: new Api.InputMessagesFilterEmpty(),
//       peer: config.chats.airdrops,
//       limit: 1,
//       fromId: config.users.max,
//       topMsgId: 0,
//     })
//   );
//   return result;
// };
// Api.Message.sear
// // binary search function to return oldest message of a user
// const getFirstMessage = async function (client, { chatId, fromUser, maxId, lastResult, lastMiss = 0, lastId, offset = 0 }) {
//     // get 3000th last message, as per telegram limit...
//     //todo: try use addOffset = lastResult.id
//     for await (const message of client.iterMessages(chatId, { fromUser: fromUser, limit: 1, addOffset: offset /*, waitTime:1*/ })) {
//         // if found, check recursively.
//         if (message.id) {
//             console.log(message.id, message.text);
//             lastId = message.id;
//             offset += 3000;
//             // make maxId half remaining messages in chat
//             // maxId = Math.floor((message.id + lastMiss) * 0.05);
//             // console.log("decrease maxId:", maxId, "gap:", message.id - lastMiss);
//             // //maxId = message.id;
//             lastResult = { id: message.id, text: message.text };
//             return await getFirstMessage(client, { chatId, fromUser, maxId, lastResult, lastMiss, lastId, offset });
//         }
//     }
//     // if our maxId offset was too low:
//     if (typeof message === "undefined") {
//         return lastResult;
//         // if (maxId == 0) {
//         //     console.log("final maxId:", maxId);
//         //     return lastResult
//         // };
//         // // increase maxId by 50% in order to find messages
//         // lastMiss = maxId;
//         // maxId = Math.floor((lastResult.id + lastMiss) * 0.5);
//         // console.log("increase maxId: ", maxId, "gap:", maxId - lastMiss);
//         // return await getFirstMessage(client, { chatId, fromUser, maxId, lastResult, lastMiss });
//     }
// }
// Api.Channel.