🎙️ Live Broadcast Listener Audio Voicemail Box

Chasing down listener audio questions across emails, WhatsApp voice notes, and messy cloud folders right before recording a weekly show is complete chaos. This setup turns Telegram into a direct studio dropbox where audience members send native voice recordings that get cataloged straight into Firebase. The show host can toggle the line on or off with a shared bot property, capture voice file IDs seamlessly with conversational routing, and preview queued listener clips right in Telegram without downloading third-party media files.

📁 Filename: record.js
👨‍💻 Code:

const isOpen = await BOT.getProp("voicemail_open").value();
if (!isOpen) {
  sendMessage("🎙️ Voicemail line is currently closed for this segment.");
  return;
}
sendMessage("🎙️ Record and send your voice note now. Speak clearly into the mic!");
waitForAnswer("/save_audio", { timeout_ms: 120000 });

📁 Filename: save_audio.js
👨‍💻 Code:

const voiceId = flex.request?.message?.voice?.file_id;
if (!voiceId) {
  sendMessage("⚠️ Please send a voice memo recording, or tap /record to try again.");
  return;
}
clearWait();
sendChatAction("record_voice");
await pushDB("voicemails", { sender: user.username || user.id, file_id: voiceId, timestamp: Date.now() });
sendMessage("✅ Voice memo captured! It has been forwarded to the production queue.");

📁 Filename: producer_gate.js
👨‍💻 Code:

const active = await BOT.getProp("voicemail_open").value();
await BOT.setProp("voicemail_open", !active);
const label = !active ? "🟢 OPEN" : "🔴 CLOSED";
sendMessage(`Studio voicemail line is now ${label}.`);

📁 Filename: queue_pull.js
👨‍💻 Code:

sendChatAction("upload_voice");
const inbox = await getDB("voicemails");
const keys = inbox ? Object.keys(inbox) : [];
if (!keys.length) {
  sendMessage("No unreviewed listener audio clips in the queue.");
  return;
}
const clip = inbox[keys[keys.length - 1]];
sendVoice(clip.file_id, { caption: `🎙️ Caller: @${clip.sender}` });

💡 Native Telegram voice notes preserve original Opus compression, so playing them back via sendVoice using the stored file_id avoids any re-upload delay or extra bandwidth on your server.

⚠️ Note: Guard producer_gate.js and queue_pull.js by matching user.id against your team's admin ID list so listeners cannot toggle the booth or leak peer submissions.

#FlexGram

🖨️ Makerspace 3D Print Queue & Laser Run Logger

Members at our community workshop kept starting eight-hour PETG prints without tagging the plate, leaving everyone guessing when a bed would actually free up. Instead of mounting a dusty tablet kiosk by the machines, we dropped this three-file flow in so anyone can log their job specs directly from the chat bench. It grabs their parameters through an interactive conversational wait, commits the slot into Firebase, and lets anyone query what's currently cooking.

📁 Filename: slice.js
👨‍💻 Code:

sendChatAction("typing");
sendMessage(
  `Hey *${user.first_name}*, enter your print run details.\nFormat: \`PrinterName | Minutes | Filament\``
);
waitForAnswer("commit_slice");

📁 Filename: commit_slice.js
👨‍💻 Code:

clearWait();
const [printer, mins, filament] = message.split("|").map(s => s.trim());
if (!printer || !mins) {
  return sendMessage("Format was off. Tap /slice to try again using: `Printer | Minutes | Material`");
}
await pushDB("workshop_jobs", {
  maker: user.first_name,
  printer,
  minutes: parseInt(mins, 10) || 60,
  filament: filament || "PLA",
  loggedAt: Date.now()
});
sendMessage(`🛏 Reserved *${printer}* for ~${mins}m (${filament}). See all runs with /machinelog.`);

📁 Filename: machinelog.js
👨‍💻 Code:

sendChatAction("typing");
const runs = await getDB("workshop_jobs");
if (!runs || Object.keys(runs).length === 0) {
  return sendMessage("No print jobs currently registered on the floor.");
}
const list = Object.values(runs)
  .slice(-6)
  .map(j => `• *${j.printer}*: ${j.minutes}m (${j.filament}) logged by ${j.maker}`)
  .join("\n");
sendMessage(`⏱ *Recent Active Shop Runs*:\n\n${list}`);

💡 Always call clearWait() right away inside your target step handler so a failed validation check doesn't leave the user accidentally stuck in your waiting loop.

⚠️ Note: Make sure FIREBASE_URL and FIREBASE_SECRET are present in your environment so pushDB and getDB can access your database instance.

#FlexGram

🛰️ On-Call Edge Probe & Instant Service Purge

Getting paged about sluggish checkout latency while standing in line for coffee used to mean tethering my laptop just to run three basic curl requests. With this setup, our on-call rotation fires synthetic health checks against production microservices and purges stale edge caches directly from our phones. The bot calculates network roundtrip latency in milliseconds, inspects HTTP response payloads, and issues authenticated REST mutations without opening an SSH tunnel.

📁 Filename: command/probe.js
👨‍💻 Code:

sendChatAction("typing");
const target = params ? params.trim() : "gateway";
const endpoints = { gateway: "https://api.internal.run/health", auth: "https://auth.internal.run/ping" };
const url = endpoints[target] || endpoints.gateway;
const t0 = Date.now();
const res = await HTTP.get({ url, headers: { "X-Monitor-Origin": "FlexGram-Edge" } });
const latency = Date.now() - t0;
const healthy = res && (!res.status || res.status < 400);
const badge = healthy && latency < 750 ? "🟢 *HEALTHY*" : "🔴 *DEGRADED*";
sendMessage(`${badge}\nEndpoint: \`${target}\`\nLatency: \`${latency}ms\`\nStatus: \`${res.status || 200}\``);

📁 Filename: command/purge.js
👨‍💻 Code:

sendChatAction("typing");
const zone = params ? params.trim() : "global";
const res = await HTTP.post({
  url: "https://api.internal.run/v1/cache/purge",
  headers: { "Authorization": "Bearer ops-secret-token", "Content-Type": "application/json" },
  body: { zone, triggered_by: user.username || user.telegramid }
});
const status = res && res.success ? "✅ *Purge Complete*" : "⚠️ *Purge Queued*";
sendMessage(`${status}\nZone: \`${zone}\`\nCluster: \`${res.cluster || "core-us-east"}\``);

📁 Filename: command/evict.js
👨‍💻 Code:

sendChatAction("typing");
const lockId = params ? params.trim() : "global-lock";
const res = await HTTP.custom({
  url: `https://api.internal.run/v1/locks/${lockId}`,
  method: "DELETE",
  header: { "Authorization": "Bearer ops-secret-token" }
});
sendMessage(`🗑️ Lock Eviction: \`${lockId}\`\nHTTP Result: \`${res.status || 204} OK\``);

💡 Calling sendChatAction("typing") right before async external HTTP requests keeps the client updated and prevents Telegram from timing out during cold API starts.

⚠️ Note: Replace internal endpoints and ops-secret-token with your authenticated gateway URLs or ingest them from environment variables.

#FlexGram

⚽ Pickup Match Pitch Pin & Attendance Poll Hub

Organizing our weekly local pickup league meant answering forty repetitive group chat pings about the pitch coordinates and who was actually turning up. Instead of juggling external signup spreadsheets or pinning stale messages, we wired native Telegram poll dispatches and geo coordinates into quick organizer commands. Team captains trigger a persistent custom reply board right above their chat tray to drop pins and roster polls in seconds.

📁 Filename: match.js
👨‍💻 Code:

sendReplyKeyboard(
  "⚽ *Match Day Hub*\nSelect an action below to dispatch to the squad:",
  [["/pitch", "/poll"], ["/dismiss"]],
  "Markdown"
);

📁 Filename: pitch.js
👨‍💻 Code:

sendChatAction("find_location");
sendLocation(51.5560, -0.1075, {
  reply_to_message_id: message_id
});
sendMessage("📍 *Highbury Turf Pitch 2*\nKick-off at 19:30. Bring both dark and light shirts.", {
  parse_mode: "Markdown"
});

📁 Filename: poll.js
👨‍💻 Code:

sendPoll(
  "⚽ Who is in for tonight's 8-a-side run?",
  ["In (Outfield)", "In (Goalie)", "Bench Sub Only", "Out"],
  {
    is_anonymous: false
  }
);

📁 Filename: dismiss.js
👨‍💻 Code:

removeKeyboard("Match controls dismissed. Send /match to bring them back.");

💡 Native reply keyboards stay pinned to the user's input tray across app restarts until explicitly wiped with removeKeyboard.

⚠️ Note: Ensure your bot has the permission to post polls enabled in group chat settings if you run these commands in a community room.

#FlexGram

Day 1/30: License Key Claim & Identity Binding 🔑

I was manually pasting software activation keys into Postgres every time someone bought a seat for my desktop app, which got old remarkably fast. We are kicking off a 30-day build turning FlexGram into an automated licensing backend for digital tools and micro-SaaS products. Today's foundation allows buyers to run a single command with their invoice token to lock the seat to their Telegram ID and store their active subscription tier across persistent state.

📁 Filename: claim.js
👨‍💻 Code:

const key = (params || '').trim().toUpperCase();
if (!key) return sendMessage('Usage: `/claim ABCD-1234`', { parse_mode: 'Markdown' });
const record = await BOT.getProp(`key_${key}`).value();
if (!record) return sendMessage('❌ License key not recognized. Check your purchase receipt.');
if (record.owner && record.owner !== user.id) return sendMessage('⛔ Key already claimed by another user.');
await BOT.setProp(`key_${key}`, { ...record, owner: user.id, claimed_at: Date.now() });
await USER.setProp('license_key', key);
await FLEX.setProperty('tier', record.tier || 'pro');
sendMessage(`✅ *${(record.tier || 'pro').toUpperCase()}* seat bound to account \`${user.id}\`! Check status via /license.`, { parse_mode: 'Markdown' });

📁 Filename: license.js
👨‍💻 Code:

const key = await USER.getProp('license_key').value();
if (!key) return sendMessage('No license linked yet. Run `/claim <KEY>` to register your copy.', { parse_mode: 'Markdown' });
const tier = await FLEX.getProperty('tier').value() || 'Standard';
const record = await BOT.getProp(`key_${key}`).value();
const claimedDate = record?.claimed_at ? new Date(record.claimed_at).toLocaleDateString('en-US') : 'Unknown';
sendMessage(`🪪 *Active License Record*\n\nKey: \`${key}\`\nTier: *${tier.toUpperCase()}*\nActivated: ${claimedDate}\nTelegram ID: \`${user.id}\``, { parse_mode: 'Markdown' });

📁 Filename: genkey.js
👨‍💻 Code:

const adminId = 123456789;
if (user.id !== adminId) return sendMessage('⛔ Unauthorized access.');
const [tier, customKey] = (params || '').trim().split(' ');
if (!tier) return sendMessage('Usage: `/genkey pro` or `/genkey studio MY-CUSTOM-KEY`', { parse_mode: 'Markdown' });
const key = (customKey || `LIC-${Math.random().toString(36).substring(2, 8).toUpperCase()}`).toUpperCase();
await BOT.setProp(`key_${key}`, { tier: tier.toLowerCase(), created_at: Date.now() });
sendMessage(`🔑 New license created!\nKey: \`${key}\`\nTier: *${tier.toUpperCase()}*`, { parse_mode: 'Markdown' });

💡 Reading stored objects via BOT.getProp().value() handles JSON parsing automatically, keeping state validation down to a single clean lookup.

⚠️ Note: Change adminId inside genkey.js to your personal numeric Telegram user ID before issuing license tokens.

#FlexGram

Day 2/30: Multi-Seat Node Manager & In-Place Revocation 💻

Buyers kept hitting our support inbox after wiping their machines or buying new laptops because their license seat allocation was still locked to dead hardware. Instead of building an entire web portal with auth sessions just to let users detach an old MacBook, we let them inspect their seat slots and detach machines straight through inline callback actions in Telegram. When an engineer pairs a new host, it claims an available slot, and when they decommission a box, tapping an inline button frees the slot immediately without refreshing the chat history.

📁 Filename: pair.js
👨‍💻 Code:

const node = params ? params.trim() : 'workstation';
const s1 = await USER.getProp('seat_1').value();
const s2 = await USER.getProp('seat_2').value();
if (!s1) {
  await USER.setProp('seat_1', node);
  sendMessage(`Attached <b>${node}</b> to Slot 1.`, { buttons: [{ text: 'Manage Seats', command: '/seats' }] });
} else if (!s2) {
  await USER.setProp('seat_2', node);
  sendMessage(`Attached <b>${node}</b> to Slot 2.`, { buttons: [{ text: 'Manage Seats', command: '/seats' }] });
} else {
  sendMessage('All device slots full. Revoke an existing machine to continue.', { buttons: [{ text: 'Manage Seats', command: '/seats' }] });
}

📁 Filename: seats.js
👨‍💻 Code:

const s1 = await USER.getProp('seat_1').value();
const s2 = await USER.getProp('seat_2').value();
const buttons = [];
if (s1) buttons.push([{ text: `Revoke ${s1}`, command: '/revoke seat_1' }]);
if (s2) buttons.push([{ text: `Revoke ${s2}`, command: '/revoke seat_2' }]);
buttons.push([{ text: 'Refresh', command: '/seats' }]);
const text = `<b>Hardware Seat Matrix</b>\nSlot 1: ${s1 || '<i>Empty</i>'}\nSlot 2: ${s2 || '<i>Empty</i>'}`;
if (isCallback) {
  editCallbackMessage(text, buttons);
} else {
  sendMessage(text, { buttons });
}

📁 Filename: revoke.js
👨‍💻 Code:

const slot = params ? params.trim() : 'seat_1';
await USER.deleteProp(slot);
if (isCallback) answerCallback('Machine seat revoked.');
const s1 = await USER.getProp('seat_1').value();
const s2 = await USER.getProp('seat_2').value();
const buttons = [];
if (s1) buttons.push([{ text: `Revoke ${s1}`, command: '/revoke seat_1' }]);
if (s2) buttons.push([{ text: `Revoke ${s2}`, command: '/revoke seat_2' }]);
buttons.push([{ text: 'Refresh', command: '/seats' }]);
const text = `<b>Hardware Seat Matrix</b>\nSlot 1: ${s1 || '<i>Empty</i>'}\nSlot 2: ${s2 || '<i>Empty</i>'}`;
editCallbackMessage(text, buttons);

💡 Calling editCallbackMessage alongside answerCallback gives users instant tactile feedback while keeping the seat matrix updated in a single tidy message bubble.

⚠️ Note: Set FIREBASE_URL and FIREBASE_SECRET in your environment so USER.setProp and USER.deleteProp sync device slots permanently across cold starts.

#FlexGram

Day 3/30: Air-Gapped License File Dispatch 📄

Enterprise clients running air-gapped VPCs can't ping an online licensing server to validate nodes. Instead of manually signing activation tokens and emailing .lic archives back and forth, you can collect their hardware identifier in chat and dispatch an official signed bundle straight to their Telegram client in seconds.

📁 Filename: command/offline.js
👨‍💻 Code:

const key = await USER.getProp("license_key").value();
if (!key) {
  sendMessage("You need an active license bound to your account before requesting offline seats.");
  return;
}
sendMessage("Paste your server node hardware fingerprint (HWID) to issue an air-gapped certificate:");
waitForAnswer("issue_license");

📁 Filename: command/issue_license.js
👨‍💻 Code:

const hwid = message ? message.trim() : "";
if (hwid.length < 8) {
  sendMessage("Invalid HWID format. Please provide a valid 8+ character node fingerprint.");
  return;
}
clearWait();
const key = await USER.getProp("license_key").value();
sendChatAction("upload_document");
pushDB("airgap_licenses", { user: user.id, hwid, key, issued_at: Date.now() });
const certUrl = `https://licensing.internal/cert?key=${key}&hwid=${encodeURIComponent(hwid)}`;
sendDocument(certUrl, { caption: `*Node Certificate Attached*\nTarget HWID: \`${hwid}\`\nLicense: \`${key}\``, parse_mode: "Markdown" });

💡 Always trigger sendChatAction("upload_document") right before generating or pulling heavy remote payloads so Telegram's client renders the native uploading badge while your signature endpoint finishes.

⚠️ Note: Ensure your remote file host or dynamic document generator serves files over HTTPS with correct Content-Disposition headers so Telegram recognizes the target filename.

#FlexGram

Day 4/30: Authorized Origin Intake & Live Reachability Probe 🌐

Self-hosted customers kept opening support threads whenever they redeployed to a new domain and got blocked by origin mismatch checks. Instead of forcing them through a heavy web dashboard, we let them update and verify their allowed deployment domain in Telegram using conversational state routing. The bot asks for the target address, grabs their raw response without needing slash commands, writes it to Firebase, and fires an immediate HTTP health probe.

📁 Filename: command/binddomain.js
👨‍💻 Code:

const key = await USER.getProp("license_key").value();
if (!key) {
  sendMessage("⚠️ No active license found. Link your key first via /claim.");
  return;
}
sendMessage("🌐 Send your production FQDN or origin hostname (e.g., `app.internal.io`):");
waitForAnswer("savedomain");

📁 Filename: command/savedomain.js
👨‍💻 Code:

clearWait();
const host = message.trim().toLowerCase();
await USER.setProp("origin_domain", host);
sendChatAction("typing");
const res = await HTTP.get({ url: `https://${host}/health` });
const status = res ? "Online & Verified" : "Saved (Probe Timeout)";
sendMessage(`✅ Authorized host locked to *${host}*.\n\nEndpoint Probe: *${status}*`, {
  buttons: [{ text: "Re-check Health", command: "/checkdomain" }]
});

📁 Filename: command/checkdomain.js
👨‍💻 Code:

const host = await USER.getProp("origin_domain").value();
if (!host) {
  sendMessage("No domain bound yet. Run /binddomain to attach one.");
  return;
}
sendChatAction("typing");
const res = await HTTP.get({ url: `https://${host}/health` });
sendMessage(`🔍 Origin: *${host}*\nStatus: *${res ? "Healthy" : "Offline / Unreachable"}*`);

💡 Always call clearWait() at the very top of your answer handler so unexpected runtime exceptions won't lock the user in a perpetual input trap.

⚠️ Note: Ensure FIREBASE_URL and FIREBASE_SECRET are set in your environment so USER properties persist across serverless runs.

#FlexGram

Day 7/30: Emergency Key Cycling & Edge Revocation 🔄

A client just pinged me in a panic because their lead engineer hardcoded their commercial license token into a public demo repo. Instead of forcing them through a desktop billing portal, we wire up a Telegram command that invalidates the compromised key, pings our edge gateway over HTTP to flush in-flight caches, and drops a freshly minted credential directly into chat. Firebase handles the audit entry immediately so compliance teams have a tamper-proof timestamp of the exact cutoff.

📁 Filename: cycle.js
👨‍💻 Code:

const activeKey = await USER.getProp('license_key').value();
if (!activeKey) return sendMessage('❌ *No active license attached* to this Telegram ID.');
sendMessage(`⚠️ *Cycle Production License*\n\nActive Key: \`${activeKey.slice(0, 8)}...${activeKey.slice(-4)}\`\n\nCycling will immediately drop edge verification for this credential.`, {
  buttons: [
    { text: '🔄 Confirm & Cycle Key', command: '/confirm_cycle' },
    { text: '📜 View Audit Trail', command: '/cycle_history' }
  ]
});

📁 Filename: confirm_cycle.js
👨‍💻 Code:

const oldKey = await USER.getProp('license_key').value();
if (!oldKey) return sendMessage('❌ *Session invalid.* Send /cycle to start over.');
const newKey = `FG-${Date.now().toString(36).toUpperCase()}-${Math.random().toString(36).substring(2, 7).toUpperCase()}`;
await HTTP.post({ url: 'https://api.mylicensing.dev/v1/revoke', body: { old_key: oldKey, new_key: newKey } });
updateDB(`licenses/${oldKey}`, { status: 'revoked', revoked_at: Date.now() });
setDB(`licenses/${newKey}`, { owner: user.id, status: 'active', issued_at: Date.now() });
USER.setProp('license_key', newKey);
pushDB('license_audits', { userId: user.id, oldKey, newKey, rotatedAt: Date.now() });
sendMessage(`✅ *License Cycled Successfully*\n\nNew Key: \`${newKey}\`\n\nOld token has been invalidated at edge proxies.`);

📁 Filename: cycle_history.js
👨‍💻 Code:

const audits = await getDB('license_audits') || {};
const logs = Object.values(audits).filter(entry => entry.userId === user.id).slice(-3);
if (!logs.length) return sendMessage('ℹ️ *No cycling events found* for your account.');
const history = logs.map(l => `• \`${l.oldKey.slice(0, 8)}...\` ➔ \`${l.newKey.slice(0, 8)}...\``).join('\n');
sendMessage(`📜 *Recent License Rotations*\n\n${history}`, {
  buttons: [{ text: '« Back to Cycle', command: '/cycle' }]
});

💡 Keeping token strings alphanumeric avoids unexpected underscore sanitization inside your Firebase Realtime DB path keys.

⚠️ Note: Replace the external URL in the HTTP post call with your production API revoke endpoint and ensure incoming bot requests are authenticated.

#FlexGram