stella-coder 5.3.0 → 5.3.2

package/releases/stella-coder/protect.mjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+// Stella Coder — Code Protector & Packager
+import fs from "node:fs"
+import path from "node:path"
+import { execSync } from "node:child_process"
+import { fileURLToPath } from "node:url"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const ROOT = path.resolve(__dirname, "..")
+const RELEASES = path.join(ROOT, "releases")
+const STELLA_PKG = path.join(RELEASES, "stella-coder")
+const AV_PKG = path.join(RELEASES, "stella-antivirus")
+
+function cleanDir(dir) {
+  if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true })
+  fs.mkdirSync(dir, { recursive: true })
+}
+
+function copy(src, dst) {
+  if (fs.existsSync(src)) {
+    if (fs.statSync(src).isDirectory()) {
+      if (!fs.existsSync(dst)) fs.mkdirSync(dst, { recursive: true })
+      for (const item of fs.readdirSync(src)) copy(path.join(src, item), path.join(dst, item))
+    } else {
+      fs.cpSync(src, dst)
+    }
+  }
+}
+
+function stripComments(code) {
+  return code
+}
+
+function makeReadable(code) {
+  return code
+}
+
+function addGuard(code) {
+  return code
+}
+
+console.log("\n  ✦ Stella Coder — Protector & Packager\n")
+
+// Create release directories
+cleanDir(STELLA_PKG)
+cleanDir(AV_PKG)
+
+// 1. Package Stella CLI
+console.log("  [1/3] Packaging Stella CLI...")
+const cliFiles = fs.readdirSync(path.join(ROOT, "stella-cli")).filter(f => f.endsWith(".mjs"))
+for (const f of cliFiles) {
+  const src = path.join(ROOT, "stella-cli", f)
+  let code = fs.readFileSync(src, "utf8")
+  code = addGuard(code)
+  code = stripComments(code)
+  fs.writeFileSync(path.join(STELLA_PKG, f), code)
+}
+// Copy package.json and README
+copy(path.join(ROOT, "package.json"), path.join(STELLA_PKG, "package.json"))
+copy(path.join(ROOT, "stella-cli", "sea-config.json"), path.join(STELLA_PKG, "sea-config.json"))
+copy(path.join(ROOT, "README.md"), path.join(STELLA_PKG, "README.md"))
+
+// Create install-stella.bat
+fs.writeFileSync(path.join(STELLA_PKG, "install-stella.bat"), `@echo off
+chcp 65001 >nul
+echo.
+echo  ✦ Stella Coder — Installation
+echo  =============================
+echo.
+echo  Install: npm i -g stella-coder
+echo  Or run:  node stella-cli/index.mjs
+echo.
+echo  Docs:    https://a1x10.github.io/stella/
+echo.
+pause
+`)
+
+// 2. Package Antivirus separately
+console.log("  [2/3] Packaging Stella Antivirus...")
+const avFiles = fs.readdirSync(path.join(ROOT, "antimalware")).filter(f => f.endsWith(".mjs"))
+for (const f of avFiles) {
+  const src = path.join(ROOT, "antimalware", f)
+  let code = fs.readFileSync(src, "utf8")
+  code = addGuard(code)
+  code = stripComments(code)
+  fs.writeFileSync(path.join(AV_PKG, f), code)
+}
+// Copy antimalware/index.mjs as entry point
+copy(path.join(ROOT, "antimalware", "index.mjs"), path.join(AV_PKG, "index.mjs"))
+
+// Create standalone install-antivirus.bat
+fs.writeFileSync(path.join(AV_PKG, "install-av.bat"), `@echo off
+chcp 65001 >nul
+echo.
+echo  ✦ Stella Antivirus — Installation
+echo  =================================
+echo.
+echo  Quick run:  node index.mjs
+echo.
+echo  Scans your system for threats using
+echo  signature-based detection + AI analysis.
+echo.
+pause
+`)
+
+// 3. Create combined installers for root
+console.log("  [3/3] Creating root installers...")
+
+// Stella installer
+fs.writeFileSync(path.join(ROOT, "install-stella-pkg.bat"), `@echo off
+chcp 65001 >nul
+echo.
+echo  ✦ Stella Coder v5.3.1 — AI Coding Agent
+echo  =========================================
+echo.
+echo  [1] npm install -g stella-coder
+call npm install -g stella-coder
+echo.
+echo  [2] Verify installation
+call stella --version
+echo.
+if %errorlevel% equ 0 (
+  echo  ✓ Stella Coder installed!
+  echo.
+  echo  Type "stella" to start
+) else (
+  echo  ✗ Try: node %~dp0stella-cli/index.mjs
+)
+echo.
+pause
+`)
+
+// Antivirus standalone installer
+fs.writeFileSync(path.join(ROOT, "install-av.bat"), `@echo off
+chcp 65001 >nul
+echo.
+echo  ✦ Stella Antivirus — Standalone Scanner
+echo  =========================================
+echo.
+echo  Quick start:
+echo    node "%CD%\\antimalware\\index.mjs"
+echo.
+echo  Or add to PATH:
+echo    set PATH=%%PATH%%;"%CD%\\antimalware"
+echo    stella-antivirus
+echo.
+echo  Scans:  files, processes, registry, startup
+echo  Method: signature database + AI heuristic
+echo.
+pause
+`)
+
+// Create shortcuts
+fs.writeFileSync(path.join(ROOT, "run-antivirus.bat"), `@echo off
+chcp 65001 >nul
+node "%~dp0antimalware\\index.mjs"
+pause
+`)
+
+console.log(fs.existsSync(path.join(AV_PKG, "index.mjs")) ? "  ✓" : "  ✗")
+console.log()
+
+// Create archive versions for GitHub release
+console.log("  Creating archives for GitHub Release...")
+const zipDir = path.join(ROOT, "releases")
+if (!fs.existsSync(zipDir)) fs.mkdirSync(zipDir, { recursive: true })
+
+// ZIP Stella
+try {
+  execSync(`powershell -Command "Compress-Archive -Path '${STELLA_PKG}\\*' -DestinationPath '${path.join(zipDir, 'stella-coder.zip')}' -Force"`, { timeout: 15000 })
+  console.log("    ✓ stella-coder.zip")
+} catch { console.log("    ✗ stella-coder.zip (use 7zip or manual)") }
+
+// ZIP Antivirus
+try {
+  execSync(`powershell -Command "Compress-Archive -Path '${AV_PKG}\\*' -DestinationPath '${path.join(zipDir, 'stella-antivirus.zip')}' -Force"`, { timeout: 15000 })
+  console.log("    ✓ stella-antivirus.zip")
+} catch { console.log("    ✗ stella-antivirus.zip") }
+
+console.log()
+console.log("  ✓ Done! Packages in releases/")
+console.log()

package/releases/stella-coder/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/releases/stella-coder/sea-config.json

@@ -0,0 +1,5 @@
+{
+  "main": "index.mjs",
+  "output": "sea-prep.blob",
+  "disableExperimentalSEAWarning": true
+}