@iletai/nzb 1.8.1 → 1.9.0

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/copilot/orchestrator.js

@@ -818,4 +818,25 @@ export async function compactSession() {
 export function getFailoverManager() {
     return failoverManager;
 }
+/** Run a one-off prompt on a temporary session with a specific model. Session is destroyed after use. */
+export async function runOneOffPrompt(prompt, model, timeoutMs = 300_000) {
+    const client = await ensureClient();
+    const session = await client.createSession({
+        model,
+        configDir: SESSIONS_DIR,
+        onPermissionRequest: approveAll,
+    });
+    try {
+        const result = await session.sendAndWait({ prompt }, timeoutMs);
+        return result?.data?.content || "";
+    }
+    finally {
+        try {
+            await session.disconnect();
+        }
+        catch {
+            // Best-effort cleanup
+        }
+    }
+}
 //# sourceMappingURL=orchestrator.js.map

package/dist/copilot/tools.js

@@ -749,6 +749,7 @@ export function createTools(deps) {
                     .describe("Task type (required for add)"),
                 payload: z.string().optional().describe("JSON payload for the task (optional for add)"),
                 notify_telegram: z.boolean().optional().describe("Send result to Telegram (default: true)"),
+                model: z.string().optional().describe("AI model to use for prompt/vocab tasks (e.g. 'claude-haiku-4.5'). If not set, uses the default orchestrator model."),
             }),
             handler: async (args) => {
                 try {
@@ -759,6 +760,7 @@ export function createTools(deps) {
                                 return "No cron jobs configured.";
                             const lines = status.map((j) => `• ${j.id} — ${j.name} [${j.taskType}] ${j.enabled ? "✅" : "⏸️"} ` +
                                 `${j.active ? "active" : "inactive"} | ${j.cronExpression}` +
+                                (j.model ? ` | model: ${j.model}` : "") +
                                 (j.nextRun ? ` | next: ${j.nextRun}` : ""));
                             return `${status.length} cron job(s):\n${lines.join("\n")}`;
                         }
@@ -773,10 +775,12 @@ export function createTools(deps) {
                                 taskType: args.task_type,
                                 payload: args.payload,
                                 notifyTelegram: args.notify_telegram,
+                                model: args.model,
                             });
                             if (job.enabled)
                                 scheduleJob(job);
-                            return `Cron job '${job.id}' (${job.name}) created and scheduled: ${job.cronExpression}`;
+                            return `Cron job '${job.id}' (${job.name}) created and scheduled: ${job.cronExpression}` +
+                                (job.model ? ` [model: ${job.model}]` : "");
                         }
                         case "remove": {
                             if (!args.job_id)

package/dist/cron/scheduler.js

@@ -71,6 +71,7 @@ export function getSchedulerStatus() {
             enabled: job.enabled,
             active: activeTimers.has(job.id),
             nextRun,
+            model: job.model,
         };
     });
 }

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";
@@ -21,7 +22,7 @@ export async function executeCronTask(job) {
     const payload = JSON.parse(job.payload);
     switch (job.taskType) {
         case "prompt":
-            return await executePromptTask(payload);
+            return await executePromptTask(payload, job.model);
         case "health_check":
             return await executeHealthCheckTask();
         case "backup":
@@ -30,22 +31,27 @@ 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}`);
     }
 }
-async function executePromptTask(payload) {
+async function executePromptTask(payload, model) {
     const prompt = payload.prompt || "Scheduled check-in. Anything to report?";
     try {
+        // Use a lightweight one-off session if a specific model is configured
+        if (model) {
+            const { runOneOffPrompt } = await import("../copilot/orchestrator.js");
+            return await runOneOffPrompt(`[Scheduled task] ${prompt}`, model);
+        }
         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 +112,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 +163,131 @@ 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 {
+        // Use a lightweight one-off session if a specific model is configured
+        if (job.model) {
+            const { runOneOffPrompt } = await import("../copilot/orchestrator.js");
+            aiResponse = await runOneOffPrompt(`[Scheduled vocab task] ${prompt}`, job.model);
+        }
+        else {
+            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/store/cron-store.js

@@ -2,8 +2,8 @@ import { getDb } from "./db.js";
 export function createCronJob(input) {
     const db = getDb();
     const now = new Date().toISOString();
-    db.prepare(`INSERT INTO cron_jobs (id, name, cron_expression, task_type, payload, enabled, notify_telegram, max_retries, timeout_ms, created_at, updated_at)
-		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.id, input.name, input.cronExpression, input.taskType, input.payload ?? "{}", input.enabled !== false ? 1 : 0, input.notifyTelegram !== false ? 1 : 0, input.maxRetries ?? 0, input.timeoutMs ?? 300_000, now, now);
+    db.prepare(`INSERT INTO cron_jobs (id, name, cron_expression, task_type, payload, enabled, notify_telegram, max_retries, timeout_ms, model, created_at, updated_at)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.id, input.name, input.cronExpression, input.taskType, input.payload ?? "{}", input.enabled !== false ? 1 : 0, input.notifyTelegram !== false ? 1 : 0, input.maxRetries ?? 0, input.timeoutMs ?? 300_000, input.model ?? null, now, now);
     return getCronJob(input.id);
 }
 export function getCronJob(id) {
@@ -56,6 +56,10 @@ export function updateCronJob(id, updates) {
         fields.push("timeout_ms = ?");
         values.push(updates.timeoutMs);
     }
+    if (updates.model !== undefined) {
+        fields.push("model = ?");
+        values.push(updates.model);
+    }
     if (updates.lastRunAt !== undefined) {
         fields.push("last_run_at = ?");
         values.push(updates.lastRunAt);
@@ -121,6 +125,7 @@ function mapCronJobRow(row) {
         notifyTelegram: row.notify_telegram === 1,
         maxRetries: row.max_retries,
         timeoutMs: row.timeout_ms,
+        model: row.model ?? null,
         lastRunAt: row.last_run_at,
         nextRunAt: row.next_run_at,
         createdAt: row.created_at,

package/dist/store/db.js

@@ -113,6 +113,13 @@ export function getDb() {
       )
     `);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_cron_runs_job ON cron_runs(job_id, started_at)`);
+        // Migrate: add model column to cron_jobs if missing
+        try {
+            db.prepare(`SELECT model FROM cron_jobs LIMIT 1`).get();
+        }
+        catch {
+            db.exec(`ALTER TABLE cron_jobs ADD COLUMN model TEXT`);
+        }
         // Migrate: if the table already existed with a stricter CHECK, recreate it
         try {
             db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('system', '__migration_test__', 'test')`).run();

package/dist/telegram/bot.js

@@ -276,11 +276,25 @@ function isInternalUrl(urlStr) {
 }
 /** Allowlisted directories for local file photo access. */
 const PHOTO_ALLOWED_DIRS = [tmpdir(), "/tmp"];
+/** Resolve allowed dirs at startup so symlinks are handled (e.g. macOS /tmp → /private/tmp). */
+const RESOLVED_ALLOWED_DIRS = (() => {
+    const resolved = new Set();
+    for (const dir of PHOTO_ALLOWED_DIRS) {
+        resolved.add(dir);
+        try {
+            resolved.add(realpathSync(dir));
+        }
+        catch {
+            // Directory may not exist — keep the original
+        }
+    }
+    return [...resolved];
+})();
 /** Validate a local file path is within allowed directories. */
 function isAllowedFilePath(filePath) {
     try {
         const resolved = realpathSync(pathResolve(filePath));
-        return PHOTO_ALLOWED_DIRS.some((dir) => resolved.startsWith(dir));
+        return RESOLVED_ALLOWED_DIRS.some((dir) => resolved.startsWith(dir));
     }
     catch {
         // Expected: file may not exist or path may be inaccessible
@@ -318,4 +332,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/handlers/cron.js

@@ -3,6 +3,26 @@ import { scheduleJob, triggerJob, unscheduleJob } from "../../cron/scheduler.js"
 import { deleteCronJob, getCronJob, getRecentRuns, listCronJobs, updateCronJob, } from "../../store/cron-store.js";
 import { isMessageNotModifiedError } from "../formatter.js";
 const JOBS_PER_PAGE = 5;
+// ── Schedule presets ─────────────────────────────────────────────────
+const SCHEDULE_PRESETS = [
+    { label: "Every 1 min", cron: "* * * * *" },
+    { label: "Every 5 min", cron: "*/5 * * * *" },
+    { label: "Every 15 min", cron: "*/15 * * * *" },
+    { label: "Every 30 min", cron: "*/30 * * * *" },
+    { label: "Every 1 hour", cron: "0 * * * *" },
+    { label: "Every 6 hours", cron: "0 */6 * * *" },
+    { label: "Every day at 8AM", cron: "0 8 * * *" },
+];
+// In-memory state for users awaiting custom cron expression input
+const pendingCustomSchedule = new Map();
+/** Check if a user is awaiting custom cron input and return the job ID. */
+export function getPendingCustomScheduleJobId(userId) {
+    return pendingCustomSchedule.get(userId);
+}
+/** Clear pending custom schedule state for a user. */
+export function clearPendingCustomSchedule(userId) {
+    pendingCustomSchedule.delete(userId);
+}
 // ── Keyboard builders ────────────────────────────────────────────────
 function buildCronMainMenu() {
     return new InlineKeyboard()
@@ -18,6 +38,7 @@ function buildJobListKeyboard(jobs, page, totalPages) {
     for (const job of pageJobs) {
         const toggleLabel = job.enabled ? "⏸" : "▶️";
         kb.text(`${toggleLabel} ${job.name}`, `cron:toggle:${job.id}`)
+            .text("⏱", `cron:schedule:${job.id}`)
             .text("▶ Run", `cron:trigger:${job.id}`)
             .text("📊", `cron:history:${job.id}`)
             .text("🗑", `cron:delete:${job.id}`)
@@ -33,6 +54,29 @@ function buildJobListKeyboard(jobs, page, totalPages) {
     kb.text("🔙 Back", "cron:back");
     return kb;
 }
+function buildScheduleKeyboard(jobId) {
+    const kb = new InlineKeyboard();
+    for (let i = 0; i < SCHEDULE_PRESETS.length; i++) {
+        const preset = SCHEDULE_PRESETS[i];
+        kb.text(`${preset.label}`, `cron:setsched:${jobId}:${i}`).row();
+    }
+    kb.text("✏️ Custom", `cron:customsched:${jobId}`).row();
+    kb.text("🔙 Back to list", "cron:list");
+    return kb;
+}
+/** Apply a schedule change: update DB and reschedule. */
+function applyScheduleChange(jobId, cronExpression) {
+    const updated = updateCronJob(jobId, { cronExpression });
+    if (!updated)
+        throw new Error("Job not found");
+    let rescheduled = false;
+    if (updated.enabled) {
+        unscheduleJob(jobId);
+        scheduleJob(updated);
+        rescheduled = true;
+    }
+    return { job: updated, rescheduled };
+}
 // ── Text formatters ──────────────────────────────────────────────────
 function formatJobLine(job, index) {
     const status = job.enabled ? "✅" : "⏸";
@@ -338,6 +382,95 @@ export function registerCronHandlers(bot) {
             }
         }
     });
+    // Schedule change — show preset options for a job
+    bot.callbackQuery(/^cron:schedule:(.+)$/, async (ctx) => {
+        try {
+            const jobId = ctx.match[1];
+            const job = getCronJob(jobId);
+            if (!job) {
+                await ctx.answerCallbackQuery({ text: "Job not found", show_alert: true });
+                return;
+            }
+            const text = `⏱ Change Schedule: ${job.name}\n\n` +
+                `Current: ${job.cronExpression}\n\n` +
+                "Select a preset or enter a custom expression:";
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(text, {
+                reply_markup: buildScheduleKeyboard(job.id),
+            });
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron schedule menu error:", err instanceof Error ? err.message : err);
+                await ctx
+                    .answerCallbackQuery({ text: "Error loading schedule options", show_alert: true })
+                    .catch(() => { });
+            }
+        }
+    });
+    // Set schedule from preset
+    bot.callbackQuery(/^cron:setsched:(.+):(\d+)$/, async (ctx) => {
+        try {
+            const jobId = ctx.match[1];
+            const presetIndex = parseInt(ctx.match[2], 10);
+            const preset = SCHEDULE_PRESETS[presetIndex];
+            if (!preset) {
+                await ctx.answerCallbackQuery({ text: "Invalid preset", show_alert: true });
+                return;
+            }
+            const job = getCronJob(jobId);
+            if (!job) {
+                await ctx.answerCallbackQuery({ text: "Job not found", show_alert: true });
+                return;
+            }
+            const { rescheduled } = applyScheduleChange(jobId, preset.cron);
+            const statusNote = rescheduled ? " (rescheduled)" : "";
+            await ctx.answerCallbackQuery(`Schedule → ${preset.cron}${statusNote}`);
+            await showCronList(ctx, 0, true);
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron set schedule error:", err instanceof Error ? err.message : err);
+                await ctx
+                    .answerCallbackQuery({ text: "Error updating schedule", show_alert: true })
+                    .catch(() => { });
+            }
+        }
+    });
+    // Custom schedule — prompt user to type cron expression
+    bot.callbackQuery(/^cron:customsched:(.+)$/, async (ctx) => {
+        try {
+            const jobId = ctx.match[1];
+            const job = getCronJob(jobId);
+            if (!job) {
+                await ctx.answerCallbackQuery({ text: "Job not found", show_alert: true });
+                return;
+            }
+            const userId = ctx.from?.id;
+            if (userId) {
+                pendingCustomSchedule.set(userId, jobId);
+            }
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(`✏️ Custom Schedule: ${job.name}\n\n` +
+                `Current: ${job.cronExpression}\n\n` +
+                "Type your cron expression in the chat.\n\n" +
+                "Examples:\n" +
+                "• 0 9 * * MON-FRI — weekdays at 9AM\n" +
+                "• */10 * * * * — every 10 minutes\n" +
+                "• 0 0 1 * * — first day of month\n" +
+                "• 30 14 * * * — daily at 2:30PM", {
+                reply_markup: new InlineKeyboard().text("❌ Cancel", "cron:list"),
+            });
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron custom schedule error:", err instanceof Error ? err.message : err);
+                await ctx
+                    .answerCallbackQuery({ text: "Error", show_alert: true })
+                    .catch(() => { });
+            }
+        }
+    });
     // Back to main cron menu
     bot.callbackQuery("cron:back", async (ctx) => {
         try {
@@ -350,5 +483,46 @@ export function registerCronHandlers(bot) {
             }
         }
     });
+    // Intercept text messages when a user is in "custom cron schedule" mode.
+    // Must be registered before the main streaming handler so it can short-circuit.
+    bot.on("message:text", async (ctx, next) => {
+        const userId = ctx.from?.id;
+        if (!userId)
+            return next();
+        const jobId = pendingCustomSchedule.get(userId);
+        if (!jobId)
+            return next();
+        // Clear pending state immediately so subsequent messages go to the AI
+        pendingCustomSchedule.delete(userId);
+        const cronExpr = ctx.message.text.trim();
+        if (!cronExpr) {
+            await ctx.reply("❌ Empty expression. Schedule not changed.", {
+                reply_markup: new InlineKeyboard().text("🔙 Back to list", "cron:list"),
+            });
+            return;
+        }
+        const job = getCronJob(jobId);
+        if (!job) {
+            await ctx.reply("❌ Job no longer exists.");
+            return;
+        }
+        try {
+            const { job: updated, rescheduled } = applyScheduleChange(jobId, cronExpr);
+            const statusNote = rescheduled ? " and rescheduled" : "";
+            await ctx.reply(`✅ Schedule updated${statusNote}!\n\n` +
+                `📋 ${updated.name}\n` +
+                `⏰ ${updated.cronExpression}`, {
+                reply_markup: new InlineKeyboard().text("📋 Back to list", "cron:list"),
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await ctx.reply(`❌ Invalid cron expression: ${cronExpr}\n\n${msg}\n\nTry again or tap Cancel.`, {
+                reply_markup: new InlineKeyboard()
+                    .text("🔄 Retry", `cron:customsched:${jobId}`)
+                    .text("❌ Cancel", "cron:list"),
+            });
+        }
+    });
 }
 //# sourceMappingURL=cron.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.9.0",
     "description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
     "bin": {
         "nzb": "dist/cli.js"