kingkont 0.8.7 → 0.9.0

package/renderer/cloudProjects.js

@@ -0,0 +1,612 @@
+// renderer/cloudProjects.js — облачные проекты (CRUD + sync с локальной копией).
+//
+// Концепция:
+//   - Облачный проект хранится на Chatium (heap-table t_spaces_server_projects_K1).
+//   - Локально живёт в `userData/cloud-projects/<projectId>/` (через cloudFs IPC).
+//   - state.filmHandle указывает на этот локальный фолдер через cloudFs-shim
+//     (см. renderer/cloudFs.js → makeCloudHandle), весь существующий код
+//     board.js / generate.js / state.js работает без изменений.
+//   - Любое локальное изменение НЕ синхронизируется на сервер автоматически —
+//     юзер должен нажать «☁ Сохранить на сервер».
+//
+// Lifecycle:
+//   1. createNewCloudProject(name) → POST /api/projects → получаем id →
+//      ensureLocal(id) → openFilm(cloudHandle).
+//   2. openCloudProject(id) → GET /api/projects/<id> → скачать все файлы
+//      с CDN в userData/cloud-projects/<id>/ → openFilm(cloudHandle).
+//   3. saveCloudProject() → пройти по локальной копии → залить изменённые
+//      файлы (hash dedup через .kingkont-meta.json) → POST /api/projects~update.
+//
+// Маркеры:
+//   - state.cloudProjectId — id серверного проекта (если открыт облачный)
+//   - state.cloudDirty     — есть несохранённые изменения
+
+(function () {
+  // -------------- helpers --------------
+  function $(id) { return document.getElementById(id); }
+  function isLoggedIn(s) { return !!(s?.useChatium && s?.chatium?.token); }
+  async function getSettings() { try { return await window.appSettings?.get(); } catch { return {}; } }
+
+  // Прогресс — переиспользуем существующий tplProgress из templates.js.
+  const PROGRESS = (typeof TPL_PROGRESS !== 'undefined') ? TPL_PROGRESS : {
+    show() {}, update() {}, hide() {},
+  };
+
+  function setCloudButtonsVisibility() {
+    // Кнопки видны только если юзер залогинен в Chatium.
+    getSettings().then(s => {
+      const logged = isLoggedIn(s);
+      const inProject = !!state.filmHandle;
+      const newBtn = $('newCloudProject');
+      const openBtn = $('openCloudProjects');
+      const saveBtn = $('saveProjectCloud');
+      if (newBtn)   newBtn.style.display  = (logged && !inProject) ? '' : 'none';
+      if (openBtn)  openBtn.style.display = (logged && !inProject) ? '' : 'none';
+      // Save-кнопка: видна для ЛЮБОГО открытого проекта (cloud или папочного).
+      if (saveBtn)  saveBtn.style.display = (logged && inProject) ? '' : 'none';
+      if (saveBtn) {
+        // Cloud-проект → "☁ Сохранить на сервер"
+        // Папочный → "☁ Загрузить на сервер" (создаст или обновит шаблон-проект).
+        if (state.cloudProjectId) {
+          saveBtn.textContent = state.cloudDirty ? '☁ Сохранить на сервер •' : '☁ Сохранено';
+          saveBtn.disabled = false;
+        } else {
+          saveBtn.textContent = '☁ Сохранить как новый облачный';
+          saveBtn.disabled = false;
+        }
+      }
+    }).catch(() => {});
+  }
+
+  function markDirty() { state.cloudDirty = true; setCloudButtonsVisibility(); }
+  function markClean() { state.cloudDirty = false; setCloudButtonsVisibility(); }
+
+  // Перехват scheduleSave, чтобы помечать dirty для cloud-проектов.
+  // (scheduleSave определён в state.js; вызывается на любое изменение.)
+  if (typeof scheduleSave === 'function') {
+    const orig = scheduleSave;
+    window.scheduleSave = function () {
+      if (state.cloudProjectId) markDirty();
+      return orig.apply(this, arguments);
+    };
+  }
+
+  // -------------- список cloud-проектов: cached + background refresh --------------
+  // Хранится в localStorage:'cloudProjectsCache' = JSON-массив из /api/projects
+  // (тот же формат). Используется welcome-grid'ом, чтобы не ждать сетевого
+  // запроса при каждом открытии — UI показывает закэшированный список сразу,
+  // а свежий грузится фоном и обновляет grid через onChange колбек.
+  const CACHE_KEY = 'cloudProjectsCache';
+  function readCache() {
+    try {
+      const raw = localStorage.getItem(CACHE_KEY);
+      return raw ? JSON.parse(raw) : [];
+    } catch { return []; }
+  }
+  function writeCache(items) {
+    try { localStorage.setItem(CACHE_KEY, JSON.stringify(items)); } catch {}
+  }
+  // Subscribers: (items) => void.
+  const _listSubs = new Set();
+  function onListChange(cb) { _listSubs.add(cb); return () => _listSubs.delete(cb); }
+  function notifyListChange(items) { for (const cb of _listSubs) try { cb(items); } catch {} }
+
+  // Возвращает {cached: [...], promise: Promise<items>}.
+  // cached — синхронно из localStorage (для мгновенного render'а).
+  // promise — фоновый fetch, по завершении кэш обновлён + notifyListChange.
+  // Доп: к каждому item подмешиваем lastOpenedAt из локального хранилища —
+  // welcome сортирует cloud-карточки по max(updatedAt, lastOpenedAt), чтобы
+  // недавно открытые поднимались наверх (по аналогии с recents для папок).
+  const OPENED_KEY = 'cloudProjectsLastOpened';
+  function readOpenedMap() {
+    try { return JSON.parse(localStorage.getItem(OPENED_KEY) || '{}'); }
+    catch { return {}; }
+  }
+  function touchCloudOpened(projectId) {
+    if (!projectId) return;
+    const m = readOpenedMap();
+    m[projectId] = Date.now();
+    try { localStorage.setItem(OPENED_KEY, JSON.stringify(m)); } catch {}
+    // Обновляем cached entry, чтобы welcome перерисовался с новым order'ом.
+    const cached = readCache();
+    const i = cached.findIndex(c => c.id === projectId);
+    if (i >= 0) {
+      cached[i].lastOpenedAt = m[projectId];
+      writeCache(cached);
+      notifyListChange(cached);
+    }
+  }
+  function decorateWithOpened(items) {
+    const m = readOpenedMap();
+    return items.map(it => ({ ...it, lastOpenedAt: m[it.id] || 0 }));
+  }
+  function fetchListCached() {
+    const cached = decorateWithOpened(readCache());
+    const promise = (async () => {
+      const s = await getSettings();
+      if (!isLoggedIn(s)) return cached;     // нет логина → не дёргаем
+      try {
+        const r = await fetch('/api/projects');
+        if (!r.ok) return cached;
+        const items = decorateWithOpened(await r.json());
+        writeCache(items);
+        notifyListChange(items);
+        return items;
+      } catch { return cached; }
+    })();
+    return { cached, promise };
+  }
+
+  // -------------- create new cloud project --------------
+  async function createNewCloudProject() {
+    const s = await getSettings();
+    if (!isLoggedIn(s)) { alert('Войдите в KingKont (Настройки → Chatium), чтобы создавать облачные проекты'); return; }
+    // window.prompt() в Electron подавлен — используем нашу askName из board.js.
+    const name = await askName('Название проекта:', '', 'Новый проект');
+    if (!name || !name.trim()) return;
+    try {
+      // 1) Создаём пустую запись на сервере.
+      const r = await fetch('/api/projects', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: name.trim(), manifest: { boards: [] }, files: {} }),
+      });
+      if (!r.ok) {
+        const err = await r.json().catch(() => ({}));
+        throw new Error(err.error || `HTTP ${r.status}`);
+      }
+      const created = await r.json();
+      // 2) Локальный фолдер + cloud-handle.
+      const handle = await window.cloudFsShim.makeCloudHandle(created.id, name.trim());
+      // 3) Открываем как обычный проект (filmHandle).
+      state.cloudProjectId = created.id;
+      state.cloudDirty = false;
+      touchCloudOpened(created.id);
+      // Обновляем кэш списка (новый проект ещё не пришёл в /api/projects).
+      const cached = readCache();
+      cached.unshift({
+        id: created.id, name: created.name || name.trim(),
+        coverUrl: null, fileCount: 0, boardCount: 0,
+        updatedAt: created.createdAt || Date.now(),
+        createdAt: created.createdAt || Date.now(),
+        lastOpenedAt: Date.now(),
+        mine: true, canModify: true,
+      });
+      writeCache(cached);
+      notifyListChange(cached);
+      await openFilm(handle);
+      setCloudButtonsVisibility();
+    } catch (e) {
+      alert('Не удалось создать облачный проект: ' + (e?.message || e));
+    }
+  }
+
+  // -------------- open cloud project (использует local cache если есть) --------------
+  // Поведение:
+  //   1. Создаём/получаем local handle (через cloudFs shim).
+  //   2. Если local copy уже синхронизирована (.kingkont-meta.json
+  //      содержит cloudProjectId === projectId) — открываем без сети.
+  //      Юзер должен явно нажать «☁ Сохранить на сервер» чтобы запушить
+  //      локальные изменения, ИЛИ ПКМ→«Обновить из облака» (refreshFromServer).
+  //   3. Если copy не синхронизирована (первый открытие) — скачиваем
+  //      manifest + все файлы, потом открываем.
+  //
+  // Этот flow и кэш позволяют после первого скачивания работать с проектом
+  // моментально, как с папочным.
+  async function openCloudProject(projectId, suggestedName, opts = {}) {
+    const s = await getSettings();
+    if (!isLoggedIn(s)) { alert('Войдите в KingKont'); return; }
+    // 1. Проверяем синхронизирован ли уже локально.
+    if (window.cloudFs) {
+      try {
+        const metaText = await window.cloudFs.readText(projectId, '.kingkont-meta.json');
+        if (metaText && !opts.forceRefresh) {
+          const meta = JSON.parse(metaText);
+          if (meta.cloudProjectId === projectId) {
+            // Local copy готова — открываем без скачивания.
+            const handle = await window.cloudFsShim.makeCloudHandle(projectId, suggestedName || projectId);
+            state.cloudProjectId = projectId;
+            state.cloudDirty = false;
+            touchCloudOpened(projectId);
+            await openFilm(handle);
+            setCloudButtonsVisibility();
+            return;
+          }
+        }
+      } catch {}
+    }
+    // 2. Не синхронизирован → скачиваем с сервера.
+    PROGRESS.show('Загрузка проекта…');
+    try {
+      const r = await fetch('/api/projects/' + encodeURIComponent(projectId));
+      if (!r.ok) {
+        const err = await r.json().catch(() => ({}));
+        throw new Error(err.error || `HTTP ${r.status}`);
+      }
+      const proj = await r.json();
+      const handle = await window.cloudFsShim.makeCloudHandle(projectId, proj.name || suggestedName || 'Project');
+      // Скачиваем все board'ы манифеста (если они уже не лежат локально с тем же hash).
+      const boards = Array.isArray(proj.manifest?.boards) ? proj.manifest.boards : [];
+      // Сначала собираем общий список файлов для прогресса.
+      const totalFiles = boards.reduce((s, b) => s + Object.keys(b?.files || {}).length, 0);
+      let done = 0;
+      // fileHashes индексируем тем же ключом что использует save: `${kind}/${name}/${relPath}`.
+      // Это критично — иначе при следующем save dedup не найдёт ничего и
+      // перезальёт все файлы заново.
+      const fileHashes = {};
+      for (const board of boards) {
+        const boardDir = boardKindToDir(board.kind, board.name);
+        // 1) scene.json
+        if (board.scene) {
+          await writeCloudFile(projectId, joinPath(boardDir, 'scene.json'),
+            new TextEncoder().encode(JSON.stringify(board.scene, null, 2)));
+        }
+        // 2) media-файлы
+        for (const [relPath, cdnUrl] of Object.entries(board.files || {})) {
+          done++;
+          PROGRESS.update(done, totalFiles, `Загрузка ${relPath} (${done}/${totalFiles})`);
+          const fr = await fetch('/api/proxy?url=' + encodeURIComponent(cdnUrl));
+          if (!fr.ok) throw new Error(`Не удалось скачать ${relPath}: ${fr.status}`);
+          const buf = new Uint8Array(await fr.arrayBuffer());
+          const localPath = joinPath(boardDir, relPath);
+          await writeCloudFile(projectId, localPath, buf);
+          // Получаем mtimeMs от FS — без него dedup на save не сработает
+          // (cached.mtime === file.lastModified должно совпадать).
+          let mtime = Date.now();
+          if (window.cloudFs?.stat) {
+            try {
+              const st = await window.cloudFs.stat(projectId, localPath);
+              if (st?.mtimeMs) mtime = st.mtimeMs;
+            } catch {}
+          }
+          fileHashes[`${board.kind}/${board.name}/${relPath}`] = {
+            url: cdnUrl, size: buf.byteLength, mtime,
+          };
+        }
+      }
+      // 3) cover (опционально). Запоминаем size+mtime → coverHash для
+      // dedup'а при следующем save'е (иначе первый же save перезальёт
+      // обложку, хотя она не менялась).
+      let openedCoverHash = null;
+      if (proj.coverUrl) {
+        try {
+          const fr = await fetch('/api/proxy?url=' + encodeURIComponent(proj.coverUrl));
+          if (fr.ok) {
+            const buf = new Uint8Array(await fr.arrayBuffer());
+            const ct = fr.headers.get('content-type') || 'image/jpeg';
+            const ext = ct.includes('png') ? 'png' : (ct.includes('webp') ? 'webp' : 'jpg');
+            const coverPath = '.cover.' + ext;
+            await writeCloudFile(projectId, coverPath, buf);
+            let coverMtime = Date.now();
+            if (window.cloudFs?.stat) {
+              try {
+                const st = await window.cloudFs.stat(projectId, coverPath);
+                if (st?.mtimeMs) coverMtime = st.mtimeMs;
+              } catch {}
+            }
+            openedCoverHash = { size: buf.byteLength, mtime: coverMtime, url: proj.coverUrl };
+          }
+        } catch {}
+      }
+      // 4) meta — cloudProjectId + fileHashes (собран в loop'е выше) + coverHash.
+      // Ключи в формате `${kind}/${name}/${relPath}` совпадают с тем что
+      // использует saveCloudProject — dedup сработает на следующем save'е.
+      await writeCloudFile(projectId, '.kingkont-meta.json',
+        new TextEncoder().encode(JSON.stringify({
+          cloudProjectId: projectId,
+          fileHashes,
+          coverUrl: proj.coverUrl || null,
+          coverHash: openedCoverHash,
+          syncedAt: Date.now(),
+        }, null, 2)));
+      // 5) Открываем.
+      state.cloudProjectId = projectId;
+      state.cloudDirty = false;
+      touchCloudOpened(projectId);
+      await openFilm(handle);
+      setCloudButtonsVisibility();
+      PROGRESS.hide();
+    } catch (e) {
+      PROGRESS.hide();
+      alert('Не удалось открыть облачный проект: ' + (e?.message || e));
+    }
+  }
+
+  function boardKindToDir(kind, name) {
+    if (kind === 'character') return '_characters/' + name;
+    if (kind === 'location')  return '_locations/' + name;
+    return name;            // scene/episode — корень проекта
+  }
+  function joinPath(a, b) { return a ? (a + '/' + b).replace(/\/+/g, '/') : b; }
+
+  async function writeCloudFile(projectId, relPath, data) {
+    if (window.cloudFs) return window.cloudFs.write(projectId, relPath, data);
+    // web fallback — пишем в backend in-memory.
+    // (cloudFsShim сам разруливает; этот path для main loop, не используется напрямую)
+    return false;
+  }
+
+  // -------------- save cloud project (upload changed files) --------------
+  async function saveCloudProject() {
+    const s = await getSettings();
+    if (!isLoggedIn(s)) { alert('Войдите в KingKont'); return; }
+    if (!state.filmHandle) return;
+
+    // Если это папочный (не cloud) проект — спросим имя и создадим новый
+    // cloud-проект. Это ответ на «Любой проект (в том числе тот что создан
+    // в папке) нужно уметь сохранить на сервер».
+    const isCloud = !!state.cloudProjectId;
+    let projectId = state.cloudProjectId;
+    let projectName = state.filmHandle.name;
+    if (!isCloud) {
+      // window.prompt() в Electron подавлен — askName из board.js.
+      const proposed = await askName('Сохранить проект на сервер. Название:', '', state.filmHandle.name);
+      if (!proposed || !proposed.trim()) return;
+      projectName = proposed.trim();
+      // Создаём пустую запись.
+      const r = await fetch('/api/projects', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: projectName, manifest: { boards: [] }, files: {} }),
+      });
+      if (!r.ok) {
+        const err = await r.json().catch(() => ({}));
+        alert('Не удалось создать запись: ' + (err.error || r.status));
+        return;
+      }
+      const created = await r.json();
+      projectId = created.id;
+      state.cloudProjectId = projectId;
+    }
+
+    PROGRESS.show('Сбор данных проекта…');
+    try {
+      // Читаем .kingkont-meta.json — там лежат хеши (size+mtime) → cdnUrl
+      // для всех ранее загруженных файлов. Используем для dedup'а — не
+      // перезаливаем неизменённые файлы.
+      const meta = (typeof readProjectMeta === 'function')
+        ? (await readProjectMeta(state.filmHandle)) || {}
+        : {};
+      const oldHashes = meta.fileHashes || {};
+      const newHashes = {};
+
+      // 1) Собираем все board'ы локального проекта (та же логика что у
+      //    saveCurrentProjectAsTemplate из templates.js).
+      const allBoards = await collectProjectBoards(state.filmHandle);
+      const manifestBoards = [];
+      const allFilesIndex = {};
+      let total = allBoards.reduce((s, b) => s + b.mediaFiles.length, 0);
+      let uploaded = 0;
+      let reused = 0;
+
+      for (const board of allBoards) {
+        const sceneFile = await board.handle.getFileHandle('scene.json').catch(() => null);
+        let scene = {};
+        if (sceneFile) {
+          const text = await (await sceneFile.getFile()).text();
+          try { scene = JSON.parse(text); } catch {}
+        }
+        const boardFiles = {};
+        // walkBoardFiles возвращает {relPath, fileHandle}.
+        for (const f of board.mediaFiles) {
+          if (!f.fileHandle) {
+            console.warn('skip file without fileHandle:', f);
+            continue;
+          }
+          const file = await f.fileHandle.getFile();
+          const metaKey = `${board.kind}/${board.name}/${f.relPath}`;
+          const cached = oldHashes[metaKey];
+          // Dedup: size + mtime совпадают → переиспользуем CDN-URL.
+          // (Это identifier «файл не менялся с момента последней синхронизации»;
+          //  неважно загружали мы его сами или скачали при openCloudProject.)
+          if (cached && cached.size === file.size && cached.mtime === file.lastModified) {
+            boardFiles[f.relPath] = cached.url;
+            allFilesIndex[metaKey] = cached.url;
+            newHashes[metaKey] = cached;
+            reused++;
+            uploaded++;
+            PROGRESS.update(uploaded, total,
+              `[${board.kind}/${board.name}] ${f.relPath} (cached, ${uploaded}/${total})`);
+            continue;
+          }
+          PROGRESS.update(uploaded, total,
+            `[${board.kind}/${board.name}] ${f.relPath} (${uploaded + 1}/${total})`);
+          const r = await fetch('/api/upload', {
+            method: 'POST',
+            headers: {
+              'Content-Type': file.type || 'application/octet-stream',
+              'X-File-Name': encodeURIComponent(f.relPath.split('/').pop()),
+            },
+            body: await file.arrayBuffer(),
+          });
+          if (!r.ok) throw new Error(`upload ${f.relPath} failed: ${r.status}`);
+          const j = await r.json();
+          boardFiles[f.relPath] = j.url;
+          allFilesIndex[metaKey] = j.url;
+          newHashes[metaKey] = { url: j.url, size: file.size, mtime: file.lastModified };
+          uploaded++;
+        }
+        manifestBoards.push({ kind: board.kind, name: board.name, scene, files: boardFiles });
+      }
+
+      // 2) Cover (dedup'нутый — не грузим если size+mtime совпадают).
+      // meta.coverHash = { size, mtime, url } сохраняется после каждого upload'а.
+      let coverUrl = meta.coverUrl || null;
+      let newCoverHash = meta.coverHash || null;
+      if (typeof readProjectCover === 'function') {
+        const coverBlob = await readProjectCover(state.filmHandle);
+        if (coverBlob) {
+          const ch = meta.coverHash;
+          if (ch && ch.size === coverBlob.size && ch.mtime === coverBlob.lastModified && ch.url) {
+            // Cover не менялся — переиспользуем CDN-URL.
+            coverUrl = ch.url;
+            PROGRESS.update(uploaded, total, 'Обложка не менялась (cached)');
+          } else {
+            PROGRESS.update(uploaded, total, 'Загрузка обложки…');
+            const r = await fetch('/api/upload', {
+              method: 'POST',
+              headers: {
+                'Content-Type': coverBlob.type || 'application/octet-stream',
+                'X-File-Name': encodeURIComponent('cover.' + (coverBlob.type?.split('/')[1] || 'jpg')),
+              },
+              body: await coverBlob.arrayBuffer(),
+            });
+            if (r.ok) {
+              const { url } = await r.json();
+              coverUrl = url;
+              newCoverHash = { size: coverBlob.size, mtime: coverBlob.lastModified, url };
+            }
+          }
+        }
+      }
+
+      // 3) Update server record.
+      PROGRESS.update(uploaded, total, 'Сохранение на сервере…');
+      const updateR = await fetch('/api/projects/' + encodeURIComponent(projectId), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name: projectName,
+          manifest: { boards: manifestBoards },
+          files: allFilesIndex,
+          coverUrl: coverUrl || '',
+        }),
+      });
+      if (!updateR.ok) {
+        const err = await updateR.json().catch(() => ({}));
+        throw new Error(err.error || `HTTP ${updateR.status}`);
+      }
+
+      // 4) Перезаписать meta с обновлёнными хешами для следующего save'а.
+      if (typeof writeProjectMeta === 'function') {
+        await writeProjectMeta(state.filmHandle, {
+          ...meta,
+          cloudProjectId: projectId,
+          fileHashes: newHashes,
+          coverUrl: coverUrl || null,
+          coverHash: newCoverHash,
+          syncedAt: Date.now(),
+        });
+      }
+
+      PROGRESS.hide();
+      markClean();
+      const stats = reused
+        ? `${uploaded - reused} новых, ${reused} переиспользованы`
+        : `${uploaded} файлов`;
+      alert(`Проект «${projectName}» сохранён (${stats}).`);
+    } catch (e) {
+      PROGRESS.hide();
+      alert('Ошибка сохранения: ' + (e?.message || e));
+    }
+  }
+
+  // -------------- list modal --------------
+  async function openCloudProjectsModal() {
+    const s = await getSettings();
+    if (!isLoggedIn(s)) { alert('Войдите в KingKont'); return; }
+    // Переиспользуем templatesModal — но рисуем туда список проектов вместо
+    // шаблонов. Подсказываем что это другой контент.
+    const modal = $('templatesModal');
+    if (!modal) return;
+    modal.classList.remove('hidden');
+    // Скрываем кнопку «＋ Проект» (она для шаблонов), показываем нашу.
+    const tplSaveProj = $('tplSaveProject');
+    if (tplSaveProj) tplSaveProj.style.display = 'none';
+    const list = $('tplList');
+    list.innerHTML = '<div style="padding:24px; text-align:center; color:#888;">Загрузка…</div>';
+    try {
+      const r = await fetch('/api/projects');
+      if (!r.ok) {
+        const err = await r.json().catch(() => ({}));
+        throw new Error(err.error || `HTTP ${r.status}`);
+      }
+      const items = await r.json();
+      list.innerHTML = '';
+      if (!items.length) {
+        list.innerHTML = '<div style="padding:24px; text-align:center; color:#888;">Облачных проектов пока нет. Создай новый кнопкой «☁ Новый проект (облако)».</div>';
+        return;
+      }
+      for (const p of items) {
+        const card = document.createElement('div');
+        card.style.cssText = 'display:flex; gap:12px; align-items:center; padding:10px 12px; background:#1a1a1a; border:1px solid #333; border-radius:6px;';
+        const cover = document.createElement('div');
+        cover.style.cssText = 'width:80px; height:60px; flex-shrink:0; border-radius:4px; background:#0e0e0e; border:1px solid #2a2a2a; overflow:hidden; display:flex; align-items:center; justify-content:center; color:#444; font-size:24px;';
+        if (p.coverUrl) {
+          const img = document.createElement('img');
+          img.style.cssText = 'width:100%; height:100%; object-fit:cover;';
+          img.src = '/api/proxy?url=' + encodeURIComponent(p.coverUrl);
+          img.draggable = false;
+          img.onerror = () => { cover.textContent = '🎬'; };
+          cover.appendChild(img);
+        } else cover.textContent = '🎬';
+        card.appendChild(cover);
+
+        const info = document.createElement('div');
+        info.style.cssText = 'flex:1; min-width:0;';
+        const title = document.createElement('div');
+        title.style.cssText = 'font-size:14px; color:#e0e0e0; font-weight:500; word-break:break-word;';
+        title.textContent = p.name || '(без названия)';
+        const meta = document.createElement('div');
+        meta.style.cssText = 'font-size:11px; color:#888; margin-top:4px;';
+        meta.textContent = [
+          p.boardCount ? `${p.boardCount} board(s)` : null,
+          p.fileCount ? `${p.fileCount} файлов` : null,
+          p.updatedAt ? 'обновлён ' + new Date(p.updatedAt).toLocaleString('ru-RU') : null,
+        ].filter(Boolean).join(' · ');
+        info.append(title, meta);
+
+        const openBtn = document.createElement('button');
+        openBtn.className = 'primary';
+        openBtn.textContent = 'Открыть';
+        openBtn.addEventListener('click', () => {
+          modal.classList.add('hidden');
+          openCloudProject(p.id, p.name);
+        });
+        const delBtn = document.createElement('button');
+        delBtn.className = 'danger';
+        delBtn.textContent = '🗑';
+        delBtn.title = 'Удалить (только серверная копия, локальный кэш можно очистить вручную)';
+        delBtn.addEventListener('click', async () => {
+          if (!confirm(`Удалить «${p.name}» с сервера? Локальная копия в userData останется.`)) return;
+          try {
+            const dr = await fetch('/api/projects/' + encodeURIComponent(p.id), { method: 'DELETE' });
+            if (!dr.ok) throw new Error('HTTP ' + dr.status);
+            openCloudProjectsModal();           // refresh
+          } catch (e) { alert('Не удалось удалить: ' + (e?.message || e)); }
+        });
+
+        card.append(info, openBtn, delBtn);
+        list.appendChild(card);
+      }
+    } catch (e) {
+      list.innerHTML = `<div style="padding:24px; text-align:center; color:#f88;">Ошибка: ${e.message}</div>`;
+    }
+  }
+
+  // -------------- wire buttons --------------
+  document.addEventListener('DOMContentLoaded', () => {
+    $('newCloudProject')?.addEventListener('click', createNewCloudProject);
+    $('openCloudProjects')?.addEventListener('click', openCloudProjectsModal);
+    $('saveProjectCloud')?.addEventListener('click', saveCloudProject);
+    setCloudButtonsVisibility();
+    // Переинициализируем видимость кнопок раз в 5 сек — для случая когда юзер
+    // login/logout в Chatium через настройки (нет других сигналов).
+    setInterval(setCloudButtonsVisibility, 5000);
+  });
+
+  // Вызывается из openFilm / closeProject (через хук в board.js).
+  window.cloudProjects = {
+    setVisibility: setCloudButtonsVisibility,
+    markDirty,
+    markClean,
+    createNew: createNewCloudProject,
+    open: openCloudProject,
+    save: saveCloudProject,
+    openListModal: openCloudProjectsModal,
+    // Для welcome-grid'а: cached список + onChange-подписка.
+    fetchListCached,
+    onListChange,
+    readCache,
+  };
+})();

package/renderer/generate.js

@@ -1836,6 +1836,13 @@ async function startGenerationJob(node, kind, prompt, mediaRefs, boardHandle, bK
       logJob(node.id, `generate ERROR: ${data.error || rawText.slice(0,200)}`);
       throw new Error(data.error || `HTTP ${r.status}: ${rawText.slice(0,200)}`);
     }
+    // Защита от bug'а где провайдер вернул success без taskId:
+    // дальше pollJob будет дёргать /api/poll?taskId=undefined → KIE
+    // ответит «task id is blank», запутывая логи. Лучше fail сразу.
+    if (!data.taskId) {
+      logJob(node.id, `generate ERROR: провайдер вернул пустой taskId. Тело: ${rawText.slice(0,300)}`);
+      throw new Error('Провайдер не вернул taskId. Проверь модель/параметры (см. лог).');
+    }
     job.taskId = data.taskId;
     logJob(node.id, `taskId=${data.taskId}`);
     await mutateNode(bKey, boardHandle, node.id, n => {