@iletai/nzb 1.3.2 → 1.3.4

package/dist/config.js

@@ -14,6 +14,7 @@ const configSchema = z.object({
     SHOW_REASONING: z.string().optional(),
     LOG_CHANNEL_ID: z.string().optional(),
     NODE_EXTRA_CA_CERTS: z.string().optional(),
+    OPENAI_API_KEY: z.string().optional(),
 });
 const raw = configSchema.parse(process.env);
 // Apply NODE_EXTRA_CA_CERTS from .env if not already set via environment.
@@ -43,6 +44,7 @@ export const config = {
     apiPort: parsedPort,
     logChannelId: parsedLogChannelId,
     workerTimeoutMs: parsedWorkerTimeout,
+    openaiApiKey: raw.OPENAI_API_KEY,
     get copilotModel() {
         return _copilotModel;
     },

package/dist/copilot/orchestrator.js

@@ -419,6 +419,14 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                 // send a follow-up "Continue" message so the user doesn't have to
                 if (finalContent.includes("⏱ Response was cut short (timeout)")) {
                     console.log("[nzb] Auto-continuing after timeout…");
+                    // Notify user that auto-continue is happening
+                    if (source.type === "telegram") {
+                        try {
+                            const { sendProactiveMessage } = await import("../telegram/bot.js");
+                            await sendProactiveMessage("🔄 Auto-continuing...");
+                        }
+                        catch { }
+                    }
                     await sleep(1000);
                     void sendToOrchestrator("Continue from where you left off. Do not repeat what was already said.", source, callback, onToolEvent, onUsage);
                 }

package/dist/setup.js

@@ -215,6 +215,20 @@ ${BOLD}╔═══════════════════════
     else {
         console.log(`\n${DIM}  Skipping Google. You can always set it up later with: nzb setup${RESET}\n`);
     }
+    // ── Voice / Whisper Setup ────────────────────────────────
+    console.log(`${BOLD}━━━ Voice Message Setup (optional) ━━━${RESET}\n`);
+    console.log(`NZB can transcribe voice messages using OpenAI's Whisper API.`);
+    console.log(`You need an OpenAI API key from ${CYAN}https://platform.openai.com/api-keys${RESET}`);
+    console.log();
+    const existingOpenaiKey = existing.OPENAI_API_KEY;
+    const openaiKey = await ask(rl, `  OpenAI API Key ${existingOpenaiKey ? `${DIM}(Enter to keep existing)${RESET}` : `${DIM}(Enter to skip)${RESET}`}: `);
+    const finalOpenaiKey = openaiKey.trim() || existingOpenaiKey || "";
+    if (finalOpenaiKey) {
+        console.log(`\n${GREEN}  ✓ Whisper transcription enabled${RESET}\n`);
+    }
+    else {
+        console.log(`\n${DIM}  Skipping voice. Voice messages will be saved but not transcribed.${RESET}\n`);
+    }
     // ── Model picker ─────────────────────────────────────────
     console.log(`\n${BOLD}━━━ Default Model ━━━${RESET}\n`);
     console.log(`${DIM}Fetching available models from Copilot...${RESET}`);
@@ -241,6 +255,8 @@ ${BOLD}╔═══════════════════════
         lines.push(`AUTHORIZED_USER_ID=${userId}`);
     lines.push(`API_PORT=${apiPort}`);
     lines.push(`COPILOT_MODEL=${model}`);
+    if (finalOpenaiKey)
+        lines.push(`OPENAI_API_KEY=${finalOpenaiKey}`);
     writeFileSync(ENV_PATH, lines.join("\n") + "\n");
     // ── Done ─────────────────────────────────────────────────
     console.log(`

package/dist/telegram/bot.js

@@ -1,6 +1,6 @@
 import { autoRetry } from "@grammyjs/auto-retry";
 import { Menu } from "@grammyjs/menu";
-import { Bot } from "grammy";
+import { Bot, Keyboard } from "grammy";
 import { Agent as HttpsAgent } from "https";
 import { config, persistEnvVar, persistModel } from "../config.js";
 import { cancelCurrentMessage, getQueueSize, getWorkers, sendToOrchestrator } from "../copilot/orchestrator.js";
@@ -80,7 +80,7 @@ const mainMenu = new Menu("main-menu")
         await ctx.reply("No memories stored.");
     }
     else {
-        await ctx.reply(formatMemoryList(memories));
+        await ctx.reply(formatMemoryList(memories), { parse_mode: "HTML" });
     }
 })
     .submenu("⚙️ Settings", "settings-menu", async (ctx) => {
@@ -110,18 +110,23 @@ const CATEGORY_ICONS = {
     routine: "🔄",
 };
 function formatMemoryList(memories) {
-    // Group by category
     const groups = {};
     for (const m of memories) {
         (groups[m.category] ??= []).push(m);
     }
+    for (const items of Object.values(groups)) {
+        items.sort((a, b) => a.id - b.id);
+    }
     const sections = Object.entries(groups).map(([cat, items]) => {
         const icon = CATEGORY_ICONS[cat] || "📝";
-        const header = `${icon} ${cat.charAt(0).toUpperCase() + cat.slice(1)}`;
-        const lines = items.map((m) => `  #${m.id} ${m.content}`);
+        const header = `${icon} <b>${escapeHtml(cat.charAt(0).toUpperCase() + cat.slice(1))}</b>`;
+        const lines = items.map((m) => `${m.id}. ${escapeHtml(m.content)}`);
         return `${header}\n${lines.join("\n")}`;
     });
-    return `🧠 Memory (${memories.length})\n\n${sections.join("\n\n")}`;
+    return `🧠 <b>${memories.length} memories</b>\n\n${sections.join("\n\n")}`;
+}
+function escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 export function createBot() {
     if (!config.telegramBotToken) {
@@ -152,8 +157,17 @@ export function createBot() {
     });
     // Register interactive menu plugin
     bot.use(mainMenu);
-    // /start and /help — with inline menu
-    bot.command("start", (ctx) => ctx.reply("NZB is online. Send me anything, or use the menu below:", { reply_markup: mainMenu }));
+    // Persistent reply keyboard — quick actions always visible below chat input
+    const replyKeyboard = new Keyboard()
+        .text("📊 Status").text("❌ Cancel").row()
+        .text("🧠 Memory").text("🔄 Restart")
+        .resized()
+        .persistent();
+    // /start and /help — with inline menu + reply keyboard
+    bot.command("start", async (ctx) => {
+        await ctx.reply("NZB is online. Quick actions below ⬇️", { reply_markup: replyKeyboard });
+        await ctx.reply("Or use the menu:", { reply_markup: mainMenu });
+    });
     bot.command("help", (ctx) => ctx.reply("I'm NZB, your AI daemon.\n\n" +
         "Just send me a message and I'll handle it.\n\n" +
         "Commands:\n" +
@@ -207,7 +221,7 @@ export function createBot() {
             await ctx.reply("No memories stored.");
         }
         else {
-            await ctx.reply(formatMemoryList(memories));
+            await ctx.reply(formatMemoryList(memories), { parse_mode: "HTML" });
         }
     });
     bot.command("skills", async (ctx) => {
@@ -261,6 +275,35 @@ export function createBot() {
             `🤖 Model: ${config.copilotModel}\n` +
             `  └ Dùng /model <name> để đổi`, { reply_markup: settingsMenu });
     });
+    // Reply keyboard button handlers — intercept before general text handler
+    bot.hears("📊 Status", async (ctx) => {
+        const workers = Array.from(getWorkers().values());
+        const lines = [
+            "📊 NZB Status",
+            `Model: ${config.copilotModel}`,
+            `Uptime: ${getUptimeStr()}`,
+            `Workers: ${workers.length} active`,
+            `Queue: ${getQueueSize()} pending`,
+        ];
+        await ctx.reply(lines.join("\n"));
+    });
+    bot.hears("❌ Cancel", async (ctx) => {
+        const cancelled = await cancelCurrentMessage();
+        await ctx.reply(cancelled ? "Cancelled." : "Nothing to cancel.");
+    });
+    bot.hears("🧠 Memory", async (ctx) => {
+        const memories = searchMemories(undefined, undefined, 50);
+        if (memories.length === 0) {
+            await ctx.reply("No memories stored.");
+        }
+        else {
+            await ctx.reply(formatMemoryList(memories), { parse_mode: "HTML" });
+        }
+    });
+    bot.hears("🔄 Restart", async (ctx) => {
+        await ctx.reply("Restarting NZB...");
+        setTimeout(() => { restartDaemon().catch(console.error); }, 500);
+    });
     // Handle all text messages — progressive streaming with tool event feedback
     bot.on("message:text", async (ctx) => {
         const chatId = ctx.chat.id;
@@ -693,6 +736,110 @@ export function createBot() {
             });
         }
     });
+    // Handle voice messages — download, transcribe via Whisper, send to AI
+    bot.on("message:voice", async (ctx) => {
+        const chatId = ctx.chat.id;
+        const userMessageId = ctx.message.message_id;
+        const duration = ctx.message.voice.duration;
+        void logInfo(`🎤 Voice received: ${duration}s`);
+        try {
+            await ctx.react("👀");
+        }
+        catch { }
+        // Limit voice duration to 5 minutes
+        if (duration > 300) {
+            await ctx.reply("❌ Voice too long (max 5 min).", { reply_parameters: { message_id: userMessageId } });
+            return;
+        }
+        try {
+            const file = await ctx.api.getFile(ctx.message.voice.file_id);
+            const filePath = file.file_path;
+            if (!filePath) {
+                await ctx.reply("❌ Could not download voice.", { reply_parameters: { message_id: userMessageId } });
+                return;
+            }
+            const url = `https://api.telegram.org/file/bot${config.telegramBotToken}/${filePath}`;
+            const { mkdtempSync, writeFileSync } = await import("fs");
+            const { join } = await import("path");
+            const { tmpdir } = await import("os");
+            const tmpDir = mkdtempSync(join(tmpdir(), "nzb-voice-"));
+            const ext = filePath.split(".").pop() || "oga";
+            const localPath = join(tmpDir, `voice.${ext}`);
+            const response = await fetch(url);
+            const buffer = Buffer.from(await response.arrayBuffer());
+            writeFileSync(localPath, buffer);
+            let prompt;
+            if (config.openaiApiKey) {
+                // Transcribe using OpenAI Whisper API
+                try {
+                    const formData = new FormData();
+                    formData.append("file", new Blob([buffer], { type: "audio/ogg" }), `voice.${ext}`);
+                    formData.append("model", "whisper-1");
+                    const whisperResp = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+                        method: "POST",
+                        headers: { Authorization: `Bearer ${config.openaiApiKey}` },
+                        body: formData,
+                    });
+                    if (!whisperResp.ok) {
+                        const errText = await whisperResp.text();
+                        throw new Error(`Whisper API ${whisperResp.status}: ${errText.slice(0, 200)}`);
+                    }
+                    const result = (await whisperResp.json());
+                    const transcript = result.text?.trim();
+                    if (!transcript) {
+                        prompt = `[User sent a voice message (${duration}s) but transcription was empty. File saved at: ${localPath}]`;
+                    }
+                    else {
+                        prompt = `[Voice message transcribed (${duration}s)]: ${transcript}`;
+                    }
+                }
+                catch (whisperErr) {
+                    console.error("[nzb] Whisper transcription failed:", whisperErr instanceof Error ? whisperErr.message : whisperErr);
+                    prompt = `[User sent a voice message (${duration}s), saved at: ${localPath}. Transcription failed: ${whisperErr instanceof Error ? whisperErr.message : String(whisperErr)}]`;
+                }
+            }
+            else {
+                prompt = `[User sent a voice message (${duration}s), saved at: ${localPath}. No OPENAI_API_KEY configured for transcription. You can tell the user to set it up in ~/.nzb/.env]`;
+            }
+            sendToOrchestrator(prompt, { type: "telegram", chatId, messageId: userMessageId }, (text, done) => {
+                if (done) {
+                    const formatted = toTelegramMarkdown(text);
+                    const chunks = chunkMessage(formatted);
+                    const fallbackChunks = chunkMessage(text);
+                    void (async () => {
+                        for (let i = 0; i < chunks.length; i++) {
+                            if (i > 0)
+                                await new Promise((r) => setTimeout(r, 300));
+                            const pageTag = chunks.length > 1 ? `📄 ${i + 1}/${chunks.length}\n` : "";
+                            try {
+                                await ctx.api.sendMessage(chatId, pageTag + chunks[i], {
+                                    parse_mode: "MarkdownV2",
+                                    reply_parameters: i === 0 ? { message_id: userMessageId } : undefined,
+                                });
+                            }
+                            catch {
+                                try {
+                                    await ctx.api.sendMessage(chatId, pageTag + (fallbackChunks[i] ?? chunks[i]), {
+                                        reply_parameters: i === 0 ? { message_id: userMessageId } : undefined,
+                                    });
+                                }
+                                catch { }
+                            }
+                        }
+                        try {
+                            await ctx.api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
+                        }
+                        catch { }
+                    })();
+                }
+            });
+        }
+        catch (err) {
+            await ctx.reply(`❌ Error processing voice: ${err instanceof Error ? err.message : String(err)}`, {
+                reply_parameters: { message_id: userMessageId },
+            });
+        }
+    });
     return bot;
 }
 export async function startBot() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@iletai/nzb",
-	"version": "1.3.2",
+	"version": "1.3.4",
 	"description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
 	"bin": {
 		"nzb": "dist/cli.js"