@iletai/nzb 1.8.2 → 1.9.1

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

@@ -22,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":
@@ -37,9 +37,14 @@ export async function executeCronTask(job) {
             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");
         // No internal timeout — the scheduler's withTaskTimeout() handles it
         // using the per-job configurable timeoutMs (default 5min).
@@ -174,13 +179,20 @@ async function executeVocabTask(job, payload) {
     // 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);
+        // 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)}`);
@@ -250,7 +262,8 @@ async function generateAndSendVocabAudio(word) {
     }
     catch { /* ignore */ }
     // Generate TTS with macOS say
-    execSync(`say -v Samantha -o "${aiffPath}" "${word.replace(/"/g, '\\"')}"`, {
+    const safeWord = word.replace(/["`$\\]/g, "");
+    execSync(`say -v Samantha -o "${aiffPath}" "${safeWord}"`, {
         timeout: 10_000,
     });
     if (!existsSync(aiffPath)) {
@@ -263,16 +276,21 @@ async function generateAndSendVocabAudio(word) {
     if (!existsSync(m4aPath)) {
         throw new Error("Audio conversion failed: m4a file not created");
     }
+    // Resolve symlink path (macOS /tmp → /private/tmp) for grammy InputFile
+    const { realpathSync: realpath } = await import("fs");
+    const resolvedPath = realpath(m4aPath);
+    console.log(`[nzb] Vocab TTS: sending voice for "${word}" (${resolvedPath}, ${statSync(resolvedPath).size} bytes)`);
     // Send voice via Telegram
     const { sendVoice } = await import("../telegram/bot.js");
-    await sendVoice(m4aPath, `🔊 ${word}`);
+    await sendVoice(resolvedPath, `🔊 ${word}`);
+    console.log(`[nzb] Vocab TTS: voice sent successfully for "${word}"`);
     // Clean up temp files
     try {
         unlinkSync(aiffPath);
     }
     catch { /* ignore */ }
     try {
-        unlinkSync(m4aPath);
+        unlinkSync(resolvedPath);
     }
     catch { /* ignore */ }
 }

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

package/dist/telegram/handlers/cron.js

@@ -3,6 +3,33 @@ 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 * * *" },
+];
+// ── Model presets ────────────────────────────────────────────────────
+const MODEL_PRESETS = [
+    { label: "⚡ Haiku (fast & cheap)", id: "claude-haiku-4.5", short: "haiku" },
+    { label: "⚖️ Sonnet (balanced)", id: "claude-sonnet-4", short: "sonnet" },
+    { label: "🧠 Opus (most capable)", id: "claude-opus-4.6", short: "opus" },
+    { label: "⚡ GPT-4.1 (fast alt)", id: "gpt-4.1", short: "gpt-4.1" },
+];
+// 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 +45,8 @@ 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("🤖", `cron:model:${job.id}`)
             .text("▶ Run", `cron:trigger:${job.id}`)
             .text("📊", `cron:history:${job.id}`)
             .text("🗑", `cron:delete:${job.id}`)
@@ -33,6 +62,41 @@ 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;
+}
+function buildModelKeyboard(jobId, currentModel) {
+    const kb = new InlineKeyboard();
+    for (let i = 0; i < MODEL_PRESETS.length; i++) {
+        const preset = MODEL_PRESETS[i];
+        const current = currentModel === preset.id ? " ✓" : "";
+        kb.text(`${preset.label}${current}`, `cron:setmodel:${jobId}:${i}`).row();
+    }
+    const noOverride = !currentModel ? " ✓" : "";
+    kb.text(`🚫 No model override (use default)${noOverride}`, `cron:setmodel:${jobId}:none`).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 ? "✅" : "⏸";
@@ -44,8 +108,11 @@ function formatJobLine(job, index) {
             minute: "2-digit",
         })
         : "—";
+    const modelTag = job.model
+        ? ` | 🤖 ${MODEL_PRESETS.find((p) => p.id === job.model)?.short ?? job.model}`
+        : "";
     return (`${index}. ${status} ${job.name}\n` +
-        `   ⏰ ${job.cronExpression} | 🏷 ${job.taskType}\n` +
+        `   ⏰ ${job.cronExpression} | 🏷 ${job.taskType}${modelTag}\n` +
         `   📅 Next: ${nextRun}`);
 }
 function buildJobListText(jobs, page, totalPages) {
@@ -338,6 +405,163 @@ 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(() => { });
+            }
+        }
+    });
+    // Model selection — show model presets for a job
+    bot.callbackQuery(/^cron:model:(.+)$/, 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 currentLabel = job.model
+                ? MODEL_PRESETS.find((p) => p.id === job.model)?.label ?? job.model
+                : "Default (no override)";
+            const text = `🤖 Change Model: ${job.name}\n\n` +
+                `Current: ${currentLabel}\n\n` +
+                "Select a model for this job:";
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(text, {
+                reply_markup: buildModelKeyboard(job.id, job.model),
+            });
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron model menu error:", err instanceof Error ? err.message : err);
+                await ctx
+                    .answerCallbackQuery({ text: "Error loading model options", show_alert: true })
+                    .catch(() => { });
+            }
+        }
+    });
+    // Set model from preset or clear override
+    bot.callbackQuery(/^cron:setmodel:(.+):(none|\d+)$/, async (ctx) => {
+        try {
+            const jobId = ctx.match[1];
+            const selection = ctx.match[2];
+            const job = getCronJob(jobId);
+            if (!job) {
+                await ctx.answerCallbackQuery({ text: "Job not found", show_alert: true });
+                return;
+            }
+            let newModel;
+            let label;
+            if (selection === "none") {
+                newModel = null;
+                label = "default";
+            }
+            else {
+                const presetIndex = parseInt(selection, 10);
+                const preset = MODEL_PRESETS[presetIndex];
+                if (!preset) {
+                    await ctx.answerCallbackQuery({ text: "Invalid model", show_alert: true });
+                    return;
+                }
+                newModel = preset.id;
+                label = preset.short;
+            }
+            updateCronJob(jobId, { model: newModel });
+            await ctx.answerCallbackQuery(`Model → ${label}`);
+            await showCronList(ctx, 0, true);
+        }
+        catch (err) {
+            if (!isMessageNotModifiedError(err)) {
+                console.error("[nzb] Cron set model error:", err instanceof Error ? err.message : err);
+                await ctx
+                    .answerCallbackQuery({ text: "Error updating model", 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 +574,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/package.json

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