izteamslots 1.5.2 → 1.5.3

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.5.3](https://github.com/izzzzzi/izTeamSlots/compare/v1.5.2...v1.5.3) (2026-03-06)
+
+
+### Bug Fixes
+
+* infrastructure hardening — atomic writes, DATA_ROOT, emergency exit, virtual scroll ([683dfd6](https://github.com/izzzzzi/izTeamSlots/commit/683dfd6670b0d4431b639331f2bc205f2fd8348a))
+
 ## [1.5.2](https://github.com/izzzzzi/izTeamSlots/compare/v1.5.1...v1.5.2) (2026-03-06)
 
 

package/README.md

@@ -36,15 +36,12 @@
 - Перелогин слотов: одного выбранного или всех по очереди.
 - Codex-файлы: авто-сохранение `codex-<email>-Team.json` в аккаунт и в `./codex/`.
 - Doctor-проверка: валидация/восстановление файловой структуры аккаунтов при старте.
-- Просмотр почты: входящие письма для админов и слотов.
-
 ---
 
 ## Структура проекта
 
 ```text
 izTeamSlots/
-├── app.py                          # Entrypoint: запускает UI
 ├── bin/                            # CLI-бинарники
 │   └── izteamslots.mjs             # Кроссплатформенный entrypoint (Node.js)
 ├── scripts/                        # Установочные скрипты
@@ -147,17 +144,17 @@ izteamslots
 
 ```mermaid
 flowchart TD
-    A[app.py] -->|spawns| B[bun ui/src/main.ts]
+    A[izteamslots CLI] -->|bun| B[ui/src/main.ts]
     B --> C[MainScreen.ts]
-    C -->|stdio JSON-RPC| D[StdioRpcClient]
-    D -->|spawns| E[python -m backend]
+    C --> D[StdioRpcClient]
+    D -->|spawns + stdio JSON-RPC| E[python -m backend]
     E --> F[RPCServer]
     F --> G[UIFacade]
     G --> H[AccountStore]
     G --> I[SlotManager]
     I --> J[openai_web_auth]
     I --> K[chatgpt_workspace_api]
-    I --> L[Boomlify Mail API]
+    I --> L[Mail Providers]
 ```
 
 ## Почтовые провайдеры (плагины)

package/backend/__init__.py

@@ -1,3 +1,16 @@
+import os
 from pathlib import Path
 
 PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+
+def _resolve_data_root() -> Path:
+    env = os.environ.get("IZTEAMSLOTS_DATA")
+    if env:
+        return Path(env)
+    if "node_modules" in str(PROJECT_ROOT):
+        return Path.home() / ".izteamslots"
+    return PROJECT_ROOT
+
+
+DATA_ROOT = _resolve_data_root()

package/backend/account_store.py

@@ -9,9 +9,9 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
-from . import PROJECT_ROOT
+from . import DATA_ROOT, PROJECT_ROOT
 
-ACCOUNTS_DIR = PROJECT_ROOT / "accounts"
+ACCOUNTS_DIR = DATA_ROOT / "accounts"
 
 
 @dataclass
@@ -60,8 +60,7 @@ class AccountStore:
         return {}
 
     def _write_index(self, path: Path, data: dict) -> None:
-        index_path = path / "index.json"
-        index_path.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+        self._atomic_write_json(path / "index.json", data)
 
     def _read_meta(self, folder: Path) -> dict:
         meta_path = folder / "meta.json"
@@ -71,8 +70,13 @@ class AccountStore:
 
     def _write_meta(self, folder: Path, data: dict) -> None:
         folder.mkdir(parents=True, exist_ok=True)
-        meta_path = folder / "meta.json"
-        meta_path.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+        self._atomic_write_json(folder / "meta.json", data)
+
+    def _atomic_write_json(self, path: Path, data: dict) -> None:
+        """Write JSON atomically: temp file + rename to prevent corruption on crash."""
+        tmp = path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+        tmp.replace(path)
 
     # --- Admin CRUD ---
 
@@ -226,6 +230,7 @@ class AccountStore:
                 "email": email,
                 "password": password,
                 "status": "created",
+                "admin_email": admin_email,
             })
             return WorkerAccount(
                 id=worker_id, email=email, password=password,
@@ -256,6 +261,8 @@ class AccountStore:
                 meta["access_token"] = account.access_token
             if account.workspace_id is not None:
                 meta["workspace_id"] = account.workspace_id
+            if account.admin_email is not None:
+                meta["admin_email"] = account.admin_email
             self._write_meta(account_dir, meta)
 
     def delete_worker(self, email: str) -> None:
@@ -327,17 +334,24 @@ class AccountStore:
                     meta = {"email": email, "password": ""}
                     if role == "worker":
                         meta["status"] = info.get("status", "created")
+                        meta["admin_email"] = info.get("admin_email", "")
                     self._write_meta(account_dir, meta)
                     fixes.append(f"{role}: {email} — meta.json отсутствовал, создан заново")
                 else:
                     try:
                         json.loads(meta_path.read_text())
                     except (json.JSONDecodeError, OSError):
+                        backup = meta_path.with_suffix(".json.bak")
+                        try:
+                            meta_path.replace(backup)
+                        except OSError:
+                            pass
                         meta = {"email": email, "password": ""}
                         if role == "worker":
                             meta["status"] = info.get("status", "created")
+                            meta["admin_email"] = info.get("admin_email", "")
                         self._write_meta(account_dir, meta)
-                        fixes.append(f"{role}: {email} — meta.json был повреждён, пересоздан")
+                        fixes.append(f"{role}: {email} — meta.json повреждён, .bak сохранён")
 
             # 4. browser_profile отсутствует (данные есть, но куки нет)
             for email, info in index.items():
@@ -374,9 +388,21 @@ class AccountStore:
                             changed = True
                             fixes.append(f"{role}: папка {child.name} ({email}) — добавлена в index")
                         elif not email:
-                            # Нет meta или нет email — удаляем сироту
-                            shutil.rmtree(child)
-                            fixes.append(f"{role}: папка-сирота {child.name} без meta — удалена")
+                            fixes.append(f"{role}: папка-сирота {child.name} без meta — требует ручной проверки")
+
+            # Миграция: admin_email из index в meta.json для воркеров
+            if role == "worker":
+                for w_email, w_info in index.items():
+                    w_admin = w_info.get("admin_email", "")
+                    w_id = w_info.get("id")
+                    if not w_admin or not w_id:
+                        continue
+                    w_dir = role_dir / w_id
+                    w_meta = self._read_meta(w_dir)
+                    if w_meta and not w_meta.get("admin_email"):
+                        w_meta["admin_email"] = w_admin
+                        self._write_meta(w_dir, w_meta)
+                        fixes.append(f"worker: {w_email} — admin_email мигрирован в meta.json")
 
             if changed or to_remove:
                 self._write_index(role_dir, index)

package/backend/chatgpt_workspace_api.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import time
 from typing import Any
 
 from .openai_web_auth import Page
@@ -31,34 +32,51 @@ class ChatGPTWorkspaceAPI:
         url = f"https://chatgpt.com{path}"
         js_body = json.dumps(body) if body else "null"
 
-        result = self.page.evaluate(
-            """async ([url, method, body, token, accountId]) => {
-                const opts = {
-                    method: method,
-                    headers: {
-                        "Content-Type": "application/json",
-                        "Authorization": "Bearer " + token,
-                        "chatgpt-account-id": accountId,
-                    },
-                };
-                if (body && method !== 'GET' && method !== 'HEAD') opts.body = body;
-                const resp = await fetch(url, opts);
-                const text = await resp.text();
-                return {status: resp.status, body: text};
-            }""",
-            [url, method, js_body, self.access_token, self.account_id],
-        )
-
-        status = result["status"]
-        raw_body = result["body"]
-
-        if status >= 400:
-            short = raw_body[:200] if len(raw_body) > 200 else raw_body
-            if status == 403:
-                short = "Cloudflare/доступ запрещён — токен протух, перелогинитесь"
-            raise ChatGPTAPIError(status, short)
-
-        return json.loads(raw_body) if raw_body else {}
+        max_attempts = 3
+        for attempt in range(1, max_attempts + 1):
+            try:
+                result = self.page.evaluate(
+                    """async ([url, method, body, token, accountId]) => {
+                        const opts = {
+                            method: method,
+                            headers: {
+                                "Content-Type": "application/json",
+                                "Authorization": "Bearer " + token,
+                                "chatgpt-account-id": accountId,
+                            },
+                        };
+                        if (body && method !== 'GET' && method !== 'HEAD') opts.body = body;
+                        const resp = await fetch(url, opts);
+                        const text = await resp.text();
+                        return {status: resp.status, body: text};
+                    }""",
+                    [url, method, js_body, self.access_token, self.account_id],
+                )
+            except Exception as e:
+                if attempt < max_attempts:
+                    time.sleep(2 ** attempt)
+                    continue
+                raise ChatGPTAPIError(0, f"Browser error: {e}") from e
+
+            status = result["status"]
+            raw_body = result["body"]
+
+            if status in (429, 500, 502, 503, 504):
+                if attempt < max_attempts:
+                    time.sleep(2 ** attempt)
+                    continue
+                short = raw_body[:200] if len(raw_body) > 200 else raw_body
+                raise ChatGPTAPIError(status, short)
+
+            if status >= 400:
+                short = raw_body[:200] if len(raw_body) > 200 else raw_body
+                if status == 403:
+                    short = "Cloudflare/доступ запрещён — токен протух, перелогинитесь"
+                raise ChatGPTAPIError(status, short)
+
+            return json.loads(raw_body) if raw_body else {}
+
+        raise ChatGPTAPIError(0, "Max retries exceeded")
 
     def send_invites(self, emails: list[str]) -> dict:
         """Отправить инвайты в workspace."""

package/backend/dto.py

@@ -90,17 +90,10 @@ class WorkerRow:
         )
 
 
-@dataclass
-class MailAccountRow:
-    kind: str
-    email: str
-
-
 @dataclass
 class AppStateDTO:
     admins: list[AdminRow]
     workers: list[WorkerRow]
-    accounts: list[MailAccountRow]
 
     def to_dict(self) -> dict:
         return asdict(self)

package/backend/file_logger.py

@@ -7,7 +7,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
-from . import PROJECT_ROOT
+from . import DATA_ROOT
 
 
 def _timestamp() -> str:
@@ -23,7 +23,7 @@ def _safe_title(value: str) -> str:
 
 class FileLogger:
     def __init__(self, root: Path | None = None) -> None:
-        self.root = root or (PROJECT_ROOT / "logs")
+        self.root = root or (DATA_ROOT / "logs")
         self.jobs_dir = self.root / "jobs"
         self.app_log = self.root / "app.log"
         self._lock = threading.Lock()
@@ -49,7 +49,7 @@ class FileLogger:
         stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
         filename = f"{stamp}-{job_id[:8]}-{_safe_title(title)}.log"
         path = self.jobs_dir / filename
-        rel_path = path.relative_to(PROJECT_ROOT).as_posix()
+        rel_path = path.relative_to(DATA_ROOT).as_posix()
         logger = JobFileLogger(path=path, rel_path=rel_path, title=title, root_logger=self)
         logger.log(f"JOB START: {title}")
         self.info(f"Job created: {title} [{job_id}] -> {rel_path}")

package/backend/jobs.py

@@ -44,8 +44,19 @@ class JobManager:
     def __init__(self, emit: EmitFunc, file_logger: FileLogger | None = None) -> None:
         self._emit = emit
         self._file_logger = file_logger or FileLogger()
+        self._active_thread: threading.Thread | None = None
+        self._active_job_id: str | None = None
+        self._lock = threading.Lock()
+
+    @property
+    def busy(self) -> bool:
+        return self._active_thread is not None and self._active_thread.is_alive()
 
     def start(self, title: str, handler: Callable[[JobContext], Any]) -> str:
+        with self._lock:
+            if self.busy:
+                raise RuntimeError(f"Задача уже выполняется: {self._active_job_id}")
+
         job_id = uuid.uuid4().hex
         job_logger = self._file_logger.create_job_logger(job_id, title)
         self._emit("job.started", {"job_id": job_id, "title": title, "log_path": job_logger.rel_path})
@@ -73,4 +84,12 @@ class JobManager:
 
         thread = threading.Thread(target=runner, daemon=True)
         thread.start()
+        self._active_thread = thread
+        self._active_job_id = job_id
         return job_id
+
+    def wait_all(self, timeout: float = 30) -> None:
+        """Wait for the active job to finish."""
+        thread = self._active_thread
+        if thread and thread.is_alive():
+            thread.join(timeout=timeout)

package/backend/mail/boomlify.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import os
+import time
 from typing import Any
 from urllib.parse import urlencode
 
@@ -91,23 +92,33 @@ class BoomlifyProvider(MailProvider):
             if clean_query:
                 url = f"{url}?{urlencode(clean_query)}"
 
-        try:
-            resp = self._session.request(method, url, json=json_body, timeout=30)
-        except requests.RequestException as e:
-            raise MailServiceUnavailable(f"Connection error: {e}") from e
-
-        try:
-            data = resp.json()
-        except ValueError:
-            data = {"error": resp.text.strip()[:500]}
-
-        if resp.status_code in (401, 403):
-            raise MailAuthError(f"[{resp.status_code}] {data}")
-        if resp.status_code in (429, 500, 502, 503, 504):
-            raise MailServiceUnavailable(f"[{resp.status_code}] {data}")
-        if resp.status_code >= 400:
-            raise MailError(f"[{resp.status_code}] {data}")
-        return data
+        max_attempts = 3
+        for attempt in range(1, max_attempts + 1):
+            try:
+                resp = self._session.request(method, url, json=json_body, timeout=30)
+            except requests.RequestException as e:
+                if attempt < max_attempts:
+                    time.sleep(2 ** attempt)
+                    continue
+                raise MailServiceUnavailable(f"Connection error: {e}") from e
+
+            try:
+                data = resp.json()
+            except ValueError:
+                data = {"error": resp.text.strip()[:500]}
+
+            if resp.status_code in (401, 403):
+                raise MailAuthError(f"[{resp.status_code}] {data}")
+            if resp.status_code in (429, 500, 502, 503, 504):
+                if attempt < max_attempts:
+                    time.sleep(2 ** attempt)
+                    continue
+                raise MailServiceUnavailable(f"[{resp.status_code}] {data}")
+            if resp.status_code >= 400:
+                raise MailError(f"[{resp.status_code}] {data}")
+            return data
+
+        raise MailServiceUnavailable("Max retries exceeded")
 
     def _extract_mailbox_id(self, mailbox: Mailbox) -> str:
         password = mailbox.password.strip()

package/backend/mail/imap.py

@@ -21,6 +21,7 @@ import email as email_lib
 import imaplib
 import os
 import re
+import time
 from email.header import decode_header as _decode_header
 from typing import Any
 
@@ -128,22 +129,29 @@ class IMAPProvider(MailProvider):
 
     def _connect(self, mailbox: Mailbox) -> imaplib.IMAP4_SSL | imaplib.IMAP4:
         """Open an IMAP connection and authenticate."""
-        try:
-            if self.use_ssl:
-                conn = imaplib.IMAP4_SSL(self.host, self.port, timeout=self.timeout)
-            else:
-                conn = imaplib.IMAP4(self.host, self.port, timeout=self.timeout)
-        except (OSError, imaplib.IMAP4.error) as e:
-            raise MailServiceUnavailable(f"Cannot connect to {self.host}:{self.port}: {e}") from e
+        max_attempts = 3
+        for attempt in range(1, max_attempts + 1):
+            try:
+                if self.use_ssl:
+                    conn = imaplib.IMAP4_SSL(self.host, self.port, timeout=self.timeout)
+                else:
+                    conn = imaplib.IMAP4(self.host, self.port, timeout=self.timeout)
+            except (OSError, imaplib.IMAP4.error) as e:
+                if attempt < max_attempts:
+                    time.sleep(2 ** attempt)
+                    continue
+                raise MailServiceUnavailable(f"Cannot connect to {self.host}:{self.port}: {e}") from e
 
-        try:
-            conn.login(mailbox.email, mailbox.password)
-        except imaplib.IMAP4.error as e:
-            err_msg = str(e)
-            conn.logout()
-            raise MailAuthError(f"IMAP login failed for {mailbox.email}: {err_msg}") from e
+            try:
+                conn.login(mailbox.email, mailbox.password)
+            except imaplib.IMAP4.error as e:
+                err_msg = str(e)
+                conn.logout()
+                raise MailAuthError(f"IMAP login failed for {mailbox.email}: {err_msg}") from e
+
+            return conn
 
-        return conn
+        raise MailServiceUnavailable(f"Cannot connect to {self.host}:{self.port}")
 
     def generate(self) -> Mailbox:
         """IMAP cannot create mailboxes automatically.

package/backend/mail/trickads.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import json
 import re
+import time
 from typing import Any
 
 import requests
@@ -78,27 +79,38 @@ class TrickAdsProvider(MailProvider):
         endpoint: str,
         json_body: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        try:
-            resp = self._session.post(f"{BASE_URL}{endpoint}", json=json_body)
+        max_attempts = 3
+        for attempt in range(1, max_attempts + 1):
+            try:
+                resp = self._session.post(f"{BASE_URL}{endpoint}", json=json_body, timeout=30)
+            except requests.RequestException as e:
+                if attempt < max_attempts:
+                    time.sleep(2 ** attempt)
+                    continue
+                raise MailServiceUnavailable(f"Connection error: {e}") from e
+
             if resp.status_code != 200:
                 body = resp.text or ""
                 summary = _extract_error_summary(body)
                 if resp.status_code == 401:
                     raise MailAuthError(f"[{resp.status_code}] {summary}")
                 if resp.status_code >= 500:
+                    if attempt < max_attempts:
+                        time.sleep(2 ** attempt)
+                        continue
                     raise MailServiceUnavailable(f"[{resp.status_code}] {summary}")
                 raise MailError(f"[{resp.status_code}] {summary}")
+
             data: dict[str, Any] = resp.json()
-        except requests.RequestException as e:
-            raise MailServiceUnavailable(f"Connection error: {e}") from e
-
-        if data.get("status") != "success":
-            msg = data.get("message", "")
-            code = data.get("code", 0)
-            if code == 401 or "password" in msg.lower() or "unauthorized" in str(data.get("status", "")).lower():
-                raise MailAuthError(f"API: {data}")
-            raise MailError(f"API: {data}")
-        return data
+            if data.get("status") != "success":
+                msg = data.get("message", "")
+                code = data.get("code", 0)
+                if code == 401 or "password" in msg.lower() or "unauthorized" in str(data.get("status", "")).lower():
+                    raise MailAuthError(f"API: {data}")
+                raise MailError(f"API: {data}")
+            return data
+
+        raise MailServiceUnavailable("Max retries exceeded")
 
     def generate(self) -> Mailbox:
         data = self._request("/tepmail/generate")

package/backend/rpc_server.py

@@ -116,19 +116,6 @@ class RPCServer:
         if m == "state.get":
             return make_success_response(req.request_id, self.facade.get_state())
 
-        if m == "admins.list":
-            return make_success_response(req.request_id, {"items": self.facade.list_admins()})
-
-        if m == "workers.list":
-            return make_success_response(req.request_id, {"items": self.facade.list_workers()})
-
-        if m == "workers.by_admin":
-            email = self._as_str_param(p, "admin_email")
-            return make_success_response(req.request_id, {"items": self.facade.list_workers_by_admin(email)})
-
-        if m == "accounts.mail.list":
-            return make_success_response(req.request_id, {"items": self.facade.list_mail_accounts()})
-
         if m == "admin.add":
             email = self._as_str_param(p, "email")
             password = self._as_str_param(p, "password")
@@ -215,14 +202,6 @@ class RPCServer:
             )
             return make_success_response(req.request_id, {"job_id": job_id})
 
-        if m == "job.fetch_mail":
-            email = self._as_str_param(p, "email")
-            job_id = self._run_job(
-                f"Почта: {email}",
-                lambda ctx: self.facade.fetch_mail(email, ctx.log),
-            )
-            return make_success_response(req.request_id, {"job_id": job_id})
-
         if m == "settings.get":
             return make_success_response(req.request_id, self._get_settings())
 
@@ -235,6 +214,7 @@ class RPCServer:
             return make_success_response(req.request_id, {"ok": True})
 
         if m == "shutdown":
+            self.jobs.wait_all(timeout=10)
             self.facade.shutdown()
             return make_success_response(req.request_id, {"ok": True})
 
@@ -293,7 +273,6 @@ def main() -> int:
     for env_path in (home_env, cwd_env, pkg_env):
         if env_path.is_file():
             load_dotenv(env_path)
-            break
 
     server = RPCServer()
     server.serve()

package/backend/slot_orchestrator.py

@@ -286,8 +286,8 @@ class SlotManager:
         return worker
 
     def _cleanup_failed_worker(self, worker: WorkerAccount, api: ChatGPTWorkspaceAPI) -> None:
-        """Удалить worker из workspace если регистрация не удалась."""
-        self._log(f"Очистка: удаляю {worker.email} из workspace...")
+        """Удалить worker из workspace и локальных данных если регистрация не удалась."""
+        self._log(f"Очистка: удаляю {worker.email}...")
         try:
             members = api.get_members()
             for m in members:
@@ -296,14 +296,18 @@ class SlotManager:
                     self._log(f"Удалён из workspace: {worker.email}")
                     break
             else:
-                # Попробуем удалить инвайт если ещё не зарегистрирован
                 try:
                     api.delete_invite(worker.email)
                     self._log(f"Инвайт удалён: {worker.email}")
                 except Exception:
                     pass
         except Exception as ex:
-            self._log(f"Не удалось очистить: {ex}")
+            self._log(f"Не удалось очистить workspace: {ex}")
+        try:
+            self.store.delete_worker(worker.email)
+            self._log(f"Локальная запись удалена: {worker.email}")
+        except Exception as ex:
+            self._log(f"Не удалось удалить локально: {ex}")
 
     def get_pending_invites(self) -> list[dict]:
         page = self._ensure_admin_page()
@@ -351,6 +355,7 @@ class SlotManager:
         # Полный OAuth логин (как при перелогине) — получаем все токены
         self._log(f"OAuth логин {worker.email}...")
         page2: Page | None = None
+        oauth_ok = False
         try:
             page2, session = oauth_login(
                 email=worker.email,
@@ -370,13 +375,19 @@ class SlotManager:
                 worker_dir = self.store.worker_dir / worker.id
                 codex_path = save_codex_file(worker_dir, session, worker.email)
                 self._log(f"Codex-файл: {codex_path.name}")
+                oauth_ok = True
+            else:
+                self._log(f"OAuth: нет access_token для {worker.email}")
         except Exception as e:
             self._log(f"OAuth логин не удался: {e}")
         finally:
             if page2:
                 close_browser(page2, log=self._log)
 
-        self._log(f"Слот {worker.email} зарегистрирован!")
+        if oauth_ok:
+            self._log(f"Слот {worker.email} готов")
+        else:
+            self._log(f"Слот {worker.email} зарегистрирован, но OAuth не завершён — нужен перелогин")
 
     def get_status(self) -> dict:
         workers = self._get_workers()