stella-coder 5.1.1 → 5.2.0

package/capture.ps1

@@ -0,0 +1,14 @@
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+try {
+  $bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+  $bitmap = New-Object System.Drawing.Bitmap($bounds.Width, $bounds.Height)
+  $graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+  $graphics.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size)
+  $bitmap.Save("C:\Users\user\Downloads\stella-coder-3-9\test_screen.png")
+  $graphics.Dispose()
+  $bitmap.Dispose()
+  Write-Output "OK"
+} catch {
+  Write-Output "FAIL:$($_.Exception.Message)"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stella-coder",
-  "version": "5.1.1",
+  "version": "5.2.0",
   "private": false,
   "description": "Stella Coder 5.0 — AI coding agent with Telegram bot, huge context, TDD, Git ecosystem, presentations, computer control, smart home, Office automation, and antivirus",
   "main": "stella-cli/index.mjs",

package/stella-cli/index.mjs

@@ -22,6 +22,7 @@ import { runSubagent, listSubagents, parseAgentCommand, SUBAGENTS } from "./suba
 import { mcp, MCP_COMMANDS } from "./mcp.mjs"
 import { generatePresentation, createPresentationFromTopic, AVAILABLE_THEMES, exportToPDF } from "./presentations.mjs"
 import { AutonomousAgent } from "./autonomous-agent.mjs"
+import { ScreenMonitor } from "./screen-monitor.mjs"
 import {
   buildRepoMap, buildProjectContext, compressContext,
   loadSpec, generateSpecTemplate,
@@ -41,7 +42,7 @@ import {
   generateAdminCode, listAuthorizedUsers,
 } from "./telegram-bot.mjs"
 
-const VERSION = "5.1.1"
+const VERSION = "5.2.0"
 const CONFIG_DIR = path.join(os.homedir(), ".stella")
 const CONFIG_PATH = path.join(CONFIG_DIR, "config.json")
 const HISTORY_PATH = path.join(CONFIG_DIR, "history.json")
@@ -650,6 +651,13 @@ const COMMANDS = [
   ["/auto-dashboard", "создать dashboard с результатами"],
   ["/auto-history", "история выполненных задач"],
 
+  // Computer Vision Monitor
+  ["/monitor", "запустить мониторинг экрана (AI vision)"],
+  ["/monitor-stop", "остановить мониторинг"],
+  ["/monitor-status", "статус мониторинга"],
+  ["/monitor-alerts", "показать обнаруженные проблемы"],
+  ["/monitor-screenshot", "сделать скриншот и проанализировать"],
+
   // Управление компьютером
   ["/open", "открыть приложение/файл/URL"],
   ["/app", "запустить приложение"],
@@ -775,6 +783,7 @@ async function handleCommand(line) {
         ["📱 Telegram", ["/tg", "/tg-stop", "/tg-notify", "/tg-sessions", "/tg-verify", "/tg-code", "/tg-users"]],
         ["🔀 Git Экосистема", ["/git-eco", "/git-pr", "/git-merge-auto"]],
         ["🤖 Autonomous Agent", ["/auto", "/auto-stop", "/auto-status", "/auto-dashboard", "/auto-history"]],
+        ["👁️ Computer Vision", ["/monitor", "/monitor-stop", "/monitor-status", "/monitor-alerts", "/monitor-screenshot"]],
         ["⚙️ Настройки", ["/help", "/model", "/clear", "/compact", "/cost", "/context", "/config", "/version", "/login", "/newkey", "/doctor", "/sessions", "/color", "/lang", "/shortcut"]],
       ]
       for (const [cat, cmds] of categories) {
@@ -3444,8 +3453,13 @@ async function handleCommand(line) {
       console.log()
 
       const apiCall = async (prompt) => {
-        const response = await queryAI(prompt, apiKey, state.model)
-        return response
+        const model = getModel(state.model)
+        const { text } = await generateText({
+          model,
+          messages: [{ role: "user", content: prompt }],
+          maxTokens: 16000,
+        })
+        return text
       }
 
       console.log(dim("  Запускаю автономный режим...\n"))
@@ -3594,6 +3608,242 @@ async function handleCommand(line) {
       return
     }
 
+    // ═══════════════════════════════════════════════════
+    //  COMPUTER VISION MONITOR
+    // ═══════════════════════════════════════════════════
+    case "/monitor": {
+      console.log()
+      const monitor = new ScreenMonitor()
+
+      if (monitor.state.running) {
+        console.log(yellow("  Мониторинг уже запущен! Используй /monitor-stop для остановки.\n"))
+        return
+      }
+
+      const intervalSec = arg ? parseInt(arg) || 2 : 2
+      const intervalMs = intervalSec * 1000
+
+      console.log(box([
+        violet("👁️  COMPUTER VISION MONITOR"),
+        "",
+        white("Интервал: ") + cyan(`${intervalSec} секунды`),
+        white("Режим:    ") + cyan("автоматический скриншот + AI анализ"),
+        "",
+        dim("Агент будет делать скриншот каждые") + white(`${intervalSec}с`),
+        dim("и анализировать через AI на наличие ошибок, крашей, алертов."),
+        dim("Все обнаруженные проблемы будут сохранены в лог."),
+      ], { color: violet, padding: 2 }))
+      console.log()
+
+      const confirmMonitor = await question("  " + green("Запустить мониторинг? (y/n) › "))
+      if (confirmMonitor.trim().toLowerCase() !== "y" && confirmMonitor.trim().toLowerCase() !== "д") {
+        console.log(dim("  Отменено\n"))
+        return
+      }
+
+      const visionFn = async (imageBase64, recentContext) => {
+        const contextStr = recentContext?.length > 0
+          ? `\nRecent history:\n${recentContext.map(r => `- ${r.time}: ${r.summary} (${r.alerts} alerts)`).join("\n")}`
+          : ""
+
+        const prompt = `Analyze this screenshot. Detect:
+1. Error messages, crash dialogs, exception windows
+2. Alert popups, warning notifications
+3. Application crashes or "not responding" dialogs
+4. System errors, BSOD, kernel panics
+5. Any other issues or anomalies
+
+${contextStr}
+
+Return JSON:
+{
+  "summary": "one-line description of what's on screen",
+  "text": "detailed analysis of what you see",
+  "issues": ["list of issues found"],
+  "severity": "none|info|warning|critical",
+  "recommendations": ["what to do about issues"]
+}
+
+If everything looks normal, set severity to "none" and issues to [].`
+
+        const model = getModel(state.model)
+        const { text } = await generateText({
+          model,
+          messages: [{
+            role: "user",
+            content: [
+              { type: "text", text: prompt },
+              { type: "image", image: `data:image/png;base64,${imageBase64}` }
+            ]
+          }],
+          maxTokens: 2000,
+        })
+
+        try {
+          let clean = text.trim()
+          if (clean.startsWith("```")) clean = clean.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "")
+          return JSON.parse(clean)
+        } catch {
+          return { summary: text.slice(0, 200), text, issues: [], severity: "none", recommendations: [] }
+        }
+      }
+
+      console.log()
+      startSpinner("Запускаю мониторинг")
+      const result = monitor.start(intervalMs, visionFn)
+      stopSpinner()
+
+      if (result.success) {
+        console.log(green(`  ✓ Мониторинг запущен! Интервал: ${intervalSec}с`))
+        console.log(dim("  Скриншоты сохраняются в ~/.stella/monitor/screenshots/"))
+        console.log(dim("  Используй /monitor-stop для остановки"))
+        console.log(dim("  Используй /monitor-status для проверки"))
+        console.log(dim("  Используй /monitor-alerts для просмотра проблем\n"))
+
+        // Show first capture
+        console.log(dim("  Делаю первый скриншот..."))
+        const firstCapture = await monitor.captureAndAnalyze(visionFn)
+        if (firstCapture.success) {
+          console.log(green(`  ✓ Скриншот: ${firstCapture.capture.sizeKB}KB`))
+          if (firstCapture.capture.analysis?.summary) {
+            console.log(dim("  Анализ: ") + white(firstCapture.capture.analysis.summary))
+          }
+          if (firstCapture.capture.alerts?.length > 0) {
+            console.log(yellow(`  ⚠️ Обнаружено проблем: ${firstCapture.capture.alerts.length}`))
+          }
+        }
+        console.log()
+      } else {
+        console.log(red(`  ✗ ${result.error}\n`))
+      }
+      return
+    }
+
+    case "/monitor-stop": {
+      console.log()
+      const monitor = new ScreenMonitor()
+      if (!monitor.state.running) {
+        console.log(dim("  Мониторинг не запущен\n"))
+        return
+      }
+      monitor.stop()
+      console.log(green("  ✓ Мониторинг остановлен"))
+      console.log(dim(`  Всего скриншотов: ${monitor.state.totalCaptures}`))
+      console.log(dim(`  Всего алертов: ${monitor.state.totalAlerts}`))
+      console.log()
+      return
+    }
+
+    case "/monitor-status": {
+      console.log()
+      const monitor = new ScreenMonitor()
+      const status = monitor.getStatus()
+
+      if (!status.running && status.totalCaptures === 0) {
+        console.log(dim("  Мониторинг не запущен. Используй /monitor для запуска.\n"))
+        return
+      }
+
+      const items = [
+        dim("Статус:     ") + (status.running ? green("● RUNNING") : red("○ STOPPED")),
+        dim("Интервал:   ") + cyan(`every ${status.interval / 1000}s`),
+        dim("Начато:     ") + white(status.startedAt ? new Date(status.startedAt).toLocaleString() : "—"),
+        dim("Скриншотов: ") + cyan(String(status.totalCaptures)),
+        dim("Алертов:    ") + (status.totalAlerts > 0 ? red(String(status.totalAlerts)) : green("0")),
+        dim("PID:        ") + white(String(status.pid || "—")),
+      ]
+
+      if (status.recentAlerts.length > 0) {
+        items.push("", violet("Последние алерты:"))
+        for (const a of status.recentAlerts.slice(-5)) {
+          const icon = a.severity === "critical" ? red("🔴") : yellow("🟡")
+          items.push(`  ${icon} [${new Date(a.timestamp).toLocaleTimeString()}] ${a.type}`)
+          if (a.description) items.push(dim(`     ${a.description.slice(0, 100)}`))
+        }
+      }
+
+      if (status.recentCaptures.length > 0) {
+        items.push("", dim("Последние скриншоты:"))
+        for (const c of status.recentCaptures) {
+          const icon = c.alertCount > 0 ? yellow("⚠️") : green("✅")
+          items.push(`  ${icon} [${new Date(c.time).toLocaleTimeString()}] ${c.summary}`)
+        }
+      }
+
+      console.log(box(items, { title: "👁️ Monitor Status", color: violet, padding: 2 }))
+      console.log()
+      return
+    }
+
+    case "/monitor-alerts": {
+      console.log()
+      const monitor = new ScreenMonitor()
+      const alerts = monitor.getAlerts()
+
+      if (alerts.length === 0) {
+        console.log(dim("  Нет обнаруженных проблем. Всё чисто! ✅\n"))
+        return
+      }
+
+      console.log(box([
+        violet(`Всего алертов: ${alerts.length}`),
+        "",
+        ...alerts.slice(-15).map(a => {
+          const icon = a.severity === "critical" ? red("🔴") : yellow("🟡")
+          return `${icon} [${new Date(a.timestamp).toLocaleTimeString()}] ${a.type}`
+        }),
+      ], { title: "⚠️ Monitor Alerts", color: yellow, padding: 2 }))
+      console.log()
+      return
+    }
+
+    case "/monitor-screenshot": {
+      console.log()
+      startSpinner("Делаю скриншот")
+      const monitor = new ScreenMonitor()
+
+      const visionFn = async (imageBase64) => {
+        const prompt = `Analyze this screenshot in detail. What's on screen? Any errors, issues, or anomalies? Return JSON with "summary", "text", "issues", "severity".`
+        const model = getModel(state.model)
+        const { text } = await generateText({
+          model,
+          messages: [{
+            role: "user",
+            content: [
+              { type: "text", text: prompt },
+              { type: "image", image: `data:image/png;base64,${imageBase64}` }
+            ]
+          }],
+          maxTokens: 2000,
+        })
+        try { return JSON.parse(text) } catch { return { summary: text.slice(0, 200), text } }
+      }
+
+      const capture = await monitor.captureAndAnalyze(visionFn)
+      stopSpinner()
+
+      if (capture.success) {
+        console.log(box([
+          green("✓ Скриншот сделан!"),
+          "",
+          dim("Файл:   ") + cyan(capture.capture.path),
+          dim("Размер: ") + white(`${capture.capture.sizeKB}KB`),
+          "",
+          violet("Анализ:"),
+          white(capture.capture.analysis?.summary || "analyzing..."),
+          capture.capture.analysis?.text ? dim(capture.capture.analysis.text.slice(0, 500)) : "",
+          "",
+          capture.capture.alerts?.length > 0
+            ? yellow(`⚠️ Обнаружено проблем: ${capture.capture.alerts.length}`)
+            : green("✅ Проблем не обнаружено"),
+        ], { title: "📸 Screenshot Analysis", color: cyan, padding: 2 }))
+      } else {
+        console.log(red(`  ✗ ${capture.error}\n`))
+      }
+      console.log()
+      return
+    }
+
     default:
       console.log(dim(`\n  Неизвестная команда: ${cmd}. Смотри /help\n`))
   }

package/stella-cli/screen-monitor.mjs

@@ -0,0 +1,334 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync, statSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+import { execSync } from "child_process"
+
+const STELLA_DIR = join(homedir(), ".stella")
+const MONITOR_DIR = join(STELLA_DIR, "monitor")
+const HISTORY_FILE = join(MONITOR_DIR, "history.json")
+const ALERTS_FILE = join(MONITOR_DIR, "alerts.json")
+const SCREENSHOTS_DIR = join(MONITOR_DIR, "screenshots")
+const MONITOR_STATE = join(MONITOR_DIR, "state.json")
+
+function ensureDir() {
+  if (!existsSync(MONITOR_DIR)) mkdirSync(MONITOR_DIR, { recursive: true })
+  if (!existsSync(SCREENSHOTS_DIR)) mkdirSync(SCREENSHOTS_DIR, { recursive: true })
+}
+
+function loadJSON(file, fallback) {
+  try { return JSON.parse(readFileSync(file, "utf-8")) } catch { return fallback }
+}
+
+function saveJSON(file, data) {
+  ensureDir()
+  writeFileSync(file, JSON.stringify(data, null, 2))
+}
+
+function captureScreenSync() {
+  const ts = Date.now()
+  const outPath = join(SCREENSHOTS_DIR, `screen_${ts}.png`)
+  const tempPath = join(SCREENSHOTS_DIR, `_temp.png`)
+  const psScriptPath = join(SCREENSHOTS_DIR, `_capture.ps1`)
+
+  // Write PowerShell script to file (avoids escaping issues)
+  const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+try {
+  $bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+  $bitmap = New-Object System.Drawing.Bitmap($bounds.Width, $bounds.Height)
+  $graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+  $graphics.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size)
+  $bitmap.Save("${tempPath.replace(/\\/g, "\\\\")}")
+  $graphics.Dispose()
+  $bitmap.Dispose()
+  Write-Output "OK"
+} catch {
+  Write-Output "FAIL:$($_.Exception.Message)"
+}
+`.trim()
+
+  try {
+    writeFileSync(psScriptPath, psScript, "utf-8")
+    const result = execSync(`powershell -NoProfile -ExecutionPolicy Bypass -File "${psScriptPath}"`, {
+      encoding: "utf-8",
+      timeout: 10000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim()
+
+    if (result.startsWith("OK") && existsSync(tempPath)) {
+      const data = readFileSync(tempPath)
+      writeFileSync(outPath, data)
+      try { unlinkSync(tempPath) } catch {}
+      try { unlinkSync(psScriptPath) } catch {}
+      return outPath
+    }
+    try { unlinkSync(psScriptPath) } catch {}
+    return null
+  } catch {
+    return null
+  }
+}
+
+function compressImage(imagePath, maxWidth = 800) {
+  const compressedPath = imagePath.replace(".png", "_small.png")
+  const psScriptPath = join(SCREENSHOTS_DIR, `_compress.ps1`)
+
+  const psScript = `
+Add-Type -AssemblyName System.Drawing
+try {
+  $img = [System.Drawing.Image]::FromFile("${imagePath.replace(/\\/g, "\\\\")}")
+  $ratio = ${maxWidth} / $img.Width
+  if ($ratio -ge 1) { $ratio = 1 }
+  $newW = [int]($img.Width * $ratio)
+  $newH = [int]($img.Height * $ratio)
+  $bmp = New-Object System.Drawing.Bitmap($newW, $newH)
+  $g = [System.Drawing.Graphics]::FromImage($bmp)
+  $g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic
+  $g.DrawImage($img, 0, 0, $newW, $newH)
+  $bmp.Save("${compressedPath.replace(/\\/g, "\\\\")}")
+  $g.Dispose()
+  $bmp.Dispose()
+  $img.Dispose()
+  Write-Output "OK"
+} catch {
+  Write-Output "FAIL"
+}
+`.trim()
+
+  try {
+    writeFileSync(psScriptPath, psScript, "utf-8")
+    execSync(`powershell -NoProfile -ExecutionPolicy Bypass -File "${psScriptPath}"`, {
+      encoding: "utf-8",
+      timeout: 10000,
+      stdio: ["pipe", "pipe", "pipe"],
+    })
+    try { unlinkSync(psScriptPath) } catch {}
+    if (existsSync(compressedPath)) {
+      return compressedPath
+    }
+  } catch {}
+  return imagePath
+}
+
+export class ScreenMonitor {
+  constructor() {
+    ensureDir()
+    this.state = loadJSON(MONITOR_STATE, {
+      running: false,
+      interval: 2000,
+      startedAt: null,
+      totalCaptures: 0,
+      totalAlerts: 0,
+      pid: null,
+    })
+    this.history = loadJSON(HISTORY_FILE, [])
+    this.alerts = loadJSON(ALERTS_FILE, [])
+    this.intervalId = null
+  }
+
+  save() {
+    saveJSON(MONITOR_STATE, this.state)
+    saveJSON(HISTORY_FILE, this.history.slice(-500))
+    saveJSON(ALERTS_FILE, this.alerts.slice(-200))
+  }
+
+  async captureAndAnalyze(visionFn) {
+    const imagePath = captureScreenSync()
+    if (!imagePath) {
+      return { success: false, error: "Failed to capture screen" }
+    }
+
+    const stats = statSync(imagePath)
+    const sizeKB = Math.round(stats.size / 1024)
+
+    // Compress for AI analysis
+    const compressedPath = compressImage(imagePath, 600)
+    let imageBase64
+    try {
+      imageBase64 = readFileSync(compressedPath).toString("base64")
+    } catch {
+      imageBase64 = readFileSync(imagePath).toString("base64")
+    }
+
+    const ts = new Date().toISOString()
+    const capture = {
+      id: Date.now().toString(36),
+      timestamp: ts,
+      path: imagePath,
+      sizeKB,
+      analysis: null,
+      alerts: [],
+    }
+
+    // Analyze with vision AI
+    if (visionFn) {
+      try {
+        const analysis = await visionFn(imageBase64, this.getRecentContext())
+        capture.analysis = analysis
+
+        // Detect alerts
+        const alertKeywords = [
+          "error", "crash", "exception", "fatal", "alert", "warning", "failed",
+          "ошибка", "краш", "исключение", "фатальная", "предупреждение", "сбой",
+          "not responding", "has stopped", "dead", "kill", "terminate",
+          "не отвечает", "остановлен", "завершить",
+        ]
+
+        const textLower = (analysis.text || "").toLowerCase()
+        const detected = alertKeywords.filter(k => textLower.includes(k))
+
+        if (detected.length > 0) {
+          const alert = {
+            id: capture.id,
+            timestamp: ts,
+            type: detected.join(", "),
+            severity: detected.some(k => ["fatal", "crash", "exception", "фатальная", "краш", "исключение"].includes(k)) ? "critical" : "warning",
+            description: analysis.text?.slice(0, 500),
+            screenshot: imagePath,
+          }
+          capture.alerts.push(alert)
+          this.alerts.push(alert)
+          this.state.totalAlerts++
+        }
+      } catch (err) {
+        capture.analysis = { error: err.message }
+      }
+    }
+
+    this.history.push(capture)
+    this.state.totalCaptures++
+    this.save()
+
+    // Clean old screenshots (keep last 50)
+    this.cleanOldScreenshots(50)
+
+    return { success: true, capture }
+  }
+
+  getRecentContext() {
+    const recent = this.history.slice(-5)
+    return recent.map(h => ({
+      time: h.timestamp,
+      analysis: h.analysis?.summary || h.analysis?.text?.slice(0, 200) || "no analysis",
+      alerts: h.alerts?.length || 0,
+    }))
+  }
+
+  cleanOldScreenshots(keep = 50) {
+    try {
+      const files = readdirSync(SCREENSHOTS_DIR)
+        .filter(f => f.startsWith("screen_") && f.endsWith(".png"))
+        .sort()
+      
+      if (files.length > keep) {
+        const toDelete = files.slice(0, files.length - keep)
+        for (const f of toDelete) {
+          try { unlinkSync(join(SCREENSHOTS_DIR, f)) } catch {}
+        }
+      }
+    } catch {}
+  }
+
+  start(intervalMs, visionFn) {
+    if (this.state.running) {
+      return { success: false, error: "Monitor already running" }
+    }
+
+    this.state.running = true
+    this.state.startedAt = new Date().toISOString()
+    this.state.interval = intervalMs || 2000
+    this.state.pid = process.pid
+    this.save()
+
+    this.intervalId = setInterval(async () => {
+      if (!this.state.running) {
+        this.stop()
+        return
+      }
+      await this.captureAndAnalyze(visionFn)
+    }, this.state.interval)
+
+    return { success: true, interval: this.state.interval }
+  }
+
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId)
+      this.intervalId = null
+    }
+    this.state.running = false
+    this.state.pid = null
+    this.save()
+    return { success: true }
+  }
+
+  getStatus() {
+    const recentAlerts = this.alerts.slice(-10)
+    const recentCaptures = this.history.slice(-5)
+
+    return {
+      running: this.state.running,
+      startedAt: this.state.startedAt,
+      interval: this.state.interval,
+      totalCaptures: this.state.totalCaptures,
+      totalAlerts: this.state.totalAlerts,
+      pid: this.state.pid,
+      recentAlerts,
+      recentCaptures: recentCaptures.map(c => ({
+        time: c.timestamp,
+        size: c.sizeKB + "KB",
+        summary: c.analysis?.summary || c.analysis?.text?.slice(0, 100) || "analyzing...",
+        alertCount: c.alerts?.length || 0,
+      })),
+    }
+  }
+
+  getAlerts(since) {
+    if (since) {
+      return this.alerts.filter(a => new Date(a.timestamp) > new Date(since))
+    }
+    return this.alerts
+  }
+
+  getScreenshotPath() {
+    const files = readdirSync(SCREENSHOTS_DIR)
+      .filter(f => f.startsWith("screen_") && f.endsWith(".png"))
+      .sort()
+    return files.length > 0 ? join(SCREENSHOTS_DIR, files[files.length - 1]) : null
+  }
+
+  generateReport() {
+    const status = this.getStatus()
+    const alertsByType = {}
+    for (const a of this.alerts) {
+      alertsByType[a.type] = (alertsByType[a.type] || 0) + 1
+    }
+
+    const report = `
+═══════════════════════════════════════════
+  👁️  SCREEN MONITOR REPORT
+═══════════════════════════════════════════
+
+Status:       ${status.running ? "🟢 RUNNING" : "🔴 STOPPED"}
+Started:      ${status.startedAt ? new Date(status.startedAt).toLocaleString() : "Never"}
+Interval:     every ${status.interval / 1000}s
+Total captures: ${status.totalCaptures}
+Total alerts:   ${status.totalAlerts}
+
+${Object.keys(alertsByType).length > 0 ? `
+Alert breakdown:
+${Object.entries(alertsByType).map(([type, count]) => `  ⚠️  ${type}: ${count}`).join("\n")}
+` : "No alerts detected."}
+
+Recent captures:
+${status.recentCaptures.map(c => `  [${new Date(c.time).toLocaleTimeString()}] ${c.summary} ${c.alertCount > 0 ? `⚠️ ${c.alertCount} alerts` : "✅"}`).join("\n")}
+
+═══════════════════════════════════════════
+`.trim()
+
+    return report
+  }
+}
+
+export default ScreenMonitor