@iletai/nzb 1.8.1 → 1.8.2

package/dist/api/server.js

@@ -7,6 +7,7 @@ import { listSkills, removeSkill } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
 import { API_TOKEN_PATH, ensureNZBHome } from "../paths.js";
 import { searchMemories } from "../store/memory.js";
+import { sendVoice } from "../telegram/bot.js";
 import { sendPhoto } from "../telegram/bot.js";
 // Ensure token file exists (generate on first run)
 let apiToken = null;
@@ -211,6 +212,32 @@ app.post("/send-photo", async (req, res) => {
         res.status(500).json({ error: msg });
     }
 });
+// Send a voice/audio file to Telegram (protected by bearer token auth middleware)
+app.post("/send-voice", async (req, res) => {
+    const { voice, caption, chat_id } = req.body;
+    if (!voice || typeof voice !== "string") {
+        res.status(400).json({ error: "Missing 'voice' (file path) in request body" });
+        return;
+    }
+    // Only allow local file paths (no URLs for voice)
+    if (voice.startsWith("http://") || voice.startsWith("https://")) {
+        res.status(400).json({ error: "Only local file paths are allowed for voice" });
+        return;
+    }
+    const chatId = chat_id ? parseInt(chat_id, 10) : undefined;
+    if (chat_id && (isNaN(chatId) || chatId === 0)) {
+        res.status(400).json({ error: "Invalid 'chat_id'" });
+        return;
+    }
+    try {
+        await sendVoice(voice, caption, chatId);
+        res.json({ status: "sent" });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        res.status(500).json({ error: msg });
+    }
+});
 // Global error handler — catch unhandled Express errors
 app.use((err, _req, res, _next) => {
     console.error("[nzb] Express error:", err.message);

package/dist/cron/task-runner.js

@@ -1,4 +1,5 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { execSync } from "child_process";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
 import { freemem, totalmem } from "os";
 import { join } from "path";
 import { config } from "../config.js";
@@ -30,6 +31,8 @@ export async function executeCronTask(job) {
             return await executeNotificationTask(job, payload);
         case "webhook":
             return await executeWebhookTask(payload, job.timeoutMs);
+        case "vocab":
+            return await executeVocabTask(job, payload);
         default:
             throw new Error(`Unknown task type: ${job.taskType}`);
     }
@@ -38,14 +41,12 @@ async function executePromptTask(payload) {
     const prompt = payload.prompt || "Scheduled check-in. Anything to report?";
     try {
         const { sendToOrchestrator } = await import("../copilot/orchestrator.js");
-        return await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => reject(new Error("Prompt task timed out after 120s")), 120_000);
-            let fullResponse = "";
+        // No internal timeout — the scheduler's withTaskTimeout() handles it
+        // using the per-job configurable timeoutMs (default 5min).
+        return await new Promise((resolve) => {
             sendToOrchestrator(`[Scheduled task] ${prompt}`, { type: "background" }, (text, done) => {
                 if (done) {
-                    clearTimeout(timeout);
-                    fullResponse = text;
-                    resolve(fullResponse);
+                    resolve(text);
                 }
             });
         });
@@ -106,7 +107,6 @@ async function executeBackupTask() {
             .sort()
             .reverse();
         for (const old of files.slice(10)) {
-            const { unlinkSync } = await import("fs");
             unlinkSync(join(BACKUPS_DIR, old));
             // Also remove corresponding WAL
             const walFile = old + "-wal";
@@ -158,6 +158,124 @@ async function executeWebhookTask(payload, timeoutMs) {
         throw err;
     }
 }
+const VOCAB_PROMPT = `Generate a single advanced English vocabulary word for a Vietnamese learner. Pick an uncommon but useful word.
+
+You MUST respond in EXACTLY this format (no extra text, no markdown fences):
+
+WORD: <word>
+IPA: <IPA pronunciation>
+POS: <part of speech abbreviation: n., v., adj., adv., etc.>
+VI: <Vietnamese translation>
+EN_EXAMPLE: <example sentence in English using the word>
+VI_EXAMPLE: <Vietnamese translation of the example sentence>`;
+async function executeVocabTask(job, payload) {
+    const customPrompt = payload.prompt;
+    const prompt = customPrompt || VOCAB_PROMPT;
+    // Step 1: Get vocab from AI
+    let aiResponse;
+    try {
+        const { sendToOrchestrator } = await import("../copilot/orchestrator.js");
+        aiResponse = await new Promise((resolve) => {
+            sendToOrchestrator(`[Scheduled vocab task] ${prompt}`, { type: "background" }, (text, done) => {
+                if (done)
+                    resolve(text);
+            });
+        });
+    }
+    catch (err) {
+        throw new Error(`Vocab AI prompt failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Step 2: Parse the AI response
+    const parsed = parseVocabResponse(aiResponse);
+    // Step 3: Format the message
+    const formattedMessage = formatVocabMessage(parsed);
+    // Step 4: Send formatted text to Telegram
+    if (config.telegramEnabled) {
+        const { sendProactiveMessage } = await import("../telegram/bot.js");
+        await sendProactiveMessage(formattedMessage);
+    }
+    // Step 5: Generate TTS audio and send voice (macOS only)
+    if (config.telegramEnabled && parsed.word) {
+        try {
+            await generateAndSendVocabAudio(parsed.word);
+        }
+        catch (err) {
+            console.error("[nzb] Vocab TTS failed (non-fatal):", err instanceof Error ? err.message : err);
+        }
+    }
+    return formattedMessage;
+}
+function parseVocabResponse(response) {
+    const get = (key) => {
+        const regex = new RegExp(`^${key}:\\s*(.+)$`, "mi");
+        const match = response.match(regex);
+        return match?.[1]?.trim() ?? "";
+    };
+    return {
+        word: get("WORD"),
+        ipa: get("IPA"),
+        pos: get("POS"),
+        vi: get("VI"),
+        enExample: get("EN_EXAMPLE"),
+        viExample: get("VI_EXAMPLE"),
+    };
+}
+function formatVocabMessage(v) {
+    const lines = ["📖 WORD OF THE MINUTE", ""];
+    if (v.word) {
+        const ipaPart = v.ipa ? `  •  ${v.ipa}` : "";
+        lines.push(`✨ ${v.word}${ipaPart}`);
+    }
+    if (v.pos)
+        lines.push(`🏷 ${v.pos}`);
+    if (v.vi)
+        lines.push(`🇻🇳 ${v.vi}`);
+    lines.push("");
+    if (v.enExample)
+        lines.push(`💬 ${v.enExample}`);
+    if (v.viExample)
+        lines.push(`🔄 ${v.viExample}`);
+    return lines.join("\n");
+}
+async function generateAndSendVocabAudio(word) {
+    const aiffPath = "/tmp/vocab-word.aiff";
+    const m4aPath = "/tmp/vocab-word.m4a";
+    // Clean up previous files
+    try {
+        unlinkSync(aiffPath);
+    }
+    catch { /* ignore */ }
+    try {
+        unlinkSync(m4aPath);
+    }
+    catch { /* ignore */ }
+    // Generate TTS with macOS say
+    execSync(`say -v Samantha -o "${aiffPath}" "${word.replace(/"/g, '\\"')}"`, {
+        timeout: 10_000,
+    });
+    if (!existsSync(aiffPath)) {
+        throw new Error("TTS generation failed: aiff file not created");
+    }
+    // Convert to m4a
+    execSync(`afconvert -f mp4f -d aac "${aiffPath}" "${m4aPath}"`, {
+        timeout: 10_000,
+    });
+    if (!existsSync(m4aPath)) {
+        throw new Error("Audio conversion failed: m4a file not created");
+    }
+    // Send voice via Telegram
+    const { sendVoice } = await import("../telegram/bot.js");
+    await sendVoice(m4aPath, `🔊 ${word}`);
+    // Clean up temp files
+    try {
+        unlinkSync(aiffPath);
+    }
+    catch { /* ignore */ }
+    try {
+        unlinkSync(m4aPath);
+    }
+    catch { /* ignore */ }
+}
 function formatBytes(bytes) {
     if (bytes < 1024)
         return `${bytes}B`;

package/dist/telegram/bot.js

@@ -318,4 +318,29 @@ export async function sendPhoto(photo, caption) {
         throw err;
     }
 }
+/** Send a voice/audio file to the authorized user (or a specific chat). Accepts a local file path. */
+export async function sendVoice(filePath, caption, chatId) {
+    if (!bot || config.authorizedUserId === undefined)
+        return;
+    const targetChat = chatId ?? config.authorizedUserId;
+    if (!isAllowedFilePath(filePath)) {
+        throw new Error("File path is not within allowed directories");
+    }
+    const { InputFile } = await import("grammy");
+    const input = new InputFile(filePath);
+    try {
+        // Use sendAudio for .m4a (shows as playable audio with duration),
+        // sendVoice for .ogg (shows as voice message bubble)
+        if (filePath.endsWith(".ogg")) {
+            await bot.api.sendVoice(targetChat, input, { caption });
+        }
+        else {
+            await bot.api.sendAudio(targetChat, input, { caption });
+        }
+    }
+    catch (err) {
+        console.error("[nzb] Failed to send voice:", err instanceof Error ? err.message : err);
+        throw err;
+    }
+}
 //# sourceMappingURL=bot.js.map

package/dist/telegram/menus.js

@@ -239,6 +239,20 @@ export function createMenus(getUptimeStr) {
     });
     // Main interactive menu with navigation
     const mainMenu = new Menu("main-menu")
+        .text("⏰ Cron", async (ctx) => {
+        try {
+            await ctx.answerCallbackQuery();
+            const { sendCronMenu } = await import("./handlers/cron.js");
+            await sendCronMenu(ctx);
+        }
+        catch (err) {
+            console.error("[nzb] Menu callback error:", err instanceof Error ? err.message : err);
+            await ctx.answerCallbackQuery({
+                text: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
+                show_alert: true,
+            }).catch(() => { });
+        }
+    })
         .text("📊 Status", async (ctx) => {
         try {
             const workers = Array.from(getWorkers().values());

package/package.json

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