stella-coder 3.9.0

package/stella-cli/markdown.mjs

@@ -0,0 +1,100 @@
+import { bold, dim, italic, violet, blue, cyan, purple, gray, bgRgb, rgb } from "./theme.mjs"
+
+const codeBg = bgRgb(30, 27, 55)
+const codeFg = rgb(196, 181, 253)
+
+// Inline markdown: **bold**, *italic*, `code`, [link](url)
+export function renderInline(text) {
+  let out = text
+  out = out.replace(/\*\*([^*]+)\*\*/g, (_, s) => bold(violet(s)))
+  out = out.replace(/(^|[^*])\*([^*\n]+)\*/g, (_, p, s) => p + italic(s))
+  out = out.replace(/`([^`]+)`/g, (_, s) => codeBg(codeFg(` ${s} `)))
+  out = out.replace(/\[([^\]]+)\][(]([^)]+)[)]/g, (_, label, url) => blue(label) + dim(` (${url})`))
+  return out
+}
+
+// Block markdown renderer for a complete markdown string
+export function renderMarkdown(md) {
+  const lines = md.split("\n")
+  const out = []
+  let inCode = false
+  let codeLang = ""
+  let codeBuf = []
+
+  for (const line of lines) {
+    const fence = line.match(/^\s*```(\w*)/)
+    if (fence) {
+      if (!inCode) {
+        inCode = true
+        codeLang = fence[1] || ""
+        codeBuf = []
+      } else {
+        inCode = false
+        const width = Math.max(...codeBuf.map((l) => l.length), codeLang.length + 2, 20)
+        out.push(purple("  ╭─") + dim(codeLang ? ` ${codeLang} ` : "") + purple("─".repeat(Math.max(width - codeLang.length, 2)) + "╮"))
+        for (const cl of codeBuf) {
+          out.push(purple("  │ ") + codeFg(cl) + " ".repeat(width - cl.length + 1) + purple("│"))
+        }
+        out.push(purple("  ╰" + "─".repeat(width + 3) + "╯"))
+      }
+      continue
+    }
+    if (inCode) {
+      codeBuf.push(line)
+      continue
+    }
+    const h = line.match(/^(#{1,4})\s+(.*)/)
+    if (h) {
+      out.push("")
+      out.push(bold(violet(h[2])))
+      continue
+    }
+    const li = line.match(/^(\s*)[-*]\s+(.*)/)
+    if (li) {
+      out.push(li[1] + violet("•") + " " + renderInline(li[2]))
+      continue
+    }
+    const ol = line.match(/^(\s*)(\d+)\.\s+(.*)/)
+    if (ol) {
+      out.push(ol[1] + blue(ol[2] + ".") + " " + renderInline(ol[3]))
+      continue
+    }
+    const bq = line.match(/^\s*>\s?(.*)/)
+    if (bq) {
+      out.push(purple("  ▎") + dim(renderInline(bq[1])))
+      continue
+    }
+    if (/^\s*(---|\*\*\*)\s*$/.test(line)) {
+      out.push(dim("  " + "─".repeat(40)))
+      continue
+    }
+    out.push(renderInline(line))
+  }
+  if (inCode && codeBuf.length) {
+    for (const cl of codeBuf) out.push(codeFg("  " + cl))
+  }
+  return out.join("\n")
+}
+
+// Streaming renderer: buffers text and flushes rendered lines as they complete
+export function createStreamRenderer(write) {
+  let buf = ""
+  return {
+    push(delta) {
+      buf += delta
+      const idx = buf.lastIndexOf("\n")
+      if (idx === -1) return
+      // Don't flush while inside an unclosed code fence
+      const flushable = buf.slice(0, idx + 1)
+      const fences = (flushable.match(/```/g) || []).length
+      if (fences % 2 !== 0) return
+      write(renderMarkdown(flushable.replace(/\n$/, "")) + "\n")
+      buf = buf.slice(idx + 1)
+    },
+    flush() {
+      if (buf.trim()) write(renderMarkdown(buf) + "\n")
+      else if (buf) write(buf)
+      buf = ""
+    },
+  }
+}

package/stella-cli/sea-config.json

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

package/stella-cli/security.mjs

@@ -0,0 +1,237 @@
+import crypto from "node:crypto"
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+import { execSync } from "node:child_process"
+import { fileURLToPath } from "node:url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const STELLA_HIDDEN = path.join(os.homedir(), ".stella", ".secure")
+const KEY_FILE = path.join(STELLA_HIDDEN, "vault.dat")
+const FINGERPRINT_FILE = path.join(STELLA_HIDDEN, ".fp")
+const INTEGRITY_FILE = path.join(STELLA_HIDDEN, ".integrity")
+const LOCKOUT_FILE = path.join(STELLA_HIDDEN, ".lockout")
+
+const CLI_FILES = [
+  "stella-cli/index.mjs",
+  "stella-cli/tools.mjs",
+  "stella-cli/banner.mjs",
+  "stella-cli/theme.mjs",
+  "stella-cli/markdown.mjs",
+  "stella-cli/security.mjs",
+]
+
+function ensureDir() {
+  fs.mkdirSync(STELLA_HIDDEN, { recursive: true })
+  try {
+    if (process.platform === "win32") {
+      execSync(`attrib +h "${STELLA_HIDDEN}"`, { stdio: "ignore" })
+    }
+  } catch {}
+}
+
+const PBKDF2_ITERATIONS = 100000
+const SALT = "stella-vault-v3-2026"
+
+function deriveKey(password) {
+  return crypto.pbkdf2Sync(password, SALT, PBKDF2_ITERATIONS, 32, "sha512")
+}
+
+function aesEncrypt(plaintext, password) {
+  const key = deriveKey(password)
+  const iv = crypto.randomBytes(12)
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv)
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()])
+  const authTag = cipher.getAuthTag()
+  const payload = Buffer.concat([iv, authTag, encrypted])
+  return payload.toString("base64")
+}
+
+function aesDecrypt(encryptedBase64, password) {
+  const key = deriveKey(password)
+  const payload = Buffer.from(encryptedBase64, "base64")
+  if (payload.length < 28) return null
+  const iv = payload.subarray(0, 12)
+  const authTag = payload.subarray(12, 28)
+  const encrypted = payload.subarray(28)
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv)
+  decipher.setAuthTag(authTag)
+  const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()])
+  return decrypted.toString("utf8")
+}
+
+function xorEncrypt(data, key) {
+  return aesEncrypt(data, key)
+}
+
+function xorDecrypt(encrypted, key) {
+  try { return aesDecrypt(encrypted, key) } catch { return null }
+}
+
+function getHardwareFingerprint() {
+  const parts = []
+  try {
+    if (process.platform === "win32") {
+      const cpuId = execSync(
+        'wmic cpu get ProcessorId /value 2>nul | findstr ProcessorId',
+        { encoding: "utf8", timeout: 5000 }
+      ).trim()
+      parts.push(cpuId)
+
+      const mbSerial = execSync(
+        'wmic baseboard get SerialNumber /value 2>nul | findstr SerialNumber',
+        { encoding: "utf8", timeout: 5000 }
+      ).trim()
+      parts.push(mbSerial)
+
+      const biosSerial = execSync(
+        'wmic bios get SerialNumber /value 2>nul | findstr SerialNumber',
+        { encoding: "utf8", timeout: 5000 }
+      ).trim()
+      parts.push(biosSerial)
+
+      const diskSerial = execSync(
+        'wmic diskdrive get SerialNumber /value 2>nul | findstr SerialNumber',
+        { encoding: "utf8", timeout: 5000 }
+      ).trim()
+      parts.push(diskSerial)
+    } else if (process.platform === "darwin") {
+      const ioPlatformUuid = execSync(
+        "ioreg -rd1 -c IOPlatformExpertDevice | awk '/IOPlatformUUID/ { print $3 }'",
+        { encoding: "utf8", timeout: 5000 }
+      ).trim()
+      parts.push(ioPlatformUuid)
+    } else {
+      const mid = execSync("cat /var/lib/dbus/machine-id 2>/dev/null || cat /etc/machine-id 2>/dev/null", {
+        encoding: "utf8",
+        timeout: 5000,
+      }).trim()
+      parts.push(mid)
+    }
+
+    const nets = os.networkInterfaces()
+    for (const name of Object.keys(nets)) {
+      for (const net of nets[name]) {
+        if (net.mac && net.mac !== "00:00:00:00:00:00") {
+          parts.push(net.mac)
+        }
+      }
+    }
+  } catch {}
+
+  if (parts.length === 0) {
+    parts.push(os.hostname())
+    parts.push(os.cpus()[0]?.model || "unknown")
+    parts.push(os.totalmem().toString())
+  }
+
+  return crypto.createHash("sha512").update(parts.join(":::")).digest("hex")
+}
+
+function getEncryptionKey() {
+  return crypto.createHash("sha256").update("stella-vault-portable-2026").digest("hex")
+}
+
+function computeCodeHash() {
+  const projectRoot = path.resolve(__dirname, "..")
+  let combined = ""
+  for (const file of CLI_FILES) {
+    const full = path.join(projectRoot, file)
+    try {
+      combined += fs.readFileSync(full, "utf8")
+    } catch {}
+  }
+  return crypto.createHash("sha256").update(combined).digest("hex")
+}
+
+export function verifyCodeIntegrity() {
+  ensureDir()
+  const currentHash = computeCodeHash()
+
+  if (fs.existsSync(INTEGRITY_FILE)) {
+    const saved = fs.readFileSync(INTEGRITY_FILE, "utf8").trim()
+    if (saved !== currentHash) {
+      return { ok: true, warning: "Код был изменён (ожидается при разработке)" }
+    }
+  } else {
+    fs.writeFileSync(INTEGRITY_FILE, currentHash, "utf8")
+  }
+
+  return { ok: true }
+}
+
+export function saveIntegrityHash() {
+  ensureDir()
+  fs.writeFileSync(INTEGRITY_FILE, computeCodeHash(), "utf8")
+}
+
+export function getApiKey() {
+  ensureDir()
+
+  if (!fs.existsSync(KEY_FILE)) return null
+
+  try {
+    const encrypted = fs.readFileSync(KEY_FILE, "utf8").trim()
+    const encKey = getEncryptionKey()
+    const apiKey = xorDecrypt(encrypted, encKey)
+
+    if (!apiKey || apiKey.length < 10) return null
+
+    return { apiKey }
+  } catch {
+    return null
+  }
+}
+
+export function saveApiKey(apiKey) {
+  ensureDir()
+
+  if (!apiKey || typeof apiKey !== "string" || apiKey.length < 10) {
+    return { ok: false, error: "Неверный формат API ключа" }
+  }
+
+  const encKey = getEncryptionKey()
+  const encrypted = xorEncrypt(apiKey, encKey)
+  fs.writeFileSync(KEY_FILE, encrypted, "utf8")
+
+  saveIntegrityHash()
+
+  try {
+    if (process.platform === "win32") {
+      execSync(`attrib +h +s "${KEY_FILE}"`, { stdio: "ignore" })
+      execSync(`attrib +h +s "${INTEGRITY_FILE}"`, { stdio: "ignore" })
+    }
+  } catch {}
+
+  return { ok: true }
+}
+
+export function deleteApiKey() {
+  ensureDir()
+  try {
+    if (fs.existsSync(KEY_FILE)) fs.unlinkSync(KEY_FILE)
+    if (fs.existsSync(FINGERPRINT_FILE)) fs.unlinkSync(FINGERPRINT_FILE)
+    if (fs.existsSync(INTEGRITY_FILE)) fs.unlinkSync(INTEGRITY_FILE)
+    return { ok: true }
+  } catch (e) {
+    return { ok: false, error: e.message }
+  }
+}
+
+export function isKeyBoundToThisMachine() {
+  const result = getApiKey()
+  if (!result || result.error) return false
+  return true
+}
+
+export function getHardwareInfo() {
+  const fp = getHardwareFingerprint()
+  return {
+    fingerprint: fp.substring(0, 16) + "...",
+    platform: process.platform,
+    hostname: os.hostname(),
+    cpu: os.cpus()[0]?.model || "unknown",
+  }
+}

package/stella-cli/theme.mjs

@@ -0,0 +1,89 @@
+// Stella Coder 3.9 — purple/blue ANSI theme
+const ESC = "\x1b["
+
+export const reset = `${ESC}0m`
+export const bold = (s) => `${ESC}1m${s}${reset}`
+export const dim = (s) => `${ESC}2m${s}${reset}`
+export const italic = (s) => `${ESC}3m${s}${reset}`
+export const underline = (s) => `${ESC}4m${s}${reset}`
+export const inverse = (s) => `${ESC}7m${s}${reset}`
+export const strikethrough = (s) => `${ESC}9m${s}${reset}`
+
+export const rgb = (r, g, b) => (s) => `${ESC}38;2;${r};${g};${b}m${s}${reset}`
+export const bgRgb = (r, g, b) => (s) => `${ESC}48;2;${r};${g};${b}m${s}${reset}`
+
+// Palette: violet -> blue
+export const violet = rgb(167, 139, 250) // #a78bfa
+export const purple = rgb(139, 92, 246) // #8b5cf6
+export const indigo = rgb(129, 140, 248) // #818cf8
+export const blue = rgb(96, 165, 250) // #60a5fa
+export const cyan = rgb(103, 232, 249) // #67e8f9
+export const green = rgb(74, 222, 128)
+export const red = rgb(248, 113, 113)
+export const yellow = rgb(250, 204, 21)
+export const gray = rgb(148, 163, 184)
+export const darkGray = rgb(100, 116, 139)
+export const white = rgb(237, 233, 254)
+
+// Gradient stops from violet to blue
+const STOPS = [
+  [167, 139, 250],
+  [139, 92, 246],
+  [129, 140, 248],
+  [99, 102, 241],
+  [96, 165, 250],
+]
+
+function lerp(a, b, t) {
+  return Math.round(a + (b - a) * t)
+}
+
+export function gradientLine(text) {
+  const chars = [...text]
+  const n = Math.max(chars.length - 1, 1)
+  let out = ""
+  for (let i = 0; i < chars.length; i++) {
+    const t = (i / n) * (STOPS.length - 1)
+    const idx = Math.min(Math.floor(t), STOPS.length - 2)
+    const f = t - idx
+    const [r1, g1, b1] = STOPS[idx]
+    const [r2, g2, b2] = STOPS[idx + 1]
+    out += `${ESC}38;2;${lerp(r1, r2, f)};${lerp(g1, g2, f)};${lerp(b1, b2, f)}m${chars[i]}`
+  }
+  return out + reset
+}
+
+export function gradient(text) {
+  return text
+    .split("\n")
+    .map((l) => gradientLine(l))
+    .join("\n")
+}
+
+// Rounded box drawing
+export function box(lines, { color = purple, padding = 1, title = "" } = {}) {
+  const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, "")
+  const width = Math.max(...lines.map((l) => strip(l).length), strip(title).length + 2)
+  const pad = " ".repeat(padding)
+  const inner = width + padding * 2
+  const top = title
+    ? color("╭─ ") + bold(violet(title)) + color(" " + "─".repeat(Math.max(inner - strip(title).length - 3, 0)) + "╮")
+    : color("╭" + "─".repeat(inner) + "╮")
+  const body = lines.map((l) => color("│") + pad + l + " ".repeat(width - strip(l).length) + pad + color("│"))
+  const bottom = color("╰" + "─".repeat(inner) + "╯")
+  return [top, ...body, bottom].join("\n")
+}
+
+export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+export const SPINNER_WORDS = [
+  "Thinking",
+  "Pondering",
+  "Vibing",
+  "Computing",
+  "Reasoning",
+  "Conjuring",
+  "Synthesizing",
+  "Brewing",
+  "Crafting",
+  "Weaving",
+]