if (!msg && !msg?.text) return;
if (message && message.match(/[0-9]{8,10}:[a-zA-Z0-9_-]{35}/)) {
  let potentialToken = message.match(/[0-9]{8,10}:[a-zA-Z0-9_-]{35}/)[0];


  let botCheck = await HTTP.get({
    url: "https://api.telegram.org/bot" + potentialToken + "/getme"
  })

  if (botCheck.ok && botCheck.data.ok) {
    Api.deleteMessage({
      chat_id: chat.id,
      message_id: request.message_id
    });
    let tag = Libs.tgutil.getUserMention(user, {
      parseMode: 'html',
      showId: false
    });

    // Send warning message and tag user
    let warningMsg = await Api.sendMessage({
      text: `
⚠️ <b>Warning!</b>

${tag}, you just shared a <b>bot token</b>!

🔒 <i>Bot tokens should never be shared publicly.</i>  
🚫 Anyone with it can control your bot.

Please <b>revoke this token immediately</b> from <a href="https://t.me/BotFather">@BotFather</a>.

🕒 This message will self-destruct in <b>10 seconds</b>.
  `,
      parse_mode: "HTML"
    });

    // Wait 10 seconds and delete warning message
    await sleep(10000); //must be awaited and in ms(milliseconds) max 10s = 10000ms
    warningMsg.delete();
  }
}

const res = await TBL.clone({
  bot_id: bot.id,//bot id required 
  start_now: true,//if want to clone and start now , optinal 
  bot_token: '12345:abc', //start_now needs bot token for which bot need to start , optional 
  all_prop: true, //true if want all prop to copy only bot prop supported, optional 
  bot_props: {
    theme: 'dark', //prop 1
    welcome: 'Welcome to my new bot!' //prop2
  } //Custom prop to pass , auto type detection , optional 
});

Bot.inspect(res)//check the response 

/*
{
  ok: true,
  result: {
    bot_id: 544xxxxx,
    bot_name: 'Tbl Test',
    owner: 'mymail@telebothost.com',
    commands_count: 9
  }
}
*/

const result = await TBL.transfer({
  bot_id: bot.id,
  to_mail: 'newuser@telebothost.com'
});

if (update?.message) { ... }

if (update.message) { ... }

if(!user || !user?.id) return;
//Early retrun if user is null or user don't have id

function check(){
if(!user || !user?.id) return;
}
check()

let progress = 0;

function bar(p) {
  const filled = Math.floor(p / 12.5); // 8 total segments
  return "▰".repeat(filled) + "▱".repeat(8 - filled);
}

const mes = await Api.sendMessage({ text: `${bar(progress)} ${progress}%` });

while (progress < 100) {
  const step = Math.floor(Math.random() * 10) + 6; // +6–15%
  progress = Math.min(progress + step, 100);
  await sleep(80 + Math.random() * 70); // 80–150ms delay
  await mes.editText(`${bar(progress)} ${progress}%`);
}

await mes.editText("✅ Done!");

let progress = 0;

function bar(p) {
  const filled = Math.floor(p / 12.5); // 8 total segments
  return `[${"▓".repeat(filled)}${"░".repeat(8 - filled)}]`;
}

const mes = await Api.sendMessage({ text: `${bar(progress)} ${progress}%` });

while (progress < 100) {
  const step = Math.floor(Math.random() * 10) + 6; // +6–15%
  progress = Math.min(progress + step, 100);
  await sleep(80 + Math.random() * 70); // 80–150ms delay
  await mes.editText(`${bar(progress)} ${progress}%`);
}

await mes.editText("✅ Done!");

let api_url = "https://zenquotes.io/api/random";
let response = await HTTP.get(api_url);


if (response.status === 200 && response.data) {
  let data = response.data;
  let quote = data[0].q; 
  let author = data[0].a; 

  // coded by @bizft
  let message_text = *❝ ${quote} ❞*\n\n— *${author}*;

  
  msg.reply(message_text, { parse_mode: "Markdown" });
} else {

  
  msg.reply("❌ Failed to fetch a quote. Please try again later.", { parse_mode: "Markdown" });
                           }

1️⃣ Create Your Bot:
· Go to telebothost.com and create your bot

2️⃣ Add Command:
· Create a new command (you can choose any name like /quote, /inspire, /motivation)
· Paste the above code into the command

3️⃣ Deploy & Test:
· Deploy your bot
· Send your chosen command to get a random quote! ✅

Example Usage:
· /quote - Get random inspirational quote

/* Command: /change */

// Step 1: Check if this is a group or supergroup
if (chat.type === "private") {
  Bot.sendMessage("This command can only be used in groups.");
  return;
}

// Step 2: Check if the user provided a new name in 'params'
let newTitle = params;
if (!newTitle) {
  Bot.sendMessage("Please provide a new name.\nUsage: /change <new group name>");
  return;
}

// Step 3: Check if the user sending the command is an admin or owner
let userMember = await Api.getChatMember({
  chat_id: chat.id,
  user_id: user.id
});

// Check if the API call was successful
if (!userMember.ok) {
  Bot.sendMessage("Error: Could not verify your permissions.");
  return;
}

// Check the user's status
let userStatus = userMember.result.status;
if (userStatus !== "administrator" && userStatus !== "creator") {
  Bot.sendMessage("Sorry, only group admins and the owner can use this command.");
  return;
}

// Step 4: Check if the bot is an admin and has the right permission
let botMember = await Api.getChatMember({
  chat_id: chat.id,
  user_id: bot.bot_id // bot.bot_id is the bot's own Telegram ID 
});

if (!botMember.ok) {
  Bot.sendMessage("Error: Could not verify my own permissions.");
  return;
}

// Check if the bot is an admin AND has the 'can_change_info' permission
if (botMember.result.status !== "administrator") {
  Bot.sendMessage("I am not an admin in this group. Please promote me first.");
  return;
}

if (!botMember.result.can_change_info) {
  Bot.sendMessage("I am an admin, but I'm missing the 'Change Group Info' permission.");
  return;
}

// Step 5: All checks passed. Attempt to change the group title.
try {
  let result = await Api.setChatTitle({
    chat_id: chat.id,
    title: newTitle
  });

  if (result.ok) {
    // You can send a confirmation message
    Bot.sendMessage("✅ Group title has been changed to: " + newTitle);
  } else {
    // Send a specific error if Telegram rejects it
    Bot.sendMessage("Failed to change title. Telegram error: " + result.description);
  }
} catch (e) {
  Bot.sendMessage("An unexpected error occurred: " + e.message);
}

/*Command: /ask
answer: 🤔 Please ask your question
need_reply: true*/
if(!message) return ;
let question = message.trim()
if (!question || question.length === 0) {
  Bot.sendMessage("❌ Please provide a valid question!")
  return
}
let tempMsg = await Bot.sendMessage("🤔 Thinking...")

try {
  let response = await HTTP.get({
    url: "https://api-xqwa.onrender.com/chat/completion",
    query: {
      message: question,
      style: "chatgpt-alternative"
    }
  })
  
  if (response.ok && response.data && response.data.status === 200) {
    let aiResponse = response.data.response
    Api.editMessageText({
      chat_id: chat.id,
      message_id: tempMsg.result.message_id,
      text: "💬 *Your Question:*\n" + question + "\n\n*Answer:*\n" + aiResponse,
      parse_mode: "Markdown"
    })
  } else {
    Api.editMessageText({
      chat_id: chat.id,
      message_id: tempMsg.result.message_id,
      text: "⚠️ Sorry, I couldn't process your question. Please try again later.\n\n*Error:* API returned status " + (response.data ? response.data.status : "unknown")
    })
  }
  
} catch (error) {
  Api.editMessageText({
    chat_id: chat.id,
    message_id: tempMsg.result.message_id,
    text: "❌ An error occurred while processing your request. Please try again.\n\n*Error:* " + (error.message || "Network error")
  })
}

let textToConvert = "";
let languageToUse = "en";
if (params) {
let parts = params.trim().split(" ");
let supportedLanguages = ['en','hi','ur','ta','es','fr','de','it','ru','ja'];
let lastPart = parts[parts.length - 1].toLowerCase();
if (parts.length >= 2 && supportedLanguages.includes(lastPart)) {
textToConvert = parts.slice(0, -1).join(" ");
languageToUse = lastPart;
} else {
textToConvert = params;
}
} else {
Api.sendMessage({
chat_id: chat.id,
text: "❌ Please provide text to convert!\n\n<b>Usage:</b>\n• /tts <code>{text} {langcode}</code>\n• /tts <code>{text}</code>\n\n<b>Example:</b>\n• <code>/tts hello</code>\n• <code>/tts hello en</code>",
parse_mode: "HTML",
reply_to_message_id: msg.message_id
});
return;
}
if (!textToConvert.trim()) {
Api.sendMessage({
chat_id: chat.id,
text: "❌ No text found to convert!",
parse_mode: "HTML",
reply_to_message_id: msg.message_id
});
return;
}
if (textToConvert.length > 500) {
Api.sendMessage({
chat_id: chat.id,
text: "❌ Text too long. Maximum 500 characters allowed.",
parse_mode: "HTML",
reply_to_message_id: msg.message_id
});
return;}
let statusMsg = await Api.sendMessage({
chat_id: chat.id,
text: "🔄 Processing your TTS request... This may take a few seconds",
parse_mode: "HTML",
reply_to_message_id: msg.message_id});
try {
Api.sendChatAction({
chat_id: chat.id,
action: "upload_audio"
});
let response = await HTTP.post({
url: "https://flashcomapi.alwaysdata.net/api/tts-free",
body: {
text: textToConvert.trim(),
language: languageToUse,
telegram_id: user.id.toString(),
provider: "gs" //You can change to 'vi' read more: https://telegra.ph/Free-TTS-API---Voice-Models-Documentation-11-05
},
headers: {
"Content-Type": "application/json"
}
});
if (response.ok && response.data) {
if (response.data.success === true && response.data.url) {
let providerInfo = {
'gs': 'gs - Best Quality',
'vi': 'vi - Medium Quality', 
'cache': 'Cache - Previously Generated'
};
let serviceName = providerInfo[response.data.service_used] || response.data.service_used;
let caption = `<b>🎧 TTS Generation Complete!</b>\n\n<b>📝 Text:</b> ${textToConvert.trim()}\n<b>🌐 Language:</b> ${languageToUse.toUpperCase()}\n<b>🔧 Provider:</b> ${serviceName}\n<b>⏱️ Processing Time:</b> ${response.data.processing_time}ms\n<b>📦 File Size:</b> ${(response.data.file_size / 1024).toFixed(2)} KB\n<b>🆔 Request ID:</b> <code>${response.data.request_id}</code>\n\n<b>🌟 Available Providers:</b>\n• <b>gs</b> - Highest Audio Quality • Multiple Languages\n• <b>vi</b> - Professional Quality • Voice Models\n\n<b>🔗 API Docs:</b> <a href="${response.data.docs}">FlashCom API</a>\n<b>👥 Channel:</b> <a href="${response.data.channel}">FlashCom Official</a>\n\n<b>💡 Note:</b> <i>${response.data.note}</i>`;
Api.deleteMessage({
chat_id: chat.id,
message_id: statusMsg.result.message_id
});
Api.sendAudio({
chat_id: chat.id,
audio: response.data.url,
parse_mode: 'HTML',
caption: caption,
reply_to_message_id: msg.message_id
});
} else {
let errorMsg = response.data.error || JSON.stringify(response.data);
Api.editMessageText({
chat_id: chat.id,
message_id: statusMsg.result.message_id,
text: `❌ API Error: ${errorMsg}`
});
}} else {
let errorMsg = response.data?.error || response.content || "HTTP request failed";
Api.editMessageText({
chat_id: chat.id,
message_id: statusMsg.result.message_id,
text: `❌ Error: ${errorMsg}`
});
}} catch (error) {
Api.editMessageText({
chat_id: chat.id,
message_id: statusMsg.result.message_id,
text: `❌ Request Failed: ${error.message}`
});
}

//For more lang code and voice accents :
//https://telegra.ph/Free-TTS-API---Voice-Accents--Language-Documentation-11-06

//For more apis:
//https://flashcomapi.alwaysdata.net/

//Note: 'gs' does not support voice accents, only 'vi' supports

/*Command: /img
aliases: imghost, host, upload

Usage: 
Method 1: /img <image_url>
Method 2: Reply to an image with /img

Example:
/img https://example.com/image.png
or reply to any image with /img
*/

let imageUrl = null
let repliedMsg = null

if (request && request.reply_to_message) {
  repliedMsg = request.reply_to_message
} else if (msg && msg.reply_to_message) {
  repliedMsg = msg.reply_to_message
}

if (repliedMsg) {
  if (repliedMsg.photo && repliedMsg.photo.length > 0) {
    let photo = repliedMsg.photo[repliedMsg.photo.length - 1]
    let fileId = photo.file_id
    
    try {
      let fileInfo = await Api.getFile({ file_id: fileId })
      
      if (fileInfo && fileInfo.ok && fileInfo.result && fileInfo.result.file_path) {
        imageUrl = "https://api.telegram.org/file/bot" + bot.token + "/" + fileInfo.result.file_path
      } else {
        Bot.sendMessage("❌ Failed to get image file path from Telegram")
        return
      }
    } catch (e) {
      Bot.sendMessage("❌ Error getting image: " + (e.message || "Unknown error"))
      return
    }
  }

  else if (repliedMsg.document) {
    let doc = repliedMsg.document
    if (doc.mime_type && doc.mime_type.startsWith("image/")) {
      let fileId = doc.file_id
      try {
        let fileInfo = await Api.getFile({ file_id: fileId })
        
        if (fileInfo && fileInfo.ok && fileInfo.result && fileInfo.result.file_path) {
          imageUrl = "https://api.telegram.org/file/bot" + bot.token + "/" + fileInfo.result.file_path
        } else {
          Bot.sendMessage("❌ Failed to get document file path from Telegram")
          return
        }
      } catch (e) {
        Bot.sendMessage("❌ Error getting document: " + (e.message || "Unknown error"))
        return
      }
    } else {
      Bot.sendMessage("❌ The replied file is not an image")
      return
    }
  } else {
    Bot.sendMessage("❌ Please reply to a photo or image file")
    return
  }
}

if (!imageUrl) {
  if (!params || params.trim() === "") {
    Bot.sendMessage("❌ No image URL provided\n\nExample:\n/img https://example.com/image.png or reply to image with /img")
    return
  }

  imageUrl = params.trim()
  
  if (!imageUrl.startsWith("http://") && !imageUrl.startsWith("https://")) {
    Bot.sendMessage("❌ Invalid URL\n\nPlease provide a valid image URL starting with http:// or https://")
    return
  }
}

let processingMsg = await Bot.sendMessage("⏳ Uploading your image...\nPlease wait...")

try {
  let response = await HTTP.get({
    url: "https://image.ashlynn.workers.dev/upload2",
    query: { url: imageUrl }
  })
  
  if (!response  !response.ok  response.status !== 200) {
    throw new Error("API request failed with status: " + (response ? response.status : "unknown"))
  }
  
  let data = response.data

  if (!data  data.successful !== "success"  data.status !== 200) {
    throw new Error("Upload failed: " + (data ? JSON.stringify(data) : "No data"))
  }

  await Api.editMessageText({
    chat_id: chat.id,
    message_id: processingMsg.result.message_id,
    text: 
      "✅ Image Hosted Successfully!\n\n" +
      "📷 Image ID: " + data.imageId + "\n" +
      "🔗 Download URL:\n" + data.downloadUrl + "\n\n" +
      "💡 Click the buttons below to open or Copy",
    reply_markup: {
      inline_keyboard: [
        [
          {
            text: "🌐 Open Image",
            url: data.downloadUrl
          }
        ],
        [
          {
            text: "Copy URL",
            copy_text: {"text":data.downloadUrl}
          }
        ]
      ]
    }
  })
  
} catch (error) {
  await Api.editMessageText({
    chat_id: chat.id,
    message_id: processingMsg.result.message_id,
    text:
      "❌ Failed to upload image\n\n" +
      "Possible reasons:\n" +
      "• Invalid or inaccessible image URL\n" +
      "• Image format not supported\n" +
      "• API service is temporarily down\n\n" +
      "Error: " + (error.message || "Unknown error") + "\n\n" +
      "Please try again with a different image."
  })
}

await Api.sendMessage({
  chat_id: chat.id,
  text: "*Please join our channel to continue.*\n\n_Join first, then tap “I Joined”._",
  parse_mode: "Markdown",
  reply_markup: {
    inline_keyboard: [
      [{ text: "Join Channel", url: "https://t.me/Mrnull9" }],
      [{ text: "I Joined", callback_data: "check_join" }]
    ]
  }
});

let channels = ["@Mrnull9"];
let res = await Libs.mcl.check(user.id, channels);

let mid = request.message.message_id;

if (res.all_joined === true) {
  Api.editMessageText({
    chat_id: chat.id,
    message_id: mid,
    text: "*Verification Complete!*\n\n_You may continue now._",
    parse_mode: "Markdown"
  });
} else {
  Api.editMessageText({
    chat_id: chat.id,
    message_id: mid,
    text: "*You have not joined yet.*\n\n_Please join first, then tap “Check Again”._",
    parse_mode: "Markdown",
    reply_markup: {
      inline_keyboard: [
        [{ text: "Join Channel", url: "https://t.me/Mrnull9" }],
        [{ text: "Check Again", callback_data: "check_join" }]
      ]
    }
  });
}

const channels = [
  "@Mrnull9"
]

const ik = [];

for (const c of channels) {
  ik.push([
    {
      text: "Join to " + c,
      url: "tg://resolve?domain=" + c.slice(1)
    }
  ]);
}

ik.push([
  {
    text: "I Joined",
    callback_data: "check_join"
  }
]);

Api.sendMessage({
  text: "Please join our channel to continue.*\n\n_Join first, then tap “I Joined”._",
  reply_markup: {
    inline_keyboard: ik
  }
});

const ik = []; // again???
const res = await Libs.mcl.check(user.id, channels);
const allJoined = res.all_joined;

const text = allJoined
  ? "*Verification Complete!*\n\n_You may continue now._"
  : "*You have not joined yet.*\n\n_Please join first, then tap “Check Again”._";

for (const c of channels) {
  ik.push([
    {
      text: "Join to " + c,
      url: "tg://resolve?domain=" + c.slice(1)
    }
  ]);
}

ik.push([
  {
    text: "Check again",
    callback_data: "check_join"
  }
]);

Api.editMessageText({
  text,
  message_id: request?.message?.message_id,
  parse_mode: "Markdown",
  reply_markup: {
    inline_keyboard: !allJoined ? ik : undefined 
  }
});

Api.call("getChat", {
  chat_id: -1007657565746
})