izteamslots 1.1.0

package/backend/ui_facade.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+
+import os
+import shutil
+import uuid
+from pathlib import Path
+from typing import Any, Callable
+
+from . import PROJECT_ROOT
+from .account_store import AccountStore
+from .dto import AdminRow, AppStateDTO, MailAccountRow, WorkerRow
+from .mail import Mailbox, create_provider_for_mailbox
+from .openai_web_auth import (
+    close_browser as close_br,
+)
+from .openai_web_auth import (
+    oauth_login,
+    oauth_login_manual,
+    open_browser,
+    save_codex_file,
+    wait_for_browser_close,
+)
+from .slot_orchestrator import SlotManager
+
+LogFunc = Callable[[str], Any]
+ProgressFunc = Callable[[int, int, str | None], None]
+
+
+def _has_profile_files(profile_dir: Path) -> bool:
+    return profile_dir.exists() and any(profile_dir.iterdir())
+
+
+class UIFacade:
+    def __init__(self, store: AccountStore | None = None) -> None:
+        self.store = store or AccountStore()
+        self.manager: SlotManager | None = None
+        self.bootstrap()
+
+    def bootstrap(self) -> None:
+        profiles_json = PROJECT_ROOT / "profiles.json"
+        admin_index_exists = (self.store.admin_dir / "index.json").exists()
+        worker_index_exists = (self.store.worker_dir / "index.json").exists()
+
+        auto_migrate_profiles = os.environ.get("IZTEAMSLOTS_AUTOMIGRATE_PROFILES") == "1"
+        if auto_migrate_profiles and profiles_json.exists() and not admin_index_exists and not worker_index_exists:
+            self.store.migrate_from_profiles()
+
+        self.store.doctor()
+        self.sync_codex_files()
+
+    def shutdown(self) -> None:
+        self.sync_codex_files()
+
+    def sync_codex_files(self) -> None:
+        codex_dir = PROJECT_ROOT / "codex"
+        codex_dir.mkdir(parents=True, exist_ok=True)
+        for src_dir in (self.store.admin_dir, self.store.worker_dir):
+            if not src_dir.exists():
+                continue
+            for account_dir in src_dir.iterdir():
+                if not account_dir.is_dir():
+                    continue
+                for f in account_dir.glob("codex-*.json"):
+                    dst = codex_dir / f.name
+                    if not dst.exists() or f.stat().st_mtime > dst.stat().st_mtime:
+                        dst.write_text(f.read_text())
+
+    def get_state(self) -> dict[str, Any]:
+        raw_admins = self.store.list_admins()
+        raw_workers = self.store.list_workers()
+        admins = [
+            AdminRow.from_account(
+                a,
+                has_browser_profile=_has_profile_files(self.store.get_admin_profile_dir(a)),
+            )
+            for a in raw_admins
+        ]
+        workers = [
+            WorkerRow.from_account(
+                w,
+                has_browser_profile=_has_profile_files(self.store.get_worker_profile_dir(w)),
+            )
+            for w in raw_workers
+        ]
+        accounts: list[MailAccountRow] = [
+            *(MailAccountRow(kind="admin", email=a.email) for a in raw_admins),
+            *(MailAccountRow(kind="worker", email=w.email) for w in raw_workers),
+        ]
+        return AppStateDTO(admins=admins, workers=workers, accounts=accounts).to_dict()
+
+    def list_admins(self) -> list[dict[str, Any]]:
+        return [
+            AdminRow.from_account(
+                a,
+                has_browser_profile=_has_profile_files(self.store.get_admin_profile_dir(a)),
+            ).__dict__
+            for a in self.store.list_admins()
+        ]
+
+    def list_workers(self) -> list[dict[str, Any]]:
+        return [
+            WorkerRow.from_account(
+                w,
+                has_browser_profile=_has_profile_files(self.store.get_worker_profile_dir(w)),
+            ).__dict__
+            for w in self.store.list_workers()
+        ]
+
+    def list_workers_by_admin(self, admin_email: str) -> list[dict[str, Any]]:
+        workers = [w for w in self.store.list_workers() if w.admin_email == admin_email]
+        return [
+            WorkerRow.from_account(
+                w,
+                has_browser_profile=_has_profile_files(self.store.get_worker_profile_dir(w)),
+            ).__dict__
+            for w in workers
+        ]
+
+    def list_mail_accounts(self) -> list[dict[str, str]]:
+        out: list[dict[str, str]] = []
+        for a in self.store.list_admins():
+            out.append({"kind": "admin", "email": a.email})
+        for w in self.store.list_workers():
+            out.append({"kind": "worker", "email": w.email})
+        return out
+
+    def add_admin(self, email: str, password: str) -> dict[str, Any]:
+        admin = self.store.add_admin(email, password)
+        return AdminRow.from_account(admin).__dict__
+
+    def add_admin_manual(self, log: LogFunc) -> dict[str, Any]:
+        temp_root = self.store.admin_dir / f"_manual_{uuid.uuid4().hex}"
+        profile_dir = temp_root / "browser_profile"
+        page = None
+        created_admin_email: str | None = None
+
+        try:
+            page, session = oauth_login_manual(
+                profile_dir=profile_dir,
+                log=log,
+            )
+            email = str(session.get("email") or "").strip()
+            if not email:
+                raise RuntimeError("OAuth не вернул email, админ не создан")
+            if self.store.get_admin(email):
+                raise RuntimeError(f"Админ {email} уже существует")
+
+            admin = self.store.add_admin(email, "")
+            created_admin_email = email
+
+            manager = SlotManager(store=self.store, admin_email=email, log=log)
+            manager.finalize_admin_session(page, session)
+            page = None
+
+            target_profile_dir = self.store.get_admin_profile_dir(admin)
+            if target_profile_dir.exists():
+                shutil.rmtree(target_profile_dir)
+            shutil.move(str(profile_dir), str(target_profile_dir))
+            log(f"Профиль сохранён: {target_profile_dir}")
+
+            self.sync_codex_files()
+            log(f"Админ {email} добавлен через ручной логин")
+            log("[предупреждение] Пароль почты не сохранён. Для почты и авто-входа добавьте его позже.")
+            return AdminRow.from_account(
+                self.store.get_admin(email) or admin,
+                has_browser_profile=_has_profile_files(target_profile_dir),
+            ).__dict__
+        except Exception:
+            if page is not None:
+                try:
+                    close_br(page, log=log)
+                except Exception:
+                    pass
+            if created_admin_email:
+                try:
+                    self.store.delete_admin(created_admin_email)
+                except Exception:
+                    pass
+            raise
+        finally:
+            if temp_root.exists():
+                shutil.rmtree(temp_root, ignore_errors=True)
+
+    def delete_admin(self, email: str) -> None:
+        self.store.delete_admin(email)
+        for w in self.store.list_workers():
+            if w.admin_email == email:
+                w.admin_email = None
+                self.store.update_worker(w)
+        if self.manager and self.manager.admin_email == email:
+            self.manager = None
+
+    def delete_worker(self, email: str) -> None:
+        self.store.delete_worker(email)
+
+    def open_admin_browser(self, email: str, log: LogFunc) -> None:
+        admin = self.store.get_admin(email)
+        if not admin:
+            raise RuntimeError("Админ не найден")
+        profile_dir = self.store.get_admin_profile_dir(admin)
+        if not any(profile_dir.iterdir()):
+            raise RuntimeError("Нет browser_profile, сначала перелогиньте админа")
+        self._open_profile_browser(
+            profile_dir, email, log,
+            url="https://chatgpt.com/admin/members?tab=members",
+        )
+
+    def open_worker_browser(self, email: str, log: LogFunc) -> None:
+        worker = self.store.get_worker(email)
+        if not worker:
+            raise RuntimeError("Слот не найден")
+        profile_dir = self.store.get_worker_profile_dir(worker)
+        if not any(profile_dir.iterdir()):
+            raise RuntimeError("Нет browser_profile, сначала перелогиньте слот")
+        self._open_profile_browser(profile_dir, email, log)
+
+    def _open_profile_browser(
+        self, profile_dir: Path, label: str, log: LogFunc, url: str = "https://chatgpt.com/",
+    ) -> None:
+        _page, context = open_browser(profile_dir, url=url, log=log)
+        log(f"Браузер {label} открыт. Закройте окно браузера для возврата.")
+        wait_for_browser_close(context, log=log)
+
+    def login_admin(self, email: str, log: LogFunc) -> None:
+        self.manager = SlotManager(store=self.store, admin_email=email, log=log)
+        self.manager.login_admin()
+        self.sync_codex_files()
+
+    def login_admin_manual(self, email: str, log: LogFunc) -> None:
+        self.manager = SlotManager(store=self.store, admin_email=email, log=log)
+        self.manager.login_admin_manual()
+        self.sync_codex_files()
+
+    def run_slots_pipeline(
+        self,
+        admin_email: str,
+        count: int,
+        log: LogFunc,
+        progress: ProgressFunc | None = None,
+    ) -> dict[str, int]:
+        self.manager = SlotManager(store=self.store, admin_email=admin_email, log=log, headless=False)
+        ok = 0
+        for i in range(count):
+            slot_no = i + 1
+            log(f"--- Слот {slot_no}/{count} ---")
+            if progress:
+                progress(slot_no, count, f"slot {slot_no}/{count}")
+            try:
+                self.manager.create_invite_login_one()
+                ok += 1
+            except Exception as e:
+                log(f"Ошибка: {e}")
+        self.manager._close_admin_page()
+        log(f"Готово: {ok}/{count} слотов")
+        self.sync_codex_files()
+        return {"ok": ok, "total": count}
+
+    def relogin_worker_email(self, email: str, log: LogFunc) -> bool:
+        worker = self.store.get_worker(email)
+        if not worker:
+            log(f"Worker {email} не найден")
+            return False
+        if not worker.openai_password:
+            log(f"{email} — нет openai_password")
+            return False
+
+        mail = create_provider_for_mailbox(Mailbox(email=worker.email, password=worker.password))
+        try:
+            mailbox = Mailbox(email=worker.email, password=worker.password)
+            profile_dir = self.store.get_worker_profile_dir(worker)
+
+            page, session = oauth_login(
+                email=worker.email,
+                password=worker.openai_password or worker.password,
+                mail_client=mail,
+                mailbox=mailbox,
+                profile_dir=profile_dir,
+                log=log,
+                headless=False,
+            )
+
+            if session.get("access_token"):
+                worker.access_token = session["access_token"]
+                if session.get("account_id"):
+                    worker.workspace_id = session["account_id"]
+                self.store.update_worker(worker)
+
+                worker_dir = self.store.worker_dir / worker.id
+                codex_path = save_codex_file(worker_dir, session, email)
+                log(f"Codex обновлён: {codex_path.name}")
+            else:
+                log("Нет access_token — codex не сохранён")
+                close_br(page, log=log)
+                return False
+
+            close_br(page, log=log)
+            log(f"{email} перелогинен")
+            self.sync_codex_files()
+            return True
+        finally:
+            mail.close()
+
+    def relogin_all_workers(
+        self,
+        log: LogFunc,
+        progress: ProgressFunc | None = None,
+    ) -> dict[str, int]:
+        workers = self.store.list_workers()
+        eligible = [w.email for w in workers if w.openai_password]
+        if not eligible:
+            log("Нет слотов с openai_password")
+            return {"ok": 0, "total": 0}
+
+        ok = 0
+        total = len(eligible)
+        for i, email in enumerate(eligible, start=1):
+            log(f"--- Перелогин {i}/{total}: {email} ---")
+            if progress:
+                progress(i, total, email)
+            if self.relogin_worker_email(email, log):
+                ok += 1
+        log(f"Готово: {ok}/{total}")
+        self.sync_codex_files()
+        return {"ok": ok, "total": total}
+
+    def fetch_mail(self, email: str, log: LogFunc) -> dict[str, Any]:
+        password = self._resolve_password(email)
+        if password is None:
+            raise RuntimeError("Аккаунт не найден")
+
+        mailbox = Mailbox(email=email, password=password)
+        mail = create_provider_for_mailbox(mailbox)
+        try:
+            inbox = mail.inbox(mailbox)
+        finally:
+            mail.close()
+
+        messages = inbox.messages
+        if not messages:
+            log(f"{email}: нет писем")
+        else:
+            log(f"{email}: писем {len(messages)}")
+            for m in messages[:50]:
+                log(f"{m.date} | {m.sender} | {m.subject}")
+
+        return {
+            "email": email,
+            "count": len(messages),
+            "messages": [
+                {
+                    "id": m.id,
+                    "date": m.date,
+                    "sender": m.sender,
+                    "subject": m.subject,
+                    "body": m.body,
+                }
+                for m in messages[:50]
+            ],
+        }
+
+    def _resolve_password(self, email: str) -> str | None:
+        admin = self.store.get_admin(email)
+        if admin:
+            return admin.password
+        worker = self.store.get_worker(email)
+        if worker:
+            return worker.password
+        return None

package/bin/izteamslots.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -e
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+
+# Ensure bun is available
+if ! command -v bun &>/dev/null; then
+  if [ -d "$HOME/.bun/bin" ]; then
+    export PATH="$HOME/.bun/bin:$PATH"
+  else
+    echo "Bun not found. Run: npm run setup" >&2
+    exit 1
+  fi
+fi
+
+exec bun run --cwd "$ROOT/ui" src/main.ts "$@"

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "izteamslots",
+  "version": "1.1.0",
+  "description": "ChatGPT Team slot management — automated invite, register, OAuth login & codex token pipeline",
+  "bin": {
+    "izteamslots": "bin/izteamslots.sh"
+  },
+  "scripts": {
+    "start": "bun run --cwd ui src/main.ts",
+    "setup": "bash scripts/setup.sh",
+    "postinstall": "bash scripts/setup.sh",
+    "typecheck:ui": "npm --prefix ui run typecheck"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/izzzzzi/izTeamSlots.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "chatgpt",
+    "team",
+    "slots",
+    "openai",
+    "codex",
+    "automation"
+  ]
+}

package/requirements.txt

@@ -0,0 +1,2 @@
+requests>=2.31
+seleniumbase>=4.32

package/scripts/setup.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+ok()   { echo -e "  ${GREEN}✓${NC} $1"; }
+warn() { echo -e "  ${YELLOW}!${NC} $1"; }
+fail() { echo -e "  ${RED}✗${NC} $1"; exit 1; }
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+echo ""
+echo "izTeamSlots setup"
+echo "================="
+echo ""
+
+# ── Python ──────────────────────────────────────────────
+echo "Checking Python..."
+PYTHON=""
+for cmd in python3 python; do
+  if command -v "$cmd" &>/dev/null; then
+    ver=$("$cmd" --version 2>&1 | grep -oE '[0-9]+\.[0-9]+')
+    major=$(echo "$ver" | cut -d. -f1)
+    minor=$(echo "$ver" | cut -d. -f2)
+    if [ "$major" -ge 3 ] && [ "$minor" -ge 11 ]; then
+      PYTHON="$cmd"
+      break
+    fi
+  fi
+done
+[ -z "$PYTHON" ] && fail "Python 3.11+ not found. Install: https://python.org"
+ok "Python: $($PYTHON --version)"
+
+# ── uv ──────────────────────────────────────────────────
+echo "Checking uv..."
+if ! command -v uv &>/dev/null; then
+  warn "uv not found. Installing..."
+  curl -LsSf https://astral.sh/uv/install.sh | sh
+  export PATH="$HOME/.local/bin:$HOME/.cargo/bin:$PATH"
+fi
+command -v uv &>/dev/null || fail "uv install failed. Install manually: https://docs.astral.sh/uv"
+ok "uv: $(uv --version)"
+
+# ── Python deps ─────────────────────────────────────────
+echo "Installing Python dependencies..."
+uv pip install --system -q -r "$ROOT/requirements.txt"
+ok "Python deps installed"
+
+# ── Bun ─────────────────────────────────────────────────
+echo "Checking Bun..."
+if ! command -v bun &>/dev/null; then
+  warn "Bun not found. Installing..."
+  curl -fsSL https://bun.sh/install | bash
+  export PATH="$HOME/.bun/bin:$PATH"
+fi
+command -v bun &>/dev/null || fail "Bun install failed. Install manually: https://bun.sh"
+ok "Bun: $(bun --version)"
+
+# ── UI deps ─────────────────────────────────────────────
+echo "Installing UI dependencies..."
+cd "$ROOT/ui"
+bun install --frozen-lockfile 2>/dev/null || bun install
+ok "UI deps installed"
+cd "$ROOT"
+
+# ── .env ────────────────────────────────────────────────
+if [ ! -f "$ROOT/.env" ]; then
+  if [ -f "$ROOT/.env.example" ]; then
+    cp "$ROOT/.env.example" "$ROOT/.env"
+    warn ".env created from .env.example — edit it with your API keys"
+  fi
+fi
+
+# ── Done ────────────────────────────────────────────────
+echo ""
+echo -e "${GREEN}Setup complete!${NC}"
+echo ""
+echo "  Start:  npm start"
+echo "  Or:     bun run --cwd ui src/main.ts"
+echo ""

package/ui/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "izteamslots-opentui",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "start": "bun run src/main.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@opentui/core": "^0.1.86"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.18",
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}

package/ui/src/main.ts

@@ -0,0 +1,4 @@
+import { MainScreen } from "./screens/MainScreen"
+
+const screen = new MainScreen()
+await screen.start()

package/ui/src/menus/format.ts

@@ -0,0 +1,163 @@
+import { StyledText, bg, bold, fg, stringToStyledText, t } from "@opentui/core"
+import type { DashboardData, MenuOption } from "./types"
+
+function truncate(value: string, width: number): string {
+  if (width <= 1) return value.slice(0, width)
+  if (value.length <= width) return value
+  return `${value.slice(0, width - 1)}…`
+}
+
+function pad(value: string, width: number): string {
+  const v = truncate(value, width)
+  if (v.length >= width) return v
+  return v + " ".repeat(width - v.length)
+}
+
+export function formatTable(
+  headers: string[],
+  rows: string[][],
+  maxWidth = 120,
+  emptyMessage = "Нет данных для отображения.",
+): StyledText {
+  const allRows = [headers, ...rows]
+  if (allRows.length === 0) return stringToStyledText("")
+
+  const cols = headers.length
+  const widths = new Array(cols).fill(0)
+  for (const row of allRows) {
+    for (let i = 0; i < cols; i++) {
+      const cell = row[i] ?? ""
+      widths[i] = Math.max(widths[i], cell.length)
+    }
+  }
+
+  const minCol = 8
+  for (let i = 0; i < cols; i++) widths[i] = Math.max(minCol, Math.min(widths[i], 48))
+
+  const separatorWidth = (cols - 1) * 3
+  const total = widths.reduce((a: number, b: number) => a + b, 0) + separatorWidth
+  if (total > maxWidth) {
+    const overflow = total - maxWidth
+    const perColCut = Math.ceil(overflow / cols)
+    for (let i = 0; i < cols; i++) widths[i] = Math.max(minCol, widths[i] - perColCut)
+  }
+
+  const rowToLine = (row: string[]): string => row.map((v, i) => pad(v ?? "", widths[i])).join(" │ ")
+  const headerLine = rowToLine(headers)
+  const divider = widths.map((w: number) => "─".repeat(w)).join("─┼─")
+
+  const lines: StyledText[] = [
+    t`${bg("#334155")(fg("#f8fafc")(bold(headerLine)))}`,
+    t`${fg("#64748b")(divider)}`,
+  ]
+
+  if (rows.length === 0) {
+    lines.push(t`${fg("#64748b")(truncate(emptyMessage, Math.max(12, maxWidth)))}`)
+    return joinStyledLines(lines)
+  }
+
+  lines.push(
+    ...rows.map((row, i) => {
+      const line = rowToLine(row)
+      return i % 2 === 0 ? t`${fg("#cbd5e1")(line)}` : t`${bg("#111827")(fg("#cbd5e1")(line))}`
+    }),
+  )
+
+  return joinStyledLines(lines)
+}
+
+export function formatMenu(options: MenuOption[], selected: number, maxWidth = 80): StyledText {
+  if (options.length === 0) {
+    return t`${fg("#94a3b8")("(пусто)")}`
+  }
+
+  const lines: StyledText[] = []
+  const longestLabel = options.reduce((max, option) => Math.max(max, option.label.length), 0)
+  const labelWidth = Math.max(18, Math.min(longestLabel + 2, 28))
+  const hintWidth = Math.max(20, maxWidth - labelWidth - 8)
+
+  for (let i = 0; i < options.length; i++) {
+    const opt = options[i]
+    const num = i < 9 ? `${i + 1}.` : "• "
+    const label = pad(opt.label, labelWidth)
+    const hint = opt.hint ? `  ${truncate(opt.hint, hintWidth)}` : ""
+    const activeBg = opt.destructive ? "#7f1d1d" : "#2563eb"
+    const activeFg = opt.destructive ? "#fee2e2" : "#eff6ff"
+    const inline = `${label}${hint}`
+
+    if (i === selected) {
+      lines.push(t`${bg(activeBg)(fg(activeFg)(bold(` ${num} ${inline} `)))}`)
+    } else if (opt.destructive) {
+      lines.push(t`${fg("#64748b")(` ${num}`)} ${fg("#f87171")(label)}${fg("#64748b")(hint)}`)
+    } else {
+      lines.push(t`${fg("#64748b")(` ${num}`)} ${fg("#cbd5e1")(label)}${fg("#64748b")(hint)}`)
+    }
+  }
+
+  return joinStyledLines(lines)
+}
+
+export function formatDashboard(data: DashboardData, maxWidth = 72): StyledText {
+  const lines: StyledText[] = []
+
+  const adminHealth = data.admins_total === 0
+    ? "нужен первый админ"
+    : `${data.admins_ready}/${data.admins_total} готовы`
+  const adminHealthColor = data.admins_ready === data.admins_total ? "#4ade80" : "#fbbf24"
+
+  lines.push(
+    t`${fg("#94a3b8")("Админы  ")}${fg("#f8fafc")(bold(pad(String(data.admins_total), 4)))}${fg(adminHealthColor)(truncate(adminHealth, Math.max(16, maxWidth - 22)))}`,
+  )
+
+  const detailParts: string[] = []
+  if (data.workers_ready > 0) detailParts.push(`${data.workers_ready} готовы`)
+  if (data.workers_registered > 0) detailParts.push(`${data.workers_registered} готово`)
+  if (data.workers_invited > 0) detailParts.push(`${data.workers_invited} приглашено`)
+  if (data.workers_created > 0) detailParts.push(`${data.workers_created} создано`)
+  if (data.workers_with_password > 0) detailParts.push(`${data.workers_with_password} с паролем`)
+
+  const detail = detailParts.length > 0 ? detailParts.join(" / ") : ""
+
+  if (detail) {
+    lines.push(
+      t`${fg("#94a3b8")("Слоты   ")}${fg("#f8fafc")(bold(pad(String(data.workers_total), 4)))}${fg("#94a3b8")(truncate(detail, Math.max(16, maxWidth - 22)))}`,
+    )
+  } else {
+    lines.push(t`${fg("#94a3b8")("Слоты   ")}${fg("#f8fafc")(bold(String(data.workers_total)))}`)
+  }
+
+  if (data.admins_total === 0) {
+    lines.push(t`${fg("#fca5a5")("Нужно добавить первого администратора.")}`)
+  } else if (data.admins_ready < data.admins_total) {
+    lines.push(t`${fg("#fbbf24")("Не все админы готовы: проверьте токен и браузерный профиль.")}`)
+  } else if (data.workers_total === 0) {
+    lines.push(t`${fg("#93c5fd")("Система готова к созданию первых слотов.")}`)
+  } else {
+    lines.push(t`${fg("#4ade80")("Операционный контур выглядит готовым к работе.")}`)
+  }
+
+  return joinStyledLines(lines)
+}
+
+export function formatLogs(logs: string[], max = 200, maxWidth = 120): StyledText {
+  const tail = logs.slice(Math.max(0, logs.length - max))
+  if (tail.length === 0) return t`${fg("#64748b")("Ожидание событий...")}`
+
+  const lines: StyledText[] = tail.map((line, i) => {
+    const value = truncate(line, Math.max(24, maxWidth))
+    if (line.includes("Ошибка:")) return t`${fg("#fca5a5")(value)}`
+    if (line.includes("▶") || line.includes("Готово")) return t`${fg("#93c5fd")(bold(value))}`
+    return i % 2 === 0 ? t`${fg("#cbd5e1")(value)}` : t`${fg("#94a3b8")(value)}`
+  })
+
+  return joinStyledLines(lines)
+}
+
+export function joinStyledLines(lines: StyledText[]): StyledText {
+  const chunks: StyledText["chunks"] = []
+  for (let i = 0; i < lines.length; i++) {
+    chunks.push(...lines[i].chunks)
+    if (i < lines.length - 1) chunks.push(...stringToStyledText("\n").chunks)
+  }
+  return new StyledText(chunks)
+}