⚠️ Note: Subscribe Backup Channel: https://youtube.com/@flecdev

🔔 Leave Notify Telegram Bot Code

import { getDB, deleteDB } from "./firebase.js";

export const commandName = "__message__";

export default async function (flex) {
  const body = flex.request.body;
  const leftMember = body.message && body.message.left_chat_member;
  const chatMemberUpdate = body.chat_member;

  const farewellText = `👋 <b>Sorry to see you leave!</b>

<b>You’ve stepped away from our community, but you’re always welcome back.</b>

✨ Whether it was by accident, you needed some time away, or simply wanted a change, our doors remain open for you.

📢 Don’t miss future updates, exclusive offers, and valuable content shared with our members.

👇 Whenever you're ready, tap the button below and rejoin the community. We'd be happy to have you back!`;

  const button = [{ text: "🔗 Join Again", url: "https://t.me/Flex_Coder" }];

  if (leftMember) {
    await API.sendMessage({
      chat_id: leftMember.id,
      text: farewellText,
      parse_mode: "HTML",
      reply_markup: {
        inline_keyboard: [button],
      },
    });
    return;
  }

  if (chatMemberUpdate) {
    const newStatus =
      chatMemberUpdate.new_chat_member &&
      chatMemberUpdate.new_chat_member.status;
    const oldStatus =
      chatMemberUpdate.old_chat_member &&
      chatMemberUpdate.old_chat_member.status;
    const leftNow =
      (newStatus === "left" || newStatus === "kicked") &&
      oldStatus !== "left" &&
      oldStatus !== "kicked";
    if (leftNow) {
      const u = chatMemberUpdate.old_chat_member.user;
      await API.sendMessage({
        chat_id: u.id,
        text: farewellText,
        parse_mode: "HTML",
        reply_markup: {
          inline_keyboard: button,
        },
      });
      return;
    }
  }

  const userId = flex.user.id;

  let pending = null;
  try {
    pending = await getDB(`wait_for_answer/${userId}`);
  } catch {}

  if (pending?.command) {
    if (Date.now() > pending.expires_at) {
      await deleteDB(`wait_for_answer/${userId}`).catch(() => {});
      await sendMessage("⏰ Session timed out. Please start again.");
      return;
    }
    await deleteDB(`wait_for_answer/${userId}`).catch(() => {});
    await runCommand(pending.command, flex.message);
    return;
  }
}

🎥 Tutorial Video: https://youtu.be/sf-v0scqi9U

Do some like & comment on video 😊

sendReplyKeyboard("Select a dev service package to kick off your quote:", [
  [{ text: "🛠️ Web App" }, { text: "📱 Mobile App" }],
  [{ text: "🤖 Telegram Bot" }]
])

removeKeyboard(`Got it! Package selected: *${message}*`)
sendMessage("Would you like to attach high-priority SLA support to this project?", {
  buttons: [
    { text: "⚡ Add Express SLA", command: "/priority_on" }
  ]
})

if (isCallback) {
  answerCallback("Express SLA appended!", true)
  editButton(message_id, [
    { text: "✅ Express SLA Active", command: "/priority_off" }
  ])
}

if (isCallback) {
  answerCallback("Express SLA removed")
  editButton(message_id, [
    { text: "⚡ Add Express SLA", command: "/priority_on" }
  ])
}

sendChatAction('typing')
const response = await HTTP.get({ url: 'https://api.github.com/zen' })
if (response) {
  BOT.setProp('last_check', Date.now())
  sendMessage('*System Status:* All systems operational 🟢')
} else {
  BOT.setProp('last_status', 'DOWN')
  sendMessage('*System Status:* Service disruption detected 🔴')
}

if (String(user.telegramid) !== process.env.ADMIN_ID) {
  return sendMessage('Unauthorized command.')
}
const allUsers = await getDB('users')
const userIds = allUsers ? Object.keys(allUsers) : []
const report = await broadcast(userIds, `🚨 *Incident Update:* ${params || 'Maintenance in progress.'}`, [], 50)
sendMessage(`Alert dispatched: ${report.sent} delivered, ${report.failed} failed.`)

sendMessage('Unrecognized command. Use /check to test system health.')

⚠️ Note: Requires the ADMIN_ID environment variable set in your deployment environment to restrict alert privileges.

const active = await USER.getProp('vip_status').value();
if (active) {
  sendMessage('✨ You already have an active VIP membership!');
  return;
}
waitForAnswer('verify_key');
sendMessage('🔑 Please enter your VIP license key to activate access:');

const res = await HTTP.post({ url: 'https://api.example.com/verify', body: { key: message, uid: user.telegramid } });
if (res && res.valid) {
  USER.setProperty('vip_status', true);
  clearWait();
  sendMessage('🎉 *Key activated!* Access your VIP portal below:', { buttons: [{ text: 'Join VIP Lounge', url: 'https://t.me/+example' }] });
} else {
  sendMessage('❌ Invalid or expired license key. Please check your key and try again.');
}

const active = await USER.getProp('vip_status').value();
if (!active) {
  sendMessage('🔒 No active VIP pass found. Type /activate to redeem a key.');
  return;
}
sendMessage('🎫 *VIP Member Card*\nUser: *' + user.first_name + '*\nStatus: *Active*');

⚠️ Note: Replace the API endpoint in verify_key.js with your actual authentication server URL.

const item = (Array.isArray(params) ? params[0] : params) || "sku_101";
const prop = await BOT.getProp(`stock_${item}`);
const qty = prop ? prop.value() || 0 : 0;
sendMessage(`📦 *Stock Level:* \`${item}\`\nQuantity: *${qty}*`, {
  buttons: [[
    { text: "-5", command: `/adj ${item} -5` },
    { text: "-1", command: `/adj ${item} -1` },
    { text: "+1", command: `/adj ${item} 1` },
    { text: "+5", command: `/adj ${item} 5` }
  ]]
});

if (!isCallback) return;
const args = Array.isArray(params) ? params : (params ? params.split(" ") : []);
const item = args[0] || "sku_101";
const delta = parseInt(args[1] || "0", 10);
const prop = await BOT.getProp(`stock_${item}`);
const current = prop ? prop.value() || 0 : 0;
const next = Math.max(0, current + delta);
await BOT.setProp(`stock_${item}`, next);
await answerCallback(`Stock updated to ${next}`);
editCallbackMessage(`📦 *Stock Level:* \`${item}\`\nQuantity: *${next}*`, [[
  { text: "-5", command: `/adj ${item} -5` },
  { text: "-1", command: `/adj ${item} -1` },
  { text: "+1", command: `/adj ${item} 1` },
  { text: "+5", command: `/adj ${item} 5` }
]], message_id);

⚠️ Note: Ensure your bot has database access configured via FIREBASE_URL and FIREBASE_SECRET so inventory levels persist across server restarts.

sendChatAction("typing");
sendMessage("Send the expense summary and total cost (e.g., Client Lunch $45):");
waitForAnswer("expense_photo");

TEMP.setProp("expense_details", message);
sendChatAction("typing");
sendMessage("Got it! Now upload a photo of the receipt image:");
waitForAnswer("expense_save");

const details = await TEMP.getProp("expense_details").value();
clearWait();
USER.add("total_expenses", 1);
TEMP.deleteProp("expense_details");
sendMessage("Logged expense receipt for: " + details);

⚠️ Note: Persistent counter methods like USER.add() require setting FIREBASE_URL and FIREBASE_SECRET in your environment variables.

🎉 We have just completed 2 yrs on YouTube

if (!params) return sendMessage("Please provide details: `/blocker <issue description>`");
USER.setProp("has_blocker", true);
USER.setProp("blocker_text", params);
USER.setProp("blocker_user", user.first_name);
sendMessage(`Logged active blocker: *${params}*\nClear it anytime with /unblock when resolved.`);

const active = await USER.getProp("has_blocker").value();
if (!active) return sendMessage("You currently have no active blockers logged. Nice work!");
const details = await USER.getProp("blocker_text").value();
sendMessage(`Your current blocker: *${details}*`);

USER.setProp("has_blocker", false);
USER.deleteProp("blocker_text");
USER.deleteProp("blocker_user");
sendMessage("Impediment cleared! Updated your status across the workspace.");

if (!inlineQuery) return;
const url = inlineQuery.startsWith('http') ? inlineQuery : `https://${inlineQuery}`;
const res = await HTTP.get({ url });
const status = res ? 'HTTP 200 OK' : 'Unreachable / Error';
answerInlineQuery([{
  type: 'article',
  id: '1',
  title: `Check ${inlineQuery}`,
  description: status,
  input_message_content: { message_text: `*Target:* \`${url}\`\n*Status:* ${status}` }
}]);

if (!params) return sendMessage('Provide a domain: `/ping example.com`');
sendChatAction('typing');
const url = params.startsWith('http') ? params : `https://${params}`;
const res = await HTTP.get({ url });
const status = res ? 'online' : 'offline';
sendMessage(`Host \`${url}\` is currently *${status}*.`);

⚠️ Note: Inline Mode must be explicitly turned on in @BotFather under Bot Settings > Inline Mode for the inline handler to work across chats.

⚠️ Note: Subscribe Backup Channel: https://youtube.com/@flecdev

📍 Comment "WhatsApp Hosting" on YouTube channel to get Part 2 as soon as possible.

await FLEX.setProperty('active', true)
const statusText = 'Welcome! You are now subscribed to automated community alerts.'
sendMessage(statusText, { buttons: [{ text: 'Check Status', command: '/status' }] })

const isActive = await FLEX.getProperty('active').value()
const text = isActive ? 'Subscription: *Active*' : 'Subscription: *Inactive*'
sendMessage(text)

if (String(user.telegramid) !== process.env.ADMIN_ID) return sendMessage('Access denied.')
sendMessage('Send the text you want to broadcast across all active subscribers:')
waitForAnswer('dispatch_announce')

clearWait()
const usersData = await getDB('users') || {}
const subscriberIds = Object.keys(usersData)
sendMessage(`Dispatching updates to ${subscriberIds.length} users with 100ms throttle...`)
const stats = await broadcast(subscriberIds, message, null, 100)
sendMessage(`Dispatch finished! Delivered: *${stats.sent}* | Failed: *${stats.failed}*`)

⚠️ Note: Ensure your ADMIN_ID environment variable is set to your numeric Telegram user ID to restrict access to the broadcast trigger.

let email = await USER.getProp('opt_email').value() ?? true;
let digest = await USER.getProp('opt_digest').value() ?? false;
let buttons = [
  [{ text: `Email Alerts: ${email ? 'ON 🔔' : 'OFF 🔕'}`, command: '/toggle_email' }],
  [{ text: `Weekly Digest: ${digest ? 'ON 🔔' : 'OFF 🔕'}`, command: '/toggle_digest' }]
];
sendMessage('*Notification Preferences*\nTap options below to toggle instantly:', { buttons });

let current = await USER.getProp('opt_email').value() ?? true;
let next = !current;
USER.setProp('opt_email', next);
let digest = await USER.getProp('opt_digest').value() ?? false;
let buttons = [
  [{ text: `Email Alerts: ${next ? 'ON 🔔' : 'OFF 🔕'}`, command: '/toggle_email' }],
  [{ text: `Weekly Digest: ${digest ? 'ON 🔔' : 'OFF 🔕'}`, command: '/toggle_digest' }]
];
if (isCallback) answerCallback(`Email alerts turned ${next ? 'ON' : 'OFF'}`);
editButton(message_id, buttons);

let current = await USER.getProp('opt_digest').value() ?? false;
let next = !current;
USER.setProp('opt_digest', next);
let email = await USER.getProp('opt_email').value() ?? true;
let buttons = [
  [{ text: `Email Alerts: ${email ? 'ON 🔔' : 'OFF 🔕'}`, command: '/toggle_email' }],
  [{ text: `Weekly Digest: ${next ? 'ON 🔔' : 'OFF 🔕'}`, command: '/toggle_digest' }]
];
if (isCallback) answerCallback(`Weekly digest turned ${next ? 'ON' : 'OFF'}`);
editButton(message_id, buttons);

export default async function () {
  sendMessage("What is your estimated project budget?");
  waitForAnswer("__brief_budget__");
}

export default async function () {
  await TEMP.setProp("budget", message);
  sendMessage("Got it! Now briefly describe the core deliverables:");
  waitForAnswer("__brief_desc__");
}

export default async function () {
  const budget = await TEMP.getProp("budget").value();
  await USER.setProp("latest_brief", { budget, scope: message });
  clearWait();
  sendMessage(`Brief saved successfully!\n\n*Budget:* ${budget}\n*Scope:* ${message}`);
}

if (!params) return sendMessage("Please provide a key: `/activate YOUR-KEY`");
let res = HTTP.post({ url: "https://api.mysoftware.com/verify", body: JSON.stringify({ key: params, tg_id: user.telegramid }) });
let data = JSON.parse(res.body || "{}");
if (!data.valid) return sendMessage("Invalid or expired license key.");
USER.setProperty("license_key", params);
USER.setProperty("license_tier", data.tier);
sendMessage("*License Activated!*\nPlan: *" + data.tier + "*");

let key = USER.getProp("license_key").value();
let tier = USER.getProp("license_tier").value();
if (!key) return sendMessage("No active license found. Use `/activate KEY` first.");
sendMessage("*Active License Details*\nKey: `" + key + "`\nPlan: *" + tier + "*");

let key = USER.getProp("license_key").value();
if (!key) return sendMessage("You do not have an active license to revoke.");
USER.deleteProp("license_key");
USER.deleteProp("license_tier");
sendMessage("License `" + key + "` has been unbound from this account.");

⚠️ Note: Store external API tokens and secret keys in your production environment variables to keep backend calls secure.