stella-coder 5.1.2 → 5.2.1

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

package/stella-cli/web-parser.mjs

@@ -0,0 +1,229 @@
+import http from "http"
+import https from "https"
+import { JSDOM } from "jsdom"
+
+function fetchUrl(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const mod = url.startsWith("https") ? https : http
+    const headers = {
+      "User-Agent": "StellaBot/5.2 (compatible; like Googlebot)",
+      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "Accept-Language": "en-US,en;q=0.5",
+      ...options.headers,
+    }
+
+    const req = mod.get(url, { headers, timeout: 15000 }, (res) => {
+      // Follow redirects
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        const redirectUrl = new URL(res.headers.location, url).href
+        return fetchUrl(redirectUrl, options).then(resolve).catch(reject)
+      }
+
+      let data = ""
+      res.on("data", (chunk) => data += chunk)
+      res.on("end", () => resolve({
+        status: res.statusCode,
+        headers: res.headers,
+        html: data,
+        url,
+      }))
+    })
+    req.on("error", reject)
+    req.on("timeout", () => { req.destroy(); reject(new Error("Timeout")) })
+  })
+}
+
+export class WebParser {
+  constructor() {
+    this.cache = new Map()
+  }
+
+  async fetchPage(url) {
+    if (this.cache.has(url)) {
+      return this.cache.get(url)
+    }
+
+    const result = await fetchUrl(url)
+    const dom = new JSDOM(result.html)
+    const doc = dom.window.document
+
+    const parsed = {
+      url,
+      status: result.status,
+      title: doc.querySelector("title")?.textContent?.trim() || "",
+      meta: {
+        description: doc.querySelector('meta[name="description"]')?.content || "",
+        keywords: doc.querySelector('meta[name="keywords"]')?.content || "",
+        ogTitle: doc.querySelector('meta[property="og:title"]')?.content || "",
+        ogDescription: doc.querySelector('meta[property="og:description"]')?.content || "",
+        ogImage: doc.querySelector('meta[property="og:image"]')?.content || "",
+        canonical: doc.querySelector('link[rel="canonical"]')?.href || "",
+      },
+      headings: Array.from(doc.querySelectorAll("h1,h2,h3,h4")).map(h => ({
+        level: parseInt(h.tagName[1]),
+        text: h.textContent.trim(),
+      })),
+      links: Array.from(doc.querySelectorAll("a[href]")).map(a => ({
+        text: a.textContent.trim().slice(0, 100),
+        href: a.href,
+      })).filter(l => l.text).slice(0, 100),
+      images: Array.from(doc.querySelectorAll("img[src]")).map(img => ({
+        src: img.src,
+        alt: img.alt || "",
+      })).slice(0, 50),
+      text: doc.body?.innerText?.trim()?.slice(0, 50000) || "",
+      html: result.html,
+      linksCount: doc.querySelectorAll("a[href]").length,
+      imagesCount: doc.querySelectorAll("img[src]").length,
+      formsCount: doc.querySelectorAll("form").length,
+      scriptsCount: doc.querySelectorAll("script").length,
+    }
+
+    this.cache.set(url, parsed)
+    return parsed
+  }
+
+  async extractText(url) {
+    const page = await this.fetchPage(url)
+    return { success: true, title: page.title, text: page.text }
+  }
+
+  async extractLinks(url) {
+    const page = await this.fetchPage(url)
+    return { success: true, links: page.links }
+  }
+
+  async extractImages(url) {
+    const page = await this.fetchPage(url)
+    return { success: true, images: page.images }
+  }
+
+  async extractForms(url) {
+    const page = await this.fetchPage(url)
+    const dom = new JSDOM(page.html)
+    const doc = dom.window.document
+
+    const forms = Array.from(doc.querySelectorAll("form")).map(f => ({
+      action: f.action,
+      method: f.method?.toUpperCase() || "GET",
+      fields: Array.from(f.querySelectorAll("input,textarea,select,button")).map(el => ({
+        tag: el.tagName.toLowerCase(),
+        type: el.type || "",
+        name: el.name || "",
+        placeholder: el.placeholder || "",
+        value: el.value || "",
+        required: el.required,
+        options: el.tagName === "SELECT"
+          ? Array.from(el.querySelectorAll("option")).map(o => ({ value: o.value, text: o.textContent.trim() }))
+          : undefined,
+      })),
+    }))
+
+    return { success: true, forms }
+  }
+
+  async search(query, engine = "duckduckgo") {
+    if (engine === "duckduckgo") {
+      const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`
+      const page = await this.fetchPage(url)
+      const dom = new JSDOM(page.html)
+      const doc = dom.window.document
+
+      const results = Array.from(doc.querySelectorAll(".result")).map(r => ({
+        title: r.querySelector(".result__title")?.textContent?.trim() || "",
+        url: r.querySelector(".result__url")?.textContent?.trim() || "",
+        snippet: r.querySelector(".result__snippet")?.textContent?.trim() || "",
+      })).slice(0, 10)
+
+      return { success: true, results }
+    }
+
+    if (engine === "google") {
+      const url = `https://www.google.com/search?q=${encodeURIComponent(query)}`
+      const page = await this.fetchPage(url)
+      const dom = new JSDOM(page.html)
+      const doc = dom.window.document
+
+      const results = Array.from(doc.querySelectorAll("div.g,div[data-sokoban-container]")).map(r => ({
+        title: r.querySelector("h3")?.textContent?.trim() || "",
+        url: r.querySelector("a")?.href || "",
+        snippet: r.querySelector(".VwiC3b,.st")?.textContent?.trim() || "",
+      })).filter(r => r.title).slice(0, 10)
+
+      return { success: true, results }
+    }
+
+    return { success: false, error: `Unknown engine: ${engine}` }
+  }
+
+  async getSEO(url) {
+    const page = await this.fetchPage(url)
+    const dom = new JSDOM(page.html)
+    const doc = dom.window.document
+
+    const seo = {
+      title: page.title,
+      titleLength: page.title.length,
+      metaDescription: page.meta.description,
+      metaDescLength: page.meta.description.length,
+      h1Count: doc.querySelectorAll("h1").length,
+      hasCanonical: !!page.meta.canonical,
+      hasOgTitle: !!page.meta.ogTitle,
+      hasOgDescription: !!page.meta.ogDescription,
+      hasOgImage: !!page.meta.ogImage,
+      imageAlts: Array.from(doc.querySelectorAll("img")).filter(img => !img.alt).length === 0,
+      linksInternal: page.links.filter(l => new URL(l.href, url).hostname === new URL(url).hostname).length,
+      linksExternal: page.links.filter(l => new URL(l.href, url).hostname !== new URL(url).hostname).length,
+      score: 0,
+      issues: [],
+    }
+
+    // Score
+    if (seo.titleLength >= 30 && seo.titleLength <= 60) seo.score += 20
+    else seo.issues.push(`Title length ${seo.titleLength} (optimal: 30-60)`)
+
+    if (seo.metaDescLength >= 120 && seo.metaDescLength <= 160) seo.score += 20
+    else seo.issues.push(`Meta description length ${seo.metaDescLength} (optimal: 120-160)`)
+
+    if (seo.h1Count === 1) seo.score += 15
+    else seo.issues.push(`H1 count: ${seo.h1Count} (should be 1)`)
+
+    if (seo.hasCanonical) seo.score += 10
+    else seo.issues.push("Missing canonical tag")
+
+    if (seo.hasOgTitle) seo.score += 10
+    else seo.issues.push("Missing og:title")
+
+    if (seo.hasOgDescription) seo.score += 10
+    else seo.issues.push("Missing og:description")
+
+    if (seo.hasOgImage) seo.score += 5
+    else seo.issues.push("Missing og:image")
+
+    if (seo.imageAlts) seo.score += 10
+    else seo.issues.push("Images without alt text")
+
+    return { success: true, seo }
+  }
+
+  async batchFetch(urls) {
+    const results = await Promise.allSettled(
+      urls.map(url => this.fetchPage(url).then(p => ({
+        url,
+        title: p.title,
+        status: p.status,
+        textLength: p.text.length,
+      })))
+    )
+
+    return {
+      success: true,
+      results: results.map((r, i) => ({
+        url: urls[i],
+        ...(r.status === "fulfilled" ? r.value : { error: r.reason?.message }),
+      })),
+    }
+  }
+}
+
+export default WebParser