stella-coder 5.3.4 → 5.3.5

package/Desktop/main.ts

@@ -0,0 +1,254 @@
+import { app, BrowserWindow, dialog, ipcMain } from "electron";
+import { execFile, spawn, type ChildProcess } from "node:child_process";
+import { promisify } from "node:util";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { pathToFileURL } from "node:url";
+import type {
+  AgentOutputEvent,
+  AgentStatusEvent,
+  DesktopSettings,
+  ProjectInfo,
+  SystemMetrics,
+  TaskRecord,
+} from "./shared/contracts";
+
+const execFileAsync = promisify(execFile);
+const DEFAULT_SETTINGS: DesktopSettings = { model: "mimo-v2.5-free", recentWorkspaces: [] };
+const MAX_HISTORY = 20;
+const MAX_OUTPUT_LENGTH = 12000;
+let mainWindow: BrowserWindow | null = null;
+let activeProcess: ChildProcess | null = null;
+let activeTask: TaskRecord | null = null;
+let cpuSample: Array<{ idle: number; total: number }> | null = null;
+
+function desktopDataPath(file: string) {
+  return path.join(app.getPath("userData"), file);
+}
+
+function sourceRoot() {
+  return app.isPackaged ? path.join(process.resourcesPath, "app.asar.unpacked") : path.resolve(__dirname, "../../..");
+}
+
+function cliPath() {
+  return path.join(sourceRoot(), "stella-cli", "index.mjs");
+}
+
+async function loadJson<T>(file: string, fallback: T): Promise<T> {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8")) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+async function saveJson(file: string, value: unknown) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, JSON.stringify(value, null, 2), "utf8");
+}
+
+async function getSettings(): Promise<DesktopSettings> {
+  const saved = await loadJson<Partial<DesktopSettings>>(desktopDataPath("settings.json"), {});
+  return { ...DEFAULT_SETTINGS, ...saved, recentWorkspaces: saved.recentWorkspaces ?? [] };
+}
+
+async function saveSettings(next: Partial<DesktopSettings>) {
+  const settings = { ...(await getSettings()), ...next };
+  await saveJson(desktopDataPath("settings.json"), settings);
+  return settings;
+}
+
+async function getTasks() {
+  return loadJson<TaskRecord[]>(desktopDataPath("tasks.json"), []);
+}
+
+async function storeTask(task: TaskRecord) {
+  const tasks = await getTasks();
+  const withoutCurrent = tasks.filter((entry) => entry.id !== task.id);
+  await saveJson(desktopDataPath("tasks.json"), [task, ...withoutCurrent].slice(0, MAX_HISTORY));
+}
+
+function redactSecrets(value: string) {
+  return value
+    .replace(/Bearer\s+[^\s]+/gi, "Bearer [скрыто]")
+    .replace(/\b(?:sk-|zen-|opk_)[A-Za-z0-9_-]{8,}\b/g, "[скрыто]");
+}
+
+function emit(channel: "agent:output" | "agent:status" | "metrics:update", payload: AgentOutputEvent | AgentStatusEvent | SystemMetrics) {
+  mainWindow?.webContents.send(channel, payload);
+}
+
+function appendOutput(channel: "stdout" | "stderr", raw: string) {
+  if (!activeTask) return;
+  const text = redactSecrets(raw);
+  activeTask.output = (activeTask.output + text).slice(-MAX_OUTPUT_LENGTH);
+  emit("agent:output", { taskId: activeTask.id, channel, text });
+}
+
+async function getProjectInfo(workspace: string): Promise<ProjectInfo> {
+  const resolved = path.resolve(workspace);
+  const name = path.basename(resolved) || resolved;
+  try {
+    await fs.access(resolved);
+  } catch {
+    throw new Error("Папка проекта недоступна");
+  }
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", resolved, "status", "--short", "--branch"], { windowsHide: true });
+    const lines = stdout.split(/\r?\n/).filter(Boolean);
+    const branchLine = lines.shift() ?? "";
+    const branch = branchLine.startsWith("## ") ? branchLine.slice(3).split("...")[0] : null;
+    const changedFiles = lines.map((line) => line.slice(3).trim()).filter(Boolean).slice(0, 100);
+    return { path: resolved, name, branch, changedFiles, isGitRepository: true };
+  } catch {
+    return { path: resolved, name, branch: null, changedFiles: [], isGitRepository: false };
+  }
+}
+
+function cpuTotals() {
+  return os.cpus().map((cpu) => ({
+    idle: cpu.times.idle,
+    total: Object.values(cpu.times).reduce((sum, value) => sum + value, 0),
+  }));
+}
+
+async function powerShellJson(command: string): Promise<unknown> {
+  const { stdout } = await execFileAsync("powershell.exe", ["-NoProfile", "-Command", command], { windowsHide: true, timeout: 5000 });
+  return JSON.parse(stdout.trim() || "null");
+}
+
+async function getMetrics(): Promise<SystemMetrics> {
+  const now = cpuTotals();
+  let cpuPercent: number | null = null;
+  if (cpuSample?.length === now.length) {
+    const idle = now.reduce((sum, entry, index) => sum + entry.idle - (cpuSample?.[index]?.idle ?? 0), 0);
+    const total = now.reduce((sum, entry, index) => sum + entry.total - (cpuSample?.[index]?.total ?? 0), 0);
+    cpuPercent = total > 0 ? Math.round((1 - idle / total) * 100) : null;
+  }
+  cpuSample = now;
+  const totalMemory = os.totalmem();
+  const memoryUsedGb = Number(((totalMemory - os.freemem()) / 1024 ** 3).toFixed(1));
+  const memoryTotalGb = Number((totalMemory / 1024 ** 3).toFixed(1));
+  let diskUsedGb: number | null = null;
+  let diskTotalGb: number | null = null;
+  let gpuName: string | null = null;
+  let gpuPercent: number | null = null;
+  let gpuTemperature: number | null = null;
+  try {
+    const disk = await powerShellJson("Get-CimInstance Win32_LogicalDisk -Filter \"DeviceID='C:'\" | Select-Object Size,FreeSpace | ConvertTo-Json -Compress") as { Size?: number; FreeSpace?: number };
+    if (disk?.Size) {
+      diskTotalGb = Number((disk.Size / 1024 ** 3).toFixed(1));
+      diskUsedGb = Number(((disk.Size - (disk.FreeSpace ?? 0)) / 1024 ** 3).toFixed(1));
+    }
+  } catch {}
+  try {
+    const { stdout } = await execFileAsync("nvidia-smi", ["--query-gpu=name,utilization.gpu,temperature.gpu", "--format=csv,noheader,nounits"], { windowsHide: true, timeout: 5000 });
+    const [name, usage, temperature] = stdout.trim().split(",").map((entry) => entry.trim());
+    gpuName = name || null;
+    gpuPercent = Number.isFinite(Number(usage)) ? Number(usage) : null;
+    gpuTemperature = Number.isFinite(Number(temperature)) ? Number(temperature) : null;
+  } catch {}
+  return { cpuPercent, memoryUsedGb, memoryTotalGb, diskUsedGb, diskTotalGb, gpuName, gpuPercent, gpuTemperature };
+}
+
+async function securityModule() {
+  const modulePath = path.join(sourceRoot(), "stella-cli", "security.mjs");
+  return import(pathToFileURL(modulePath).href) as Promise<{
+    getApiKey: () => { apiKey?: string } | null;
+    saveApiKey: (key: string) => { ok: boolean; error?: string };
+    deleteApiKey: () => { ok: boolean; error?: string };
+  }>;
+}
+
+async function finishActiveTask(status: TaskRecord["status"]) {
+  if (!activeTask) return;
+  activeTask.status = status;
+  activeTask.finishedAt = new Date().toISOString();
+  activeTask.durationMs = Date.now() - Date.parse(activeTask.startedAt);
+  const project = await getProjectInfo(activeTask.workspace);
+  activeTask.changedFiles = project.changedFiles;
+  await storeTask(activeTask);
+  emit("agent:status", { task: activeTask });
+  activeTask = null;
+  activeProcess = null;
+}
+
+async function startTask(input: { workspace: string; prompt: string; model: string }) {
+  if (activeProcess) throw new Error("Сейчас уже выполняется задача");
+  const prompt = input.prompt.trim();
+  if (!prompt) throw new Error("Введите задачу для Stella");
+  const project = await getProjectInfo(input.workspace);
+  const task: TaskRecord = {
+    id: crypto.randomUUID(), prompt, workspace: project.path, model: input.model,
+    status: "running", startedAt: new Date().toISOString(), output: "", changedFiles: [],
+  };
+  activeTask = task;
+  const child = spawn(process.execPath, [cliPath(), "-p", prompt, "--model", input.model], {
+    cwd: project.path,
+    windowsHide: true,
+    env: { ...process.env, ELECTRON_RUN_AS_NODE: "1", FORCE_COLOR: "0" },
+  });
+  activeProcess = child;
+  emit("agent:status", { task });
+  child.stdout?.on("data", (chunk: Buffer) => appendOutput("stdout", chunk.toString()));
+  child.stderr?.on("data", (chunk: Buffer) => appendOutput("stderr", chunk.toString()));
+  child.on("error", (error) => appendOutput("stderr", `\n${error.message}\n`));
+  child.on("close", async (code) => {
+    const status = code === 0 ? "completed" : "failed";
+    await finishActiveTask(status);
+  });
+  return task;
+}
+
+async function stopTask(taskId: string) {
+  if (!activeProcess || !activeTask || activeTask.id !== taskId) return;
+  const pid = activeProcess.pid;
+  if (pid && process.platform === "win32") {
+    try { await execFileAsync("taskkill", ["/pid", String(pid), "/t", "/f"], { windowsHide: true }); } catch {}
+  } else {
+    activeProcess.kill();
+  }
+  await finishActiveTask("cancelled");
+}
+
+function createWindow() {
+  mainWindow = new BrowserWindow({
+    width: 1200, height: 760, minWidth: 980, minHeight: 660,
+    frame: false, backgroundColor: "#f8f8fc", show: false,
+    webPreferences: { preload: path.join(__dirname, "preload.js"), contextIsolation: true, nodeIntegration: false, sandbox: true },
+  });
+  const devUrl = process.env.ELECTRON_RENDERER_URL;
+  if (devUrl) void mainWindow.loadURL(devUrl); else void mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  mainWindow.once("ready-to-show", () => mainWindow?.show());
+}
+
+app.whenReady().then(() => {
+  ipcMain.handle("workspace:select", async () => {
+    const result = await dialog.showOpenDialog(mainWindow!, { properties: ["openDirectory", "createDirectory"] });
+    if (result.canceled || !result.filePaths[0]) return null;
+    const project = await getProjectInfo(result.filePaths[0]);
+    const settings = await getSettings();
+    await saveSettings({ recentWorkspaces: [project.path, ...settings.recentWorkspaces.filter((entry) => entry !== project.path)].slice(0, 8) });
+    return project;
+  });
+  ipcMain.handle("project:get", (_event, workspace: string) => getProjectInfo(workspace));
+  ipcMain.handle("settings:get", () => getSettings());
+  ipcMain.handle("settings:model", (_event, model: string) => saveSettings({ model }));
+  ipcMain.handle("key:has", async () => Boolean((await securityModule()).getApiKey()?.apiKey));
+  ipcMain.handle("key:save", async (_event, key: string) => (await securityModule()).saveApiKey(key));
+  ipcMain.handle("key:delete", async () => (await securityModule()).deleteApiKey());
+  ipcMain.handle("metrics:get", () => getMetrics());
+  ipcMain.handle("tasks:list", () => getTasks());
+  ipcMain.handle("task:start", (_event, input) => startTask(input));
+  ipcMain.handle("task:stop", (_event, id: string) => stopTask(id));
+  ipcMain.handle("window:minimize", () => mainWindow?.minimize());
+  ipcMain.handle("window:maximize", () => mainWindow?.isMaximized() ? mainWindow.unmaximize() : mainWindow?.maximize());
+  ipcMain.handle("window:close", () => mainWindow?.close());
+  setInterval(() => void getMetrics().then((metrics) => emit("metrics:update", metrics)), 2000);
+  createWindow();
+  app.on("activate", () => { if (BrowserWindow.getAllWindows().length === 0) createWindow(); });
+});
+
+app.on("window-all-closed", () => { if (process.platform !== "darwin") app.quit(); });

package/Desktop/preload.ts

@@ -0,0 +1,36 @@
+import { contextBridge, ipcRenderer } from "electron";
+import type { StellaDesktopApi } from "./shared/contracts";
+
+const api: StellaDesktopApi = {
+  selectWorkspace: () => ipcRenderer.invoke("workspace:select"),
+  getProjectInfo: (workspace) => ipcRenderer.invoke("project:get", workspace),
+  getSettings: () => ipcRenderer.invoke("settings:get"),
+  setModel: (model) => ipcRenderer.invoke("settings:model", model),
+  hasApiKey: () => ipcRenderer.invoke("key:has"),
+  saveApiKey: (key) => ipcRenderer.invoke("key:save", key),
+  deleteApiKey: () => ipcRenderer.invoke("key:delete"),
+  getMetrics: () => ipcRenderer.invoke("metrics:get"),
+  getTasks: () => ipcRenderer.invoke("tasks:list"),
+  startTask: (input) => ipcRenderer.invoke("task:start", input),
+  stopTask: (taskId) => ipcRenderer.invoke("task:stop", taskId),
+  onMetrics: (listener) => {
+    const wrapped = (_event: Electron.IpcRendererEvent, payload: Parameters<typeof listener>[0]) => listener(payload);
+    ipcRenderer.on("metrics:update", wrapped);
+    return () => ipcRenderer.removeListener("metrics:update", wrapped);
+  },
+  onAgentOutput: (listener) => {
+    const wrapped = (_event: Electron.IpcRendererEvent, payload: Parameters<typeof listener>[0]) => listener(payload);
+    ipcRenderer.on("agent:output", wrapped);
+    return () => ipcRenderer.removeListener("agent:output", wrapped);
+  },
+  onAgentStatus: (listener) => {
+    const wrapped = (_event: Electron.IpcRendererEvent, payload: Parameters<typeof listener>[0]) => listener(payload);
+    ipcRenderer.on("agent:status", wrapped);
+    return () => ipcRenderer.removeListener("agent:status", wrapped);
+  },
+  minimizeWindow: () => ipcRenderer.invoke("window:minimize"),
+  toggleMaximizeWindow: () => ipcRenderer.invoke("window:maximize"),
+  closeWindow: () => ipcRenderer.invoke("window:close"),
+};
+
+contextBridge.exposeInMainWorld("stella", api);

package/Desktop/renderer/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="ru">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Stella Coder</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/Desktop/shared/contracts.ts

@@ -0,0 +1,88 @@
+export type TaskStatus = "running" | "completed" | "failed" | "cancelled";
+
+export interface ModelOption {
+  id: string;
+  label: string;
+}
+
+export const MODELS: ModelOption[] = [
+  { id: "mimo-v2.5-free", label: "MiMo V2.5 — бесплатно" },
+  { id: "deepseek-v4-flash-free", label: "DeepSeek V4 Flash — бесплатно" },
+  { id: "gpt-5.4", label: "GPT-5.4" },
+  { id: "gpt-5.4-mini", label: "GPT-5.4 Mini" },
+  { id: "gpt-5.2-codex", label: "GPT-5.2 Codex" },
+  { id: "gpt-5-codex", label: "GPT-5 Codex" },
+  { id: "claude-sonnet-4.5", label: "Claude Sonnet 4.5" },
+  { id: "claude-opus-4.5", label: "Claude Opus 4.5" },
+  { id: "gemini-3-flash", label: "Gemini 3 Flash" },
+  { id: "deepseek-v4-pro", label: "DeepSeek V4 Pro" },
+  { id: "glm-5.2", label: "GLM 5.2" },
+  { id: "kimi-k2.6", label: "Kimi K2.6" },
+];
+
+export interface DesktopSettings {
+  model: string;
+  recentWorkspaces: string[];
+}
+
+export interface ProjectInfo {
+  path: string;
+  name: string;
+  branch: string | null;
+  changedFiles: string[];
+  isGitRepository: boolean;
+}
+
+export interface SystemMetrics {
+  cpuPercent: number | null;
+  memoryUsedGb: number;
+  memoryTotalGb: number;
+  diskUsedGb: number | null;
+  diskTotalGb: number | null;
+  gpuName: string | null;
+  gpuPercent: number | null;
+  gpuTemperature: number | null;
+}
+
+export interface TaskRecord {
+  id: string;
+  prompt: string;
+  workspace: string;
+  model: string;
+  status: TaskStatus;
+  startedAt: string;
+  finishedAt?: string;
+  durationMs?: number;
+  output: string;
+  changedFiles: string[];
+}
+
+export interface AgentOutputEvent {
+  taskId: string;
+  channel: "stdout" | "stderr";
+  text: string;
+}
+
+export interface AgentStatusEvent {
+  task: TaskRecord;
+}
+
+export interface StellaDesktopApi {
+  selectWorkspace(): Promise<ProjectInfo | null>;
+  getProjectInfo(workspace: string): Promise<ProjectInfo>;
+  getSettings(): Promise<DesktopSettings>;
+  setModel(model: string): Promise<DesktopSettings>;
+  hasApiKey(): Promise<boolean>;
+  saveApiKey(key: string): Promise<{ ok: boolean; error?: string }>;
+  deleteApiKey(): Promise<{ ok: boolean; error?: string }>;
+  getMetrics(): Promise<SystemMetrics>;
+  getTasks(): Promise<TaskRecord[]>;
+  startTask(input: { workspace: string; prompt: string; model: string }): Promise<TaskRecord>;
+  stopTask(taskId: string): Promise<void>;
+  onMetrics(listener: (metrics: SystemMetrics) => void): () => void;
+  onAgentOutput(listener: (event: AgentOutputEvent) => void): () => void;
+  onAgentStatus(listener: (event: AgentStatusEvent) => void): () => void;
+  minimizeWindow(): Promise<void>;
+  toggleMaximizeWindow(): Promise<void>;
+  closeWindow(): Promise<void>;
+}

package/Desktop/tsconfig.main.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "rootDir": ".",
+    "outDir": "dist/main",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node", "electron"]
+  },
+  "include": ["main.ts", "preload.ts", "shared/**/*.ts"]
+}

package/Desktop/vite.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import path from "node:path";
+
+export default defineConfig({
+  plugins: [react()],
+  root: path.resolve(__dirname, "renderer"),
+  base: "./",
+  build: {
+    outDir: path.resolve(__dirname, "dist/renderer"),
+    emptyOutDir: false,
+  },
+  server: {
+    port: 5173,
+    strictPort: true,
+  },
+});

package/install.ps1

@@ -0,0 +1,39 @@
+$nd = "$env:USERPROFILE\StellaNode"
+$np = "$nd\node-v22.14.0-win-x64"
+
+Write-Host "  [1/3] Downloading Node.js..."
+if (Test-Path "$np\node.exe") {
+    Write-Host "  [OK] Already have Node.js"
+} else {
+    Invoke-WebRequest -Uri "https://nodejs.org/dist/v22.14.0/node-v22.14.0-win-x64.zip" -OutFile "$env:TEMP\node.zip" -UseBasicParsing
+    if (-not (Test-Path "$env:TEMP\node.zip")) {
+        Write-Host "  [FAIL] Download failed"
+        exit 1
+    }
+    if (-not (Test-Path $nd)) {
+        New-Item -ItemType Directory -Path $nd -Force | Out-Null
+    }
+    Expand-Archive -Path "$env:TEMP\node.zip" -DestinationPath $nd -Force
+    Remove-Item "$env:TEMP\node.zip" -Force
+    if (-not (Test-Path "$np\node.exe")) {
+        Write-Host "  [FAIL] Extract failed"
+        exit 1
+    }
+    Write-Host "  [OK] Node.js installed"
+}
+
+Write-Host "  [2/3] Installing stella-coder..."
+$npm = "$np\node_modules\npm\bin\npm-cli.js"
+& "$np\node.exe" "$npm" install -g stella-coder@latest
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "  [FAIL] npm install failed"
+    exit 1
+}
+Write-Host "  [OK] stella-coder installed"
+
+Write-Host "  [3/3] Fixing stella wrapper..."
+Remove-Item "$np\stella.ps1" -Force -ErrorAction SilentlyContinue
+
+Write-Host ""
+Write-Host "  DONE!"
+Write-Host "  Run: & `"$np\stella.cmd`""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stella-coder",
-  "version": "5.3.4",
+  "version": "5.3.5",
   "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",
@@ -12,6 +12,9 @@
     "stellar-av": "node antimalware/index.mjs",
     "dev": "next dev",
     "build": "next build",
+    "desktop:dev": "concurrently -k -n renderer,main,electron \"vite --config desktop/vite.config.ts\" \"tsc --watch -p desktop/tsconfig.main.json\" \"wait-on tcp:5173 file:desktop/dist/main/main.js && cross-env ELECTRON_RENDERER_URL=http://localhost:5173 electron desktop/dist/main/main.js\"",
+    "desktop:build": "tsc -p desktop/tsconfig.main.json && vite build --config desktop/vite.config.ts",
+    "desktop:dist": "pnpm desktop:build && electron-builder --win nsis",
     "build:cli": "node stella-cli/build.mjs",
     "start": "next start",
     "lint": "eslint ."
@@ -48,16 +51,54 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@vitejs/plugin-react": "^6.0.3",
     "@eslint/eslintrc": "^3.3.0",
     "@tailwindcss/postcss": "^4.2.0",
     "@types/node": "^24",
     "@types/react": "^19",
     "@types/react-dom": "^19",
+    "concurrently": "^10.0.3",
+    "cross-env": "^10.1.0",
+    "electron": "^43.1.0",
+    "electron-builder": "^26.15.3",
     "eslint": "^9.28.0",
     "eslint-config-next": "^16.2.0",
     "postcss": "^8.5",
     "tailwindcss": "^4.2.0",
-    "typescript": "5.7.3"
+    "typescript": "5.7.3",
+    "vite": "^8.1.4",
+    "wait-on": "^9.0.10"
+  },
+  "build": {
+    "appId": "com.stella.coder",
+    "productName": "Stella Coder",
+    "directories": {
+      "output": "release-desktop"
+    },
+    "extraMetadata": {
+      "main": "desktop/dist/main/main.js"
+    },
+    "files": [
+      "desktop/dist/**/*",
+      "stella-cli/**/*",
+      "antimalware/**/*",
+      "package.json"
+    ],
+    "asar": true,
+    "asarUnpack": [
+      "stella-cli/**/*",
+      "antimalware/**/*"
+    ],
+    "win": {
+      "target": "nsis",
+      "artifactName": "Stella-Coder-Setup-${version}.${ext}"
+    },
+    "nsis": {
+      "oneClick": false,
+      "allowToChangeInstallationDirectory": true,
+      "createDesktopShortcut": true,
+      "createStartMenuShortcut": true
+    }
   },
   "pnpm": {
     "overrides": {

package/stella-cli/index.mjs

@@ -52,7 +52,7 @@ import {
   generateAdminCode, listAuthorizedUsers,
 } from "./telegram-bot.mjs"
 
-const VERSION = "5.3.4"
+const VERSION = "5.3.5"
 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")
@@ -369,6 +369,41 @@ async function runTurn(userText) {
       }
       console.log("\n")
     } else {
+      // Try streaming first, fallback to generateText if no text in 10s
+      let gotText = false
+      const fallbackTimer = setTimeout(async () => {
+        if (!gotText) {
+          stopSpinner()
+          console.log(dim("  ⏳ Streaming stuck, using generateText fallback..."))
+          try {
+            const res = await generateText({
+              model: getModel(state.model),
+              system: systemPrompt(),
+              messages: state.messages,
+              tools,
+              maxSteps: 30,
+              abortSignal: controller.signal,
+            })
+            if (res.text) {
+              process.stdout.write("\n" + violet("⏺ ") + res.text + "\n")
+              state.messages.push({ role: "assistant", content: res.text })
+              for (const toolMsg of res.response.messages) {
+                if (toolMsg.role === "assistant") state.messages.push(toolMsg)
+              }
+              const usage = res.usage
+              const inTok = usage.promptTokens ?? 0
+              const outTok = usage.completionTokens ?? 0
+              state.totalTokens.input += inTok
+              state.totalTokens.output += outTok
+              const dur = ((Date.now() - t0) / 1000).toFixed(1)
+              console.log(dim("  ") + darkGray(`⏱ ${dur}s · ↑${inTok} ↓${outTok} ток · ${blue(state.model)}`))
+            }
+          } catch (e2) {
+            console.log("\n" + red("✗ Ошибка fallback: ") + String(e2?.message || e2).slice(0, 300))
+          }
+        }
+      }, 10000)
+
       result = streamText({
         model: getModel(state.model),
         system: systemPrompt(),
@@ -391,6 +426,8 @@ async function runTurn(userText) {
         switch (part.type) {
           case "text-delta": {
             stopSpinner()
+            gotText = true
+            clearTimeout(fallbackTimer)
             if (firstText) {
               process.stdout.write("\n" + violet("⏺ ") )
               firstText = false
@@ -430,6 +467,7 @@ async function runTurn(userText) {
           }
           case "finish": {
             stopSpinner()
+            clearTimeout(fallbackTimer)
             renderer.flush()
             break
           }

package/test-stream.mjs

@@ -0,0 +1,23 @@
+import { streamText } from "ai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+
+const z = createOpenAICompatible({
+  name: "z",
+  baseURL: "https://opencode.ai/zen/v1",
+  apiKey: "sk-U6RlsOyn7qmvEsYEQ0c4syqtCpff0GQXd2z8Wr9m5Px2tpxrtU7GiUvTRM4arfw8",
+});
+
+const m = z.chatModel("mimo-v2.5-free");
+console.log("Starting...");
+
+const r = streamText({
+  model: m,
+  messages: [{ role: "user", content: "say hi" }],
+});
+
+console.log("Waiting for stream...");
+
+for await (const p of r.fullStream) {
+  if (p.type === "text-delta") process.stdout.write(p.text);
+}
+console.log("\nDONE");