@iletai/nzb 1.9.1 → 1.10.1

package/dist/cron/research-runner.js

@@ -0,0 +1,208 @@
+import { config } from "../config.js";
+const FETCH_TIMEOUT_MS = 10_000;
+const USER_AGENT = "nzb-research/1.0";
+// ── HTTP helper ──────────────────────────────────────────────────────
+async function fetchJson(url) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { "User-Agent": USER_AGENT },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} ${res.statusText}`);
+        return (await res.json());
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// ── Source fetchers ──────────────────────────────────────────────────
+async function fetchHackerNews() {
+    const ids = await fetchJson("https://hacker-news.firebaseio.com/v0/topstories.json");
+    const top10 = ids.slice(0, 10);
+    const items = await Promise.all(top10.map((id) => fetchJson(`https://hacker-news.firebaseio.com/v0/item/${id}.json`)));
+    const lines = items.map((item, i) => `${i + 1}. ${item.title ?? "Untitled"} (${item.score ?? 0} pts, ${item.descendants ?? 0} comments)${item.url ? `\n   ${item.url}` : ""}`);
+    return lines.join("\n");
+}
+async function fetchGitHubTrending() {
+    const since = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .split("T")[0];
+    const data = await fetchJson(`https://api.github.com/search/repositories?q=created:>${since}&sort=stars&order=desc&per_page=5`);
+    const repos = data.items ?? [];
+    const lines = repos.map((r, i) => `${i + 1}. ${r.full_name ?? "unknown"} ⭐${r.stargazers_count ?? 0} [${r.language ?? "N/A"}]\n   ${r.description ?? "No description"}\n   ${r.html_url ?? ""}`);
+    return lines.join("\n");
+}
+async function fetchReddit(subreddit) {
+    const data = await fetchJson(`https://www.reddit.com/r/${subreddit}/hot.json?limit=5`);
+    const posts = data.data?.children ?? [];
+    const lines = posts
+        .filter((p) => p.data.title)
+        .map((p, i) => `${i + 1}. ${p.data.title} (${p.data.score ?? 0} pts, ${p.data.num_comments ?? 0} comments)`);
+    return lines.join("\n");
+}
+async function fetchGoldPrice() {
+    // Use a free metals API. Falls back to a message if unavailable.
+    try {
+        const data = await fetchJson("https://api.metals.dev/v1/latest?api_key=demo&currency=USD&unit=toz");
+        const metals = data.metals;
+        if (metals) {
+            const lines = [];
+            if (metals.gold)
+                lines.push(`Gold: $${metals.gold}/oz`);
+            if (metals.silver)
+                lines.push(`Silver: $${metals.silver}/oz`);
+            if (metals.platinum)
+                lines.push(`Platinum: $${metals.platinum}/oz`);
+            return lines.join("\n") || "No metal price data available.";
+        }
+        return JSON.stringify(data).slice(0, 500);
+    }
+    catch {
+        // Fallback: try alternative free API
+        try {
+            const data = await fetchJson("https://www.goldapi.io/api/XAU/USD");
+            const price = data.price;
+            return price ? `Gold: $${price}/oz` : JSON.stringify(data).slice(0, 300);
+        }
+        catch {
+            return "Gold price APIs unavailable. Could not fetch current prices.";
+        }
+    }
+}
+async function fetchCryptoPrices() {
+    const data = await fetchJson("https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum,solana,cardano&vs_currencies=usd&include_24hr_change=true");
+    const lines = [];
+    for (const [coin, info] of Object.entries(data)) {
+        const change = info.usd_24h_change != null ? ` (${info.usd_24h_change > 0 ? "+" : ""}${info.usd_24h_change.toFixed(2)}%)` : "";
+        lines.push(`${coin}: $${info.usd ?? "N/A"}${change}`);
+    }
+    return lines.join("\n") || "No crypto data available.";
+}
+// ── Presets ───────────────────────────────────────────────────────────
+function getPresetSources(preset) {
+    switch (preset) {
+        case "tech-trends":
+            return [
+                { name: "HackerNews Top Stories", fetchData: fetchHackerNews },
+                { name: "GitHub Trending Repos (last 7 days)", fetchData: fetchGitHubTrending },
+                { name: "Reddit r/programming", fetchData: () => fetchReddit("programming") },
+                { name: "Reddit r/MachineLearning", fetchData: () => fetchReddit("MachineLearning") },
+            ];
+        case "gold-price":
+            return [
+                { name: "Gold & Metals Prices", fetchData: fetchGoldPrice },
+            ];
+        case "crypto":
+            return [
+                { name: "Cryptocurrency Prices", fetchData: fetchCryptoPrices },
+            ];
+        default:
+            return [];
+    }
+}
+function buildCustomSources(sources) {
+    return sources.map((s) => ({
+        name: s.name,
+        fetchData: async () => {
+            const data = await fetchJson(s.url);
+            return typeof data === "string" ? data : JSON.stringify(data).slice(0, 2000);
+        },
+    }));
+}
+// ── Fetch all sources in parallel ────────────────────────────────────
+async function fetchAllSources(sources) {
+    const results = await Promise.allSettled(sources.map(async (src) => {
+        try {
+            const data = await src.fetchData();
+            return { name: src.name, data };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { name: src.name, data: `[Failed to fetch: ${msg}]` };
+        }
+    }));
+    const sections = [];
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            sections.push(`## ${result.value.name}\n${result.value.data}`);
+        }
+    }
+    return sections.join("\n\n");
+}
+// ── Main entry point ─────────────────────────────────────────────────
+export async function executeResearchTask(job, payload) {
+    // 1. Determine sources
+    const preset = payload.preset;
+    const customSources = payload.sources;
+    const prompt = payload.prompt || "Summarize the following data concisely.";
+    let sources = [];
+    if (preset) {
+        sources = getPresetSources(preset);
+        if (sources.length === 0) {
+            throw new Error(`Unknown research preset: ${preset}. Available: tech-trends, gold-price, crypto`);
+        }
+    }
+    if (customSources && Array.isArray(customSources)) {
+        sources = sources.concat(buildCustomSources(customSources));
+    }
+    if (sources.length === 0) {
+        throw new Error("Research task requires 'preset' or 'sources' in payload. Available presets: tech-trends, gold-price, crypto");
+    }
+    // 2. Fetch real data from all sources
+    console.log(`[nzb] Research task '${job.id}': fetching ${sources.length} source(s)...`);
+    const fetchedData = await fetchAllSources(sources);
+    if (!fetchedData.trim()) {
+        throw new Error("All research sources failed to return data.");
+    }
+    // 3. Build AI prompt with real data
+    const aiPrompt = `[Scheduled research task]
+
+You are given REAL-TIME data fetched from the internet just now. Use ONLY this data to produce your summary — do NOT use your built-in knowledge for facts or figures.
+
+USER INSTRUCTIONS:
+${prompt}
+
+--- FETCHED DATA (${new Date().toISOString()}) ---
+
+${fetchedData}
+
+--- END OF DATA ---
+
+Based on the data above, provide your summary following the user's instructions.`;
+    // 4. Send to AI for summarization
+    console.log(`[nzb] Research task '${job.id}': sending to AI for summarization...`);
+    let aiResponse;
+    try {
+        if (job.model) {
+            const { runOneOffPrompt } = await import("../copilot/orchestrator.js");
+            aiResponse = await runOneOffPrompt(aiPrompt, job.model);
+        }
+        else {
+            const { sendToOrchestrator } = await import("../copilot/orchestrator.js");
+            aiResponse = await new Promise((resolve) => {
+                sendToOrchestrator(aiPrompt, { type: "background" }, (text, done) => {
+                    if (done)
+                        resolve(text);
+                });
+            });
+        }
+    }
+    catch (err) {
+        throw new Error(`Research AI summarization failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // 5. Format and send to Telegram
+    const header = preset
+        ? `🔬 Research: ${preset}`
+        : "🔬 Research Report";
+    const formattedMessage = `${header}\n\n${aiResponse}`;
+    if (config.telegramEnabled) {
+        const { sendProactiveMessage } = await import("../telegram/bot.js");
+        await sendProactiveMessage(formattedMessage);
+    }
+    console.log(`[nzb] Research task '${job.id}': completed successfully.`);
+    return formattedMessage;
+}
+//# sourceMappingURL=research-runner.js.map

package/dist/cron/scheduler.js

@@ -107,7 +107,10 @@ async function runJob(jobId) {
                     }
                 }
                 console.log(`[nzb] Cron job '${job.id}' completed in ${finishedAt.getTime() - startedAt.getTime()}ms`);
-                await notifyResult(job, `✅ Completed\n${result}`);
+                // Vocab and research tasks handle their own Telegram notifications
+                if (job.taskType !== "vocab" && job.taskType !== "research") {
+                    await notifyResult(job, `✅ Completed\n${result}`);
+                }
                 return result;
             }
             catch (err) {

package/dist/cron/task-runner.js

@@ -4,6 +4,7 @@ import { freemem, totalmem } from "os";
 import { join } from "path";
 import { config } from "../config.js";
 import { DB_PATH, NZB_HOME } from "../paths.js";
+import { executeResearchTask } from "./research-runner.js";
 const BACKUPS_DIR = join(NZB_HOME, "backups");
 /** Notify result to Telegram if the job has notifyTelegram enabled. */
 export async function notifyResult(job, message) {
@@ -33,6 +34,8 @@ export async function executeCronTask(job) {
             return await executeWebhookTask(payload, job.timeoutMs);
         case "vocab":
             return await executeVocabTask(job, payload);
+        case "research":
+            return await executeResearchTask(job, payload);
         default:
             throw new Error(`Unknown task type: ${job.taskType}`);
     }

package/dist/daemon.js

@@ -4,11 +4,14 @@ import { broadcastToSSE, startApiServer } from "./api/server.js";
 import { config } from "./config.js";
 import { getClient, stopClient } from "./copilot/client.js";
 import { getWorkers, initOrchestrator, setMessageLogger, setProactiveNotify, setWorkerNotify, stopHealthCheck, } from "./copilot/orchestrator.js";
+import { closeDaemonLogger, initDaemonLogger } from "./logger.js";
 import { PID_FILE_PATH } from "./paths.js";
 import { closeDb, getDb } from "./store/db.js";
 import { createBot, sendProactiveMessage, sendWorkerNotification, startBot, stopBot } from "./telegram/bot.js";
 import { startCronScheduler, stopCronScheduler } from "./cron/scheduler.js";
 import { checkForUpdate, getDismissedVersion, isAutoUpdateEnabled, scheduleUpdateCheck, shouldCheckUpdate, stopUpdateCheck } from "./update.js";
+// Initialize file logging before anything else
+initDaemonLogger();
 // Log the active CA bundle (injected by cli.ts via re-exec).
 if (process.env.NODE_EXTRA_CA_CERTS) {
     console.log(`[nzb] Using system CA bundle: ${process.env.NODE_EXTRA_CA_CERTS}`);
@@ -261,6 +264,7 @@ async function shutdown() {
     closeDb();
     releasePidLock();
     console.log("[nzb] Goodbye.");
+    closeDaemonLogger();
     process.exit(0);
 }
 /** Restart the daemon by spawning a new process and exiting. */
@@ -294,6 +298,7 @@ export async function restartDaemon() {
     }
     closeDb();
     releasePidLock();
+    closeDaemonLogger();
     // Spawn a detached replacement process with the same args (include execArgv for tsx/loaders)
     const child = spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
         detached: true,

package/dist/logger.js

@@ -0,0 +1,118 @@
+import { createWriteStream, readFileSync, renameSync, statSync } from "fs";
+import { DAEMON_LOG_PATH, ensureNZBHome } from "./paths.js";
+/** Max log file size before rotation (5 MB) */
+const MAX_LOG_SIZE = 5 * 1024 * 1024;
+let logStream;
+let originalLog;
+let originalError;
+let originalWarn;
+let initialized = false;
+function getTimestamp() {
+    return new Date().toISOString().replace("T", " ").slice(0, 23);
+}
+/** Rotate daemon.log → daemon.log.1 if it exceeds MAX_LOG_SIZE */
+function rotateIfNeeded() {
+    try {
+        const stats = statSync(DAEMON_LOG_PATH);
+        if (stats.size >= MAX_LOG_SIZE) {
+            if (logStream) {
+                logStream.end();
+                logStream = undefined;
+            }
+            renameSync(DAEMON_LOG_PATH, DAEMON_LOG_PATH + ".1");
+        }
+    }
+    catch {
+        // File doesn't exist yet — nothing to rotate
+    }
+}
+function ensureStream() {
+    if (!logStream || logStream.destroyed) {
+        logStream = createWriteStream(DAEMON_LOG_PATH, { flags: "a" });
+        logStream.on("error", () => {
+            // Silently ignore write errors — never crash the daemon for logging
+        });
+    }
+    return logStream;
+}
+function formatArgs(args) {
+    return args
+        .map((a) => {
+        if (typeof a === "string")
+            return a;
+        if (a instanceof Error)
+            return `${a.message}\n${a.stack ?? ""}`;
+        try {
+            return JSON.stringify(a);
+        }
+        catch {
+            return String(a);
+        }
+    })
+        .join(" ");
+}
+/**
+ * Initialize daemon file logging.
+ * Intercepts console.log, console.error, console.warn and mirrors
+ * all output to ~/.nzb/daemon.log with timestamps.
+ * Call this once at daemon startup before any other logging.
+ */
+export function initDaemonLogger() {
+    if (initialized)
+        return;
+    initialized = true;
+    ensureNZBHome();
+    rotateIfNeeded();
+    originalLog = console.log.bind(console);
+    originalError = console.error.bind(console);
+    originalWarn = console.warn.bind(console);
+    console.log = (...args) => {
+        originalLog(...args);
+        const line = `${getTimestamp()} [LOG] ${formatArgs(args)}\n`;
+        try {
+            ensureStream().write(line);
+        }
+        catch {
+            // Never crash for logging
+        }
+    };
+    console.error = (...args) => {
+        originalError(...args);
+        const line = `${getTimestamp()} [ERR] ${formatArgs(args)}\n`;
+        try {
+            ensureStream().write(line);
+        }
+        catch {
+            // Never crash for logging
+        }
+    };
+    console.warn = (...args) => {
+        originalWarn(...args);
+        const line = `${getTimestamp()} [WRN] ${formatArgs(args)}\n`;
+        try {
+            ensureStream().write(line);
+        }
+        catch {
+            // Never crash for logging
+        }
+    };
+}
+/** Close the log stream gracefully (call during shutdown) */
+export function closeDaemonLogger() {
+    if (logStream && !logStream.destroyed) {
+        logStream.end();
+        logStream = undefined;
+    }
+}
+/** Read the last N lines from the daemon log file. Returns null if file doesn't exist. */
+export function tailDaemonLog(lines = 50) {
+    try {
+        const content = readFileSync(DAEMON_LOG_PATH, "utf-8");
+        const allLines = content.trimEnd().split("\n");
+        return allLines.slice(-lines).join("\n");
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/paths.js

@@ -19,6 +19,8 @@ export const TUI_DEBUG_LOG_PATH = join(NZB_HOME, "tui-debug.log");
 export const API_TOKEN_PATH = join(NZB_HOME, "api-token");
 /** Path to the PID lock file for single-instance enforcement */
 export const PID_FILE_PATH = join(NZB_HOME, "nzb.pid");
+/** Path to the daemon console log file */
+export const DAEMON_LOG_PATH = join(NZB_HOME, "daemon.log");
 /** Ensure ~/.nzb/ exists */
 export function ensureNZBHome() {
     mkdirSync(NZB_HOME, { recursive: true });

package/dist/telegram/handlers/commands.js

@@ -2,8 +2,9 @@ import { config, persistEnvVar, persistModel } from "../../config.js";
 import { cancelCurrentMessage, compactSession, getQueueSize, getWorkers, resetSession, } from "../../copilot/orchestrator.js";
 import { listSkills } from "../../copilot/skills.js";
 import { restartDaemon } from "../../daemon.js";
+import { tailDaemonLog } from "../../logger.js";
 import { searchMemories } from "../../store/memory.js";
-import { chunkMessage } from "../formatter.js";
+import { chunkMessage, escapeHtml } from "../formatter.js";
 import { buildSettingsText, formatMemoryList } from "../menus.js";
 import { sendCronMenu } from "./cron.js";
 import { getReactionHelpText } from "./reactions.js";
@@ -31,6 +32,7 @@ export function registerCommandHandlers(bot, deps) {
         "/memory — Stored memories\n" +
         "/skills — Installed skills\n" +
         "/workers — Active worker sessions\n" +
+        "/logs [N] — Tail daemon log (last N lines)\n" +
         "/cron — Manage cron jobs\n" +
         "/update — Check for updates\n" +
         "/restart — Restart NZB\n\n" +
@@ -194,6 +196,22 @@ export function registerCommandHandlers(bot, deps) {
             });
         }, 500);
     });
+    bot.command("logs", async (ctx) => {
+        const arg = ctx.match?.trim();
+        const lineCount = arg ? parseInt(arg, 10) : 50;
+        const count = Number.isNaN(lineCount) || lineCount < 1 ? 50 : Math.min(lineCount, 200);
+        const lines = tailDaemonLog(count);
+        if (!lines) {
+            await ctx.reply("No daemon log found.");
+            return;
+        }
+        const header = `📋 Last ${count} log lines:`;
+        const text = `${header}\n\n<pre>${escapeHtml(lines)}</pre>`;
+        const chunks = chunkMessage(text);
+        for (const chunk of chunks) {
+            await ctx.reply(chunk, { parse_mode: "HTML" });
+        }
+    });
     bot.command("settings", async (ctx) => {
         await ctx.reply(buildSettingsText(getUptimeStr), { reply_markup: settingsMenu });
     });

package/package.json

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