kingkont 0.13.0 → 0.14.0

package/lib/chatSession.js

@@ -0,0 +1,310 @@
+// lib/chatSession.js — Server-side chat sessions для KingKont.
+//
+// Каждая сессия привязана к проекту (sessionKey = projectKey клиента,
+// например "cloud:abc123" или "folder:Сериал-вживую"). Хранит:
+//   - history: [{role, content, tools?}]
+//   - busy:    true пока крутится LLM-loop
+//   - pendingToolCalls: [{name, args, id}] — то что Claude хочет запустить;
+//                        клиент исполняет → posts results → loop продолжается
+//   - lastError: строка ошибки если loop упал
+//
+// Lifecycle:
+//   1. Клиент: POST /api/chat/send {sessionKey, text, system, context}
+//      → серверный send() пушит user-msg, стартует LLM-loop в фоне.
+//   2. Loop ждёт ответ от LLM. Парсит <tool>JSON</tool> блоки.
+//      Если есть → выставляет pendingToolCalls + ставит ожидание results.
+//   3. Клиент поллит GET /api/chat/state?sessionKey=...
+//      Видит pendingToolCalls → исполняет локально (с FSAH доступом!) →
+//      POST /api/chat/tool-results {sessionKey, results}.
+//   4. Loop резюмирует с tool-results, идёт следующая итерация.
+//   5. Когда нет tools → loop останавливается, busy=false.
+//
+// Persistence: на каждое изменение пишем в `<userDataDir>/chats/<key>.json`
+// (debounced). Загружается на первый запрос session'а. Это позволяет
+// чату пережить рестарт Electron.
+//
+// Tools НЕ исполняются на сервере — только пробрасываются клиенту.
+// Это потому что тулы работают с FSAH-handle'ами проекта (renderer-only).
+
+'use strict';
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const MAX_TOOL_ITERATIONS = 12;
+const PERSIST_DEBOUNCE_MS = 800;
+
+// ============== STORAGE ==============
+let _userDataDir = null;   // выставляется через init() из main.js
+function init({ userDataDir }) {
+  _userDataDir = userDataDir;
+  if (_userDataDir) {
+    const dir = path.join(_userDataDir, 'chats');
+    try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  }
+}
+function _sessionFilePath(key) {
+  if (!_userDataDir) return null;
+  // sessionKey может содержать /, : и т.п. — encode через URI.
+  const safe = encodeURIComponent(key);
+  return path.join(_userDataDir, 'chats', safe + '.json');
+}
+async function _persist(session) {
+  if (!_userDataDir) return;
+  const p = _sessionFilePath(session.key);
+  if (!p) return;
+  // Не сохраняем pending state — на restart loop стартанётся заново
+  // (или останется незавершённым — клиент увидит busy=false и предложит
+  //  повторить).
+  const persistable = {
+    key: session.key,
+    history: session.history.filter(m =>
+      m.role !== 'system' &&
+      !(m.role === 'user' && typeof m.content === 'string' && m.content.startsWith('<tool_result>')),
+    ),
+    savedAt: Date.now(),
+  };
+  try {
+    await fsp.writeFile(p, JSON.stringify(persistable, null, 2), 'utf-8');
+  } catch (e) {
+    console.warn('[chatSession] persist failed for', session.key, e?.message);
+  }
+}
+async function _load(key) {
+  if (!_userDataDir) return null;
+  const p = _sessionFilePath(key);
+  if (!p) return null;
+  try {
+    const text = await fsp.readFile(p, 'utf-8');
+    return JSON.parse(text);
+  } catch { return null; }
+}
+
+// ============== SESSIONS ==============
+const SESSIONS = new Map();   // key → Session
+
+function _emptySession(key) {
+  return {
+    key,
+    history: [],          // [{role, content, tools?}]
+    busy: false,
+    pendingToolCalls: null,    // null | [{id, name, args}]
+    pendingResolve: null,      // function(results) — used by loop awaiting
+    lastError: null,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    _persistTimer: null,
+  };
+}
+
+async function getSession(key, { create = true } = {}) {
+  let s = SESSIONS.get(key);
+  if (s) return s;
+  // Try load from disk.
+  const saved = await _load(key);
+  if (saved) {
+    s = _emptySession(key);
+    s.history = Array.isArray(saved.history) ? saved.history : [];
+    SESSIONS.set(key, s);
+    return s;
+  }
+  if (!create) return null;
+  s = _emptySession(key);
+  SESSIONS.set(key, s);
+  return s;
+}
+
+function schedulePersist(session) {
+  clearTimeout(session._persistTimer);
+  session._persistTimer = setTimeout(() => _persist(session), PERSIST_DEBOUNCE_MS);
+}
+
+// ============== TOOL-CALL PARSER ==============
+function parseToolCalls(text) {
+  if (typeof text !== 'string' || !text) return [];
+  const out = [];
+  const re = /<tool>\s*([\s\S]*?)\s*<\/tool>/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    try {
+      const obj = JSON.parse(m[1]);
+      if (obj && typeof obj.name === 'string') {
+        out.push({ id: crypto.randomUUID(), name: obj.name, args: obj.args || {} });
+      }
+    } catch (e) {
+      out.push({ id: crypto.randomUUID(), _parseError: e.message, raw: m[1] });
+    }
+  }
+  return out;
+}
+function stripToolCalls(text) {
+  if (typeof text !== 'string') return '';
+  return text
+    .replace(/<tool>[\s\S]*?<\/tool>/g, '')
+    .replace(/<tool_result>[\s\S]*?<\/tool_result>/g, '')
+    .replace(/[ \t]{2,}/g, ' ')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+// ============== LLM CALL ==============
+// Использует ту же providers.generateText (single-prompt с transcript), что и
+// клиентский код раньше. Передаём messages как готовый transcript-prompt.
+function _historyToPrompt(history) {
+  const lines = [];
+  for (const m of history) {
+    if (m.role === 'system') continue;
+    const role = m.role === 'assistant' ? 'ASSISTANT' : m.role === 'user' ? 'USER' : m.role.toUpperCase();
+    const content = typeof m.content === 'string' ? m.content : '';
+    lines.push(`${role}: ${content}`);
+  }
+  lines.push('ASSISTANT:');
+  return lines.join('\n\n');
+}
+
+async function _callLLM(history, system, settings) {
+  const providers = require('./providers');
+  const prompt = _historyToPrompt(history);
+  const r = await providers.generateText({
+    prompt, system,
+    model: 'anthropic/claude-sonnet-4.6',
+    settings,
+  });
+  return r.text || '';
+}
+
+// ============== LOOP ==============
+// Запускается в фоне после send() / submitToolResults(). Делает один-два
+// (или больше) round-trips к LLM, между ними ждёт tool-results от клиента.
+async function _runLoop(session, system, settingsGetter) {
+  if (session.busy) return;     // уже идёт
+  session.busy = true;
+  session.lastError = null;
+  schedulePersist(session);
+  let iter = 0;
+  try {
+    while (iter < MAX_TOOL_ITERATIONS) {
+      iter++;
+      const text = await _callLLM(session.history, system, settingsGetter());
+      const toolCalls = parseToolCalls(text);
+      const cleanText = stripToolCalls(text);
+      const assistantMsg = { role: 'assistant', content: cleanText, tools: [] };
+      session.history.push(assistantMsg);
+      schedulePersist(session);
+      if (!toolCalls.length) break;     // финальный ответ
+      // Выставляем pendingToolCalls и ЖДЁМ что клиент пришлёт results.
+      // _waitForToolResults возвращает массив {id, ok, result, error}.
+      const results = await _waitForToolResults(session, toolCalls);
+      // Записываем info про tool-вызовы в assistantMsg для UI.
+      for (let i = 0; i < toolCalls.length; i++) {
+        const tc = toolCalls[i];
+        const r = results.find(x => x.id === tc.id) || {};
+        assistantMsg.tools.push({
+          name: tc.name, args: tc.args,
+          _ok: !!r.ok, _error: r.error || tc._parseError, result: r.result,
+        });
+      }
+      schedulePersist(session);
+      // Шлём результаты в LLM как user-msg (Claude видит их в transcript).
+      const resultsMsg = results.map(r => `<tool_result>${JSON.stringify({
+        name: r.name, ok: !!r.ok, result: r.result, error: r.error,
+      })}</tool_result>`).join('\n');
+      session.history.push({ role: 'user', content: resultsMsg });
+    }
+    if (iter >= MAX_TOOL_ITERATIONS) {
+      session.history.push({ role: 'assistant', content: `⚠ Остановлен после ${MAX_TOOL_ITERATIONS} итераций.`, tools: [] });
+    }
+  } catch (e) {
+    console.error('[chatSession] loop error:', e?.stack || e?.message || e);
+    session.lastError = e?.message || String(e);
+    session.history.push({ role: 'assistant', content: `⚠ Ошибка: ${session.lastError}`, tools: [] });
+  } finally {
+    session.busy = false;
+    session.pendingToolCalls = null;
+    session.pendingResolve = null;
+    schedulePersist(session);
+  }
+}
+
+function _waitForToolResults(session, toolCalls) {
+  // Выставляем pending — клиент через GET state увидит, исполнит локально,
+  // вызовет submitToolResults. Тот резолвит promise.
+  return new Promise(resolve => {
+    session.pendingToolCalls = toolCalls;
+    session.pendingResolve = resolve;
+  });
+}
+
+// ============== PUBLIC API ==============
+
+// Снимок состояния для клиента (без internal-полей).
+function snapshot(session) {
+  return {
+    key: session.key,
+    history: session.history,
+    busy: session.busy,
+    pendingToolCalls: session.pendingToolCalls,
+    lastError: session.lastError,
+    updatedAt: session.updatedAt,
+  };
+}
+
+// Push user-msg + start loop. Если loop уже бежит — отказ.
+async function send(key, { text, system, settingsGetter }) {
+  if (!text) throw new Error('text обязателен');
+  const session = await getSession(key);
+  if (session.busy) throw new Error('сессия занята — дождитесь окончания текущего turn');
+  session.history.push({ role: 'user', content: text });
+  session.updatedAt = Date.now();
+  schedulePersist(session);
+  // Запускаем loop в фоне (не await'им).
+  _runLoop(session, system, settingsGetter).catch(e => {
+    console.error('[chatSession] _runLoop unhandled:', e);
+  });
+  return snapshot(session);
+}
+
+// Клиент исполнил pendingToolCalls и шлёт results. Резолвим promise →
+// loop продолжается.
+function submitToolResults(key, results) {
+  const session = SESSIONS.get(key);
+  if (!session) throw new Error('сессия не найдена');
+  if (!session.pendingResolve) throw new Error('нет ожидающих tool-вызовов');
+  const resolve = session.pendingResolve;
+  session.pendingResolve = null;
+  session.pendingToolCalls = null;
+  // Привязываем results к pending-toolCall id'ам — клиент должен прислать
+  // тот же id что мы дали в pendingToolCalls.
+  resolve(results || []);
+  return snapshot(session);
+}
+
+async function clear(key) {
+  const session = SESSIONS.get(key);
+  if (session) {
+    session.history = [];
+    session.lastError = null;
+    schedulePersist(session);
+    return snapshot(session);
+  }
+  // Нет в памяти — создадим пустую и сохраним.
+  const fresh = await getSession(key);
+  fresh.history = [];
+  schedulePersist(fresh);
+  return snapshot(fresh);
+}
+
+async function getState(key) {
+  const session = await getSession(key);
+  return snapshot(session);
+}
+
+module.exports = {
+  init,
+  getState,
+  send,
+  submitToolResults,
+  clear,
+};

package/main.js

@@ -974,7 +974,10 @@ app.whenReady().then(async () => {
   // падаем на random и теряем handle. 8×500мс = 4 сек обычно хватает.
   // server.js на каждый запрос читает live-настройки через getSettings —
   // settings.json на диске единственный источник правды.
-  const startOpts = { getSettings: () => readSettings() };
+  const startOpts = {
+    getSettings: () => readSettings(),
+    userDataDir: app.getPath('userData'),
+  };
   const PRIMARY_PORT = 17893;
   const RETRIES = 8;
   let lastErr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kingkont",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "KingKont · Chatium — нод-редактор сцен с AI-генерацией (картинки/видео/голос/SFX/музыка/текст)",
   "main": "main.js",
   "bin": {
@@ -19,7 +19,8 @@
     "scripts/**/*",
     "skill/**/*",
     "README.md",
-    "updates.html"
+    "updates.html",
+    "web.html"
   ],
   "engines": {
     "node": ">=18"

package/renderer/chat.js

@@ -485,7 +485,21 @@
       await persistNow();
     }
   }
+  // Забираем историю с сервера (server-side state — source of truth).
+  // Если на сервере есть pending tool-loop — сразу стартуем polling.
   async function loadHistoryFromCurrentProject() {
+    const key = sessionKey();
+    if (!key) { history = []; renderHistory(); return; }
+    try {
+      const r = await fetch('/api/chat/state?key=' + encodeURIComponent(key));
+      if (r.ok) {
+        const snap = await r.json();
+        applyServerState(snap);
+        if (snap.busy) startPolling(key);
+        return;
+      }
+    } catch (e) { console.warn('[chat] load from server failed:', e?.message); }
+    // Fallback на legacy disk-loaded — если сервер недоступен (старая версия).
     if (!state.filmHandle) { history = []; renderHistory(); return; }
     try {
       const fh = await state.filmHandle.getFileHandle(CHAT_FILE);
@@ -818,7 +832,8 @@
     list.scrollTop = list.scrollHeight;
   }
 
-  function appendStatus(msg) {
+  // (старый appendStatus — заменён на нижний с поддержкой isError)
+  function _appendStatusOld(msg) {
     const list = $('chatList');
     if (!list) return;
     const div = document.createElement('div');
@@ -894,85 +909,137 @@
     return await def.handler(args || {});
   }
 
+  // Идентификатор сессии чата = projectKey клиента. Передаётся серверу.
+  function sessionKey() {
+    if (state.cloudProjectId) return 'cloud:' + state.cloudProjectId;
+    if (state.filmHandle?.name) return 'folder:' + state.filmHandle.name;
+    return null;
+  }
+
+  // Длинный pollin цикл. Стартует после send(). Опрашивает GET /api/chat/state
+  // каждые 800ms, пока сервер busy=true. Если сервер вернул pendingToolCalls
+  // — исполняет их локально (тут есть FSAH-доступ) и шлёт results через
+  // POST /api/chat/tool-results, после чего сервер продолжает loop.
+  let pollTimer = null;
+  let pollKey = null;
+  async function startPolling(key) {
+    if (pollKey === key && pollTimer) return;
+    stopPolling();
+    pollKey = key;
+    const tick = async () => {
+      if (pollKey !== key) return;
+      try {
+        const r = await fetch('/api/chat/state?key=' + encodeURIComponent(key));
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        const snap = await r.json();
+        // Применяем снимок только если сессия всё ещё активна на клиенте.
+        if (sessionKey() === key) applyServerState(snap);
+        // Если есть pending-tools — исполняем и шлём results (продолжаем
+        // poll сразу, не ждём next tick).
+        if (snap.pendingToolCalls && snap.pendingToolCalls.length) {
+          const results = [];
+          for (const tc of snap.pendingToolCalls) {
+            if (tc._parseError) {
+              results.push({ id: tc.id, name: 'parse_error', ok: false, error: tc._parseError });
+              continue;
+            }
+            try {
+              const r2 = await runTool(tc.name, tc.args);
+              results.push({ id: tc.id, name: tc.name, ok: true, result: r2 });
+            } catch (e) {
+              results.push({ id: tc.id, name: tc.name, ok: false, error: e?.message || String(e) });
+            }
+          }
+          await fetch('/api/chat/tool-results', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ key, results }),
+          }).catch(() => {});
+          // Сразу продолжаем polling без задержки (loop уже резюмирован сервером).
+          if (pollKey === key) pollTimer = setTimeout(tick, 50);
+          return;
+        }
+        if (snap.busy) {
+          if (pollKey === key) pollTimer = setTimeout(tick, 800);
+        } else {
+          // Loop завершён — последняя статус-строка может быть info'й.
+          if (snap.lastError) appendStatus('⚠ ' + snap.lastError, true);
+          stopPolling();
+        }
+      } catch (e) {
+        console.warn('[chat] poll failed:', e?.message);
+        if (pollKey === key) pollTimer = setTimeout(tick, 2000);   // backoff
+      }
+    };
+    tick();
+  }
+  function stopPolling() {
+    clearTimeout(pollTimer);
+    pollTimer = null;
+    pollKey = null;
+  }
+
+  // Сервер прислал snapshot — применяем history к UI.
+  function applyServerState(snap) {
+    if (!snap) return;
+    history = snap.history || [];
+    busy = !!snap.busy;
+    renderHistory();
+    // Statusbar: если сервер думает — поддерживаем placeholder.
+    let statusEl = document.querySelector('#chatList .chat-status:last-child');
+    if (busy) {
+      const txt = (snap.pendingToolCalls?.length)
+        ? `Выполняю ${snap.pendingToolCalls.length} tool(s)…`
+        : 'KingKont думает…';
+      if (!statusEl || !statusEl.classList.contains('chat-status') || statusEl.classList.contains('error')) {
+        statusEl = appendStatus(txt);
+      } else {
+        statusEl.textContent = txt;
+      }
+    } else if (statusEl && !statusEl.classList.contains('error')) {
+      statusEl.remove();
+    }
+  }
+
   async function send(userText) {
-    if (busy) return;
     if (!userText.trim()) return;
-    busy = true;
-    // Snapshot ДО мутации — чтобы юзер мог откатить «всё что чат сделал
-    // в ответ на это сообщение». Шортнем label первыми 60 символами user-msg.
+    const key = sessionKey();
+    if (!key) { alert('Сначала открой проект'); return; }
+    // Snapshot ДО мутации — клиентский (для отката чат-действий).
     try {
       await takeSnapshot(userText.length > 60 ? userText.slice(0, 60) + '…' : userText);
     } catch (e) { console.warn('snapshot failed:', e?.message); }
-    history.push({ role: 'user', content: userText });
-    renderHistory();
-    persistDebounced();
-    const status = appendStatus('KingKont думает…');
-    // Привязываем context-snapshot НА МОМЕНТ send: текущая сцена,
-    // выделенные ноды, прикреплённые файлы. Передаётся в system-prompt
-    // дополнительным блоком — модель видит что у юзера сейчас в фокусе.
+    // Контекст + system-prompt: формируем тут (на клиенте) и отдаём серверу.
     const ctxSnap = buildContextSnapshot();
     const system = buildSystemPrompt() + '\n\n' + buildContextBlock(ctxSnap);
+    appendStatus('KingKont думает…');
     try {
-      let iter = 0;
-      while (iter < MAX_TOOL_ITERATIONS) {
-        iter++;
-        const text = await callLLM(historyToMessages(), system);
-        const toolCalls = parseToolCalls(text);
-        const cleanText = stripToolCalls(text);
-        const assistantMsg = {
-          role: 'assistant',
-          content: cleanText,
-          tools: [],
-        };
-        history.push(assistantMsg);
-
-        if (!toolCalls.length) {
-          // Финальный ответ — больше нечего исполнять.
-          status.remove();
-          renderHistory();
-          persistDebounced();
-          break;
-        }
-
-        // Исполняем tools, собираем результаты.
-        status.textContent = `Выполняю ${toolCalls.length} tool(s)…`;
-        const results = [];
-        for (const tc of toolCalls) {
-          if (tc._parseError) {
-            results.push({ name: 'parse_error', error: tc._parseError, raw: tc.raw });
-            assistantMsg.tools.push({ name: 'parse_error', _error: tc._parseError });
-            continue;
-          }
-          try {
-            const r = await runTool(tc.name, tc.args);
-            results.push({ name: tc.name, ok: true, result: r });
-            assistantMsg.tools.push({ name: tc.name, args: tc.args, result: r, _ok: true });
-          } catch (e) {
-            results.push({ name: tc.name, ok: false, error: e?.message || String(e) });
-            assistantMsg.tools.push({ name: tc.name, args: tc.args, _error: e?.message || String(e) });
-          }
-        }
-        renderHistory();
-        persistDebounced();   // assistant-турн с tool-вызовами уже частично готов
-
-        // Шлём результаты обратно как user-message (чтобы Claude увидел и продолжил).
-        const resultsMsg = results.map(r => `<tool_result>${JSON.stringify(r)}</tool_result>`).join('\n');
-        history.push({ role: 'user', content: resultsMsg });
-        // Не рендерим этот системный turn (renderHistory его отфильтровывает) —
-        // на самом деле он role='user', придётся скрыть руками. Делаем простую
-        // эвристику: если content начинается с <tool_result>, не показываем.
-        // Тут же — это можно сделать через флаг.
-      }
-      if (iter >= MAX_TOOL_ITERATIONS) {
-        appendStatus(`⚠ остановился после ${MAX_TOOL_ITERATIONS} итераций`);
+      const r = await fetch('/api/chat/send', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ key, text: userText, system }),
+      });
+      if (!r.ok) {
+        const err = await r.json().catch(() => ({}));
+        throw new Error(err.error || 'HTTP ' + r.status);
       }
+      const snap = await r.json();
+      applyServerState(snap);
+      startPolling(key);
     } catch (e) {
-      status.textContent = '⚠ ' + (e?.message || e);
-      status.classList.add('error');
-    } finally {
-      busy = false;
+      appendStatus('⚠ ' + (e?.message || e), true);
     }
   }
+  function appendStatus(text, isError) {
+    const list = $('chatList');
+    if (!list) return null;
+    const div = document.createElement('div');
+    div.className = 'chat-status' + (isError ? ' error' : '');
+    div.textContent = text;
+    list.appendChild(div);
+    list.scrollTop = list.scrollHeight;
+    return div;
+  }
 
   // Скрываем tool_result-сообщения из UI (они нужны только модели).
   // renderHistory вызывает renderHistory — оставлю как есть, плюс добавлю
@@ -1180,13 +1247,25 @@
     open: () => { ensureUI(); $('chatPanel').classList.remove('hidden'); setTimeout(() => $('chatInput')?.focus(), 50); },
     close: () => $('chatPanel')?.classList.add('hidden'),
     send,
-    // User-clear: чистит И на диске тоже (юзер явно нажал ⌫).
-    clear: () => { history = []; snapshots = []; renderHistory(); renderSnapshotBar(); persistNow().catch(() => {}); },
-    // Reset-on-close: ФЛАШИМ pending-дебаунс В ТЕКУЩИЙ filmHandle (чтобы
-    // история не утекла в следующий проект), потом чистим in-memory.
-    // На диске история того проекта остаётся — re-open подгрузит.
+    // User-clear: стираем И на сервере (юзер явно нажал ⌫).
+    clear: async () => {
+      const key = sessionKey();
+      if (key) {
+        try {
+          await fetch('/api/chat/clear', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ key }),
+          });
+        } catch {}
+      }
+      history = []; snapshots = [];
+      renderHistory(); renderSnapshotBar();
+    },
+    // Reset-on-close: останавливаем polling, чистим UI. История на сервере
+    // остаётся (server-side persistence). re-open того же проекта подгрузит.
     resetInMemory: async () => {
-      try { await flushPersist(); } catch {}
+      stopPolling();
       history = []; snapshots = [];
       renderHistory(); renderSnapshotBar();
     },

package/renderer/media.js

@@ -14,31 +14,59 @@ const _canvasFrame = $('canvasFrame');
 // layout-affecting свойство, его смена на каждом wheel-tick форсила 751ms Layout.
 // Транформ на canvas идёт через GPU (will-change: transform → composited),
 // scroll-bounds во время burst могут быть слегка off, на idle подстраиваются.
+// Канвас-frame теперь с padding'ом вокруг .canvas (см. styles.css
+// .canvas-frame --canvas-pad-x/y). Координаты:
+//   - frame-coords: 0..(6000*z + 2*padX). Лево-верх frame = (0,0).
+//   - canvas-coords: 0..6000 (до scale). Канвас расположен в frame'е
+//     по offset (padX, padY) и масштабирован transform: scale(z).
+//   - mouseInFrame = scrollLeft + (mouseClient - wrapClient)
+//   - contentCoord = (mouseInFrame - padX) / z
+function _getFramePadding() {
+  const cs = getComputedStyle(_canvasFrame);
+  return {
+    padX: parseInt(cs.getPropertyValue('--canvas-pad-x')) || 0,
+    padY: parseInt(cs.getPropertyValue('--canvas-pad-y')) || 0,
+  };
+}
 let _frameSizeTimer = null;
 function applyZoomStyles(z) {
   canvas.style.transform = `scale(${z})`;
   clearTimeout(_frameSizeTimer);
   _frameSizeTimer = setTimeout(() => {
     _frameSizeTimer = null;
-    _canvasFrame.style.width  = (6000 * z) + 'px';
-    _canvasFrame.style.height = (4000 * z) + 'px';
+    const { padX, padY } = _getFramePadding();
+    // Frame-размер = scaled-canvas + padding с обеих сторон.
+    // Раньше padding не учитывался → frame ужимался при zoom-out → весь
+    // padding-skill терялся, ноды с отрицательными coord'ами становились
+    // неперехватываемыми скроллом.
+    _canvasFrame.style.width  = (6000 * z + 2 * padX) + 'px';
+    _canvasFrame.style.height = (4000 * z + 2 * padY) + 'px';
   }, 200);
 }
 function applyZoom(nextZoom, anchorClientX, anchorClientY) {
   nextZoom = Math.max(ZOOM_MIN, Math.min(ZOOM_MAX, nextZoom));
   if (nextZoom === state.zoom) return;
   const rect = canvasWrap.getBoundingClientRect();
-  // Если якорь не задан — берём центр видимой области
+  const { padX, padY } = _getFramePadding();
+  // Якорь = mouse client coord (или центр если не задан).
   const ax = anchorClientX ?? (rect.left + rect.width / 2);
   const ay = anchorClientY ?? (rect.top + rect.height / 2);
-  const visualX = canvasWrap.scrollLeft + (ax - rect.left);
-  const visualY = canvasWrap.scrollTop  + (ay - rect.top);
-  const contentX = visualX / state.zoom;
-  const contentY = visualY / state.zoom;
+  // mouse внутри wrap (без учёта scroll).
+  const mouseWrapX = ax - rect.left;
+  const mouseWrapY = ay - rect.top;
+  // mouse в frame-coords (со scroll).
+  const mouseFrameX = canvasWrap.scrollLeft + mouseWrapX;
+  const mouseFrameY = canvasWrap.scrollTop  + mouseWrapY;
+  // mouse в canvas content-coords (вычитаем padding и делим на zoom).
+  const contentX = (mouseFrameX - padX) / state.zoom;
+  const contentY = (mouseFrameY - padY) / state.zoom;
   state.zoom = nextZoom;
   applyZoomStyles(nextZoom);
-  canvasWrap.scrollLeft = contentX * nextZoom - (ax - rect.left);
-  canvasWrap.scrollTop  = contentY * nextZoom - (ay - rect.top);
+  // После нового zoom: contentCoord должен оказаться там же где был курсор.
+  // newMouseFrame = contentCoord * nextZoom + padX
+  // newScrollLeft = newMouseFrame - mouseWrapX
+  canvasWrap.scrollLeft = contentX * nextZoom + padX - mouseWrapX;
+  canvasWrap.scrollTop  = contentY * nextZoom + padY - mouseWrapY;
   $('zoomLabel').textContent = Math.round(nextZoom * 100) + '%';
   scheduleViewSave();
 }

package/server.js

@@ -13,6 +13,7 @@ const { readFileSync, existsSync } = require('node:fs');
 const { extname, join, normalize, resolve } = require('node:path');
 
 const providers = require('./lib/providers');
+const chatSession = require('./lib/chatSession');
 
 // ---------- .env loader (без зависимостей) ----------
 function loadEnv() {
@@ -299,6 +300,51 @@ async function handleProjectDelete(res, id) {
   } catch (e) { sendError(res, e, 502); }
 }
 
+// =============================================================================
+// Chat sessions: server-side LLM-loop с tool-pump pattern.
+// Клиент:  POST /api/chat/send {key, text, system}  → starts loop
+//          GET  /api/chat/state?key=...             → poll for state/pendingTools
+//          POST /api/chat/tool-results {key, results} → continue loop
+//          POST /api/chat/clear {key}
+// Tools исполняются НА КЛИЕНТЕ (FSAH-доступ), сервер только пробрасывает.
+// =============================================================================
+async function handleChatSend(req, res) {
+  try {
+    const body = await readJson(req);
+    const { key, text, system } = body || {};
+    if (!key) return send(res, 400, { error: 'key обязателен' });
+    if (!text) return send(res, 400, { error: 'text обязателен' });
+    const snap = await chatSession.send(key, { text, system, settingsGetter: getSettings });
+    send(res, 200, snap);
+  } catch (e) { sendError(res, e, 500); }
+}
+async function handleChatState(res, url) {
+  try {
+    const key = url.searchParams.get('key');
+    if (!key) return send(res, 400, { error: 'key обязателен' });
+    const snap = await chatSession.getState(key);
+    send(res, 200, snap);
+  } catch (e) { sendError(res, e, 500); }
+}
+async function handleChatToolResults(req, res) {
+  try {
+    const body = await readJson(req);
+    const { key, results } = body || {};
+    if (!key) return send(res, 400, { error: 'key обязателен' });
+    const snap = chatSession.submitToolResults(key, results);
+    send(res, 200, snap);
+  } catch (e) { sendError(res, e, 500); }
+}
+async function handleChatClear(req, res) {
+  try {
+    const body = await readJson(req);
+    const { key } = body || {};
+    if (!key) return send(res, 400, { error: 'key обязателен' });
+    const snap = await chatSession.clear(key);
+    send(res, 200, snap);
+  } catch (e) { sendError(res, e, 500); }
+}
+
 // =============================================================================
 // Static files (renderer assets).
 // =============================================================================
@@ -348,6 +394,11 @@ const server = createServer(async (req, res) => {
         if (req.method === 'DELETE') return handleTemplateDelete(res, decodeURIComponent(m[1]));
       }
     }
+    // Chat routes (server-side LLM loop, tools исполняются на клиенте).
+    if (req.method === 'POST' && url.pathname === '/api/chat/send')         return handleChatSend(req, res);
+    if (req.method === 'GET'  && url.pathname === '/api/chat/state')        return handleChatState(res, url);
+    if (req.method === 'POST' && url.pathname === '/api/chat/tool-results') return handleChatToolResults(req, res);
+    if (req.method === 'POST' && url.pathname === '/api/chat/clear')        return handleChatClear(req, res);
     // Cloud-projects routes — зеркало templates, но для редактируемых проектов.
     if (req.method === 'GET'  && url.pathname === '/api/projects')     return handleProjectsList(res);
     if (req.method === 'POST' && url.pathname === '/api/projects')     return handleProjectCreate(req, res);
@@ -372,6 +423,9 @@ process.on('uncaughtException',  (err) => console.error('[uncaughtException]', e
 
 function start(port = PORT, opts = {}) {
   if (typeof opts.getSettings === 'function') getSettings = opts.getSettings;
+  // Init chatSession с userDataDir для персистентности историй.
+  // Без opts.userDataDir чат живёт только in-memory (CLI-режим).
+  chatSession.init({ userDataDir: opts.userDataDir || null });
   return new Promise((resolveOk, reject) => {
     server.once('error', reject);
     server.listen(port, () => {

package/web.html

@@ -0,0 +1,105 @@
+<!DOCTYPE html>
+<!--
+  KingKont — web-shell (без FS Access API).
+  =========================================
+
+  Это вход для веб-версии. Отличается от index.html только тем что:
+    1. Вначале выставляет window.__KINGKONT_WEB__ = true.
+    2. После загрузки index.html-разметки прячет кнопки которые требуют
+       реальной FS-Access (#pickRoot и любые «Открыть папку…»).
+    3. В renderer/cloudFs.js fallback на in-memory backend срабатывает
+       автоматически — preload не подгружен, window.cloudFs undefined.
+
+  Способы попасть сюда:
+    - локально: `node server.js` → http://localhost:8000/web.html
+    - чуть позже задеплоится отдельно как иной endpoint (когда будет готов).
+
+  ВАЖНО: всю работу с проектом веб-версия ведёт через cloud-projects.
+  Папочные проекты (через showDirectoryPicker) в вебе не поддерживаются.
+-->
+<html lang="ru">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>KingKont (web)</title>
+<link rel="stylesheet" href="renderer/styles.css">
+<style>
+  /* Web-mode: прячем кнопки которые завязаны на FS Access API. */
+  body.web-mode #pickRoot,
+  body.web-mode #welcomeOpen,
+  body.web-mode .web-hide { display: none !important; }
+  /* Подсказку добавляем в шапку — что это web-вариант. */
+  body.web-mode .brand-version::after {
+    content: ' · web';
+    color: #ff9d6e;
+    margin-left: 4px;
+  }
+</style>
+<script>
+  // Маркер до загрузки прочих скриптов: cloudFs.js / cloudProjects.js
+  // могут проверить window.__KINGKONT_WEB__ для развилок.
+  window.__KINGKONT_WEB__ = true;
+</script>
+</head>
+<body class="web-mode">
+<!--
+  ВНИМАНИЕ: разметка ниже скопирована из index.html. Чтобы не плодить дубликат
+  при изменениях, держи их синхронизированными ИЛИ вынеси разметку в общий
+  partial. Сейчас минимальный shell — без копирования всех модалок: их можно
+  включить позже когда веб-режим будет покрывать больше сценариев.
+
+  TODO для следующих итераций:
+    - вынести `<aside class="sidebar">` и `<main class="canvas">` в common partial
+    - проверить что generate.js работает без window.appSettings (он делает
+      `window.appSettings.get()` для useChatium-флагов; на вебе нужно либо
+      mock'ать через server.js endpoint, либо хранить в localStorage).
+    - аудио/видео-плейбек таймлайна должен работать с blob-URL'ами от
+      in-memory cloud-handle'ов (cloudFs.js делает Blob через .getFile()).
+-->
+<div style="padding:60px; text-align:center; max-width:600px; margin:auto; color:#bbb; font-family:sans-serif;">
+  <h1 style="color:#fff; margin-bottom:16px;">KingKont · web</h1>
+  <p style="margin-bottom:24px;">Веб-версия в разработке. Сейчас доступно:</p>
+  <ul style="text-align:left; max-width:400px; margin:0 auto 24px; line-height:1.8;">
+    <li>создание облачного проекта (server-side)</li>
+    <li>редактирование в браузере (in-memory)</li>
+    <li>сохранение на сервер по кнопке</li>
+  </ul>
+  <p style="font-size:13px; opacity:0.7;">
+    Для полноценной работы открой Electron-приложение:<br>
+    <code style="background:#222; padding:2px 6px; border-radius:3px;">npx kingkont</code>
+  </p>
+  <hr style="margin:32px 0; border:none; border-top:1px solid #333;">
+  <p style="font-size:12px; opacity:0.6;">
+    Чтобы открыть полную web-версию (с canvas), <a href="/index.html" style="color:#7ab;">перейди на /index.html</a>
+    — там работает FS Access API в Chrome (можно открыть папку проекта).<br>
+    Эта страница (web.html) — заготовка для будущего билда без FS-API.
+  </p>
+</div>
+
+<script>
+  // Заглушки для главных API окружения, которых нет в web (приходят из
+  // preload в Electron). Renderer-модули проверяют наличие через optional
+  // chaining (window.appSettings?.get etc) — undefined → они просто не
+  // дёргают эти ручки.
+  if (!window.appSettings) {
+    window.appSettings = {
+      // На вебе settings храним в localStorage (минимально нужны useChatium
+      // и chatium.token — иначе cloud-projects кнопки не покажутся).
+      // Token придётся ввести вручную пока не сделан web-OAuth.
+      get: async () => {
+        try { return JSON.parse(localStorage.getItem('webSettings') || '{}'); }
+        catch { return {}; }
+      },
+      save: async (partial) => {
+        const cur = JSON.parse(localStorage.getItem('webSettings') || '{}');
+        const next = { ...cur, ...partial };
+        localStorage.setItem('webSettings', JSON.stringify(next));
+        return next;
+      },
+    };
+  }
+  if (!window.appProject) window.appProject = { notifyState: () => {} };
+  if (!window.appInfo)    window.appInfo    = { version: async () => 'web' };
+</script>
+</body>
+</html>