1384 lines
63 KiB
JavaScript
Executable File
1384 lines
63 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
|
|
import { spawn } from 'node:child_process'
|
|
import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
|
|
import { existsSync } from 'node:fs'
|
|
import net from 'node:net'
|
|
import os from 'node:os'
|
|
import path from 'node:path'
|
|
|
|
const ROOT = path.resolve(new URL('..', import.meta.url).pathname)
|
|
const FRONTEND = path.join(ROOT, 'frontend')
|
|
const OUT_DIR = process.env.GUI_SMOKE_OUT || path.join(os.tmpdir(), 'verstak-gui-smoke')
|
|
const CHROMIUM = process.env.CHROMIUM_BIN || findChromium()
|
|
const HOST = '127.0.0.1'
|
|
|
|
const flowUnderTest = 'app loads -> first meaningful screen renders -> primary visible controls respond and mutate UI state without runtime errors.'
|
|
|
|
if (!CHROMIUM) {
|
|
fail('Chromium executable not found. Set CHROMIUM_BIN or install chromium.')
|
|
}
|
|
if (!existsSync(path.join(FRONTEND, 'dist', 'index.html'))) {
|
|
fail('frontend/dist is missing. Run npm run build before GUI render smoke.')
|
|
}
|
|
|
|
const processes = []
|
|
let browser = null
|
|
let preview = null
|
|
|
|
process.on('SIGINT', async () => {
|
|
await cleanup()
|
|
process.exit(130)
|
|
})
|
|
process.on('SIGTERM', async () => {
|
|
await cleanup()
|
|
process.exit(143)
|
|
})
|
|
|
|
async function main() {
|
|
console.log('=== GUI render smoke ===')
|
|
console.log(`Flow under test: ${flowUnderTest}`)
|
|
console.log(`Browser plugin not available; using local Chromium/CDP: ${CHROMIUM}`)
|
|
|
|
await rm(OUT_DIR, { recursive: true, force: true })
|
|
await mkdir(OUT_DIR, { recursive: true })
|
|
|
|
const previewPort = await freePort()
|
|
const cdpPort = await freePort()
|
|
preview = await startPreview(previewPort)
|
|
const baseUrl = `http://${HOST}:${previewPort}`
|
|
await waitForHttp(baseUrl, 15000)
|
|
|
|
browser = await startChromium(cdpPort)
|
|
const cdp = await openPage(cdpPort)
|
|
await cdp.send('Page.enable')
|
|
await cdp.send('Runtime.enable')
|
|
await cdp.send('Log.enable')
|
|
|
|
const consoleIssues = []
|
|
cdp.on('Runtime.consoleAPICalled', (event) => {
|
|
if (['error', 'warning', 'assert'].includes(event.type)) {
|
|
const text = (event.args || []).map((arg) => arg.value ?? arg.description ?? '').join(' ')
|
|
consoleIssues.push({ type: event.type, text })
|
|
}
|
|
})
|
|
cdp.on('Runtime.exceptionThrown', (event) => {
|
|
consoleIssues.push({ type: 'exception', text: event.exceptionDetails?.text || 'Runtime exception' })
|
|
})
|
|
cdp.on('Log.entryAdded', (event) => {
|
|
const entry = event.entry || {}
|
|
if (['error', 'warning'].includes(entry.level)) {
|
|
consoleIssues.push({ type: entry.level, text: entry.text || '' })
|
|
}
|
|
})
|
|
|
|
await cdp.send('Page.addScriptToEvaluateOnNewDocument', { source: wailsMockSource() })
|
|
|
|
await runStartupScenario(cdp, `${baseUrl}/?smokeMode=first_run`, 'first-run', '.first-run-screen')
|
|
await runStartupScenario(cdp, `${baseUrl}/?smokeMode=recovery`, 'recovery', '.recovery-screen')
|
|
await runReadyScenario(cdp, `${baseUrl}/?smokeMode=ready`)
|
|
|
|
const relevantIssues = consoleIssues.filter((issue) => {
|
|
const text = issue.text || ''
|
|
return !text.includes('Failed to load resource: the server responded with a status of 404')
|
|
})
|
|
const errors = relevantIssues.filter((issue) => issue.type !== 'warning')
|
|
if (errors.length > 0) {
|
|
const lines = errors.map((issue) => `- ${issue.type}: ${issue.text}`).join('\n')
|
|
fail(`GUI render smoke saw console/runtime errors:\n${lines}`)
|
|
}
|
|
if (relevantIssues.length > 0) {
|
|
const lines = relevantIssues.map((issue) => `- ${issue.type}: ${issue.text}`).join('\n')
|
|
console.log(`Console warnings:\n${lines}`)
|
|
}
|
|
|
|
console.log(`OK: GUI render smoke passed. Screenshots: ${OUT_DIR}`)
|
|
cdp.close()
|
|
}
|
|
|
|
async function runStartupScenario(cdp, url, name, selector) {
|
|
await navigate(cdp, url)
|
|
await waitForSelector(cdp, selector)
|
|
if (name === 'first-run') {
|
|
await assertEval(cdp, `document.body.innerText.includes('Верстак')`, `${name}: app identity text visible`)
|
|
} else {
|
|
await assertEval(cdp, `document.body.innerText.includes('/tmp/missing-verstak-vault')`, `${name}: missing vault path visible`)
|
|
}
|
|
await screenshot(cdp, `${name}.png`)
|
|
console.log(`OK: ${name} screen renders`)
|
|
}
|
|
|
|
async function runReadyScenario(cdp, url) {
|
|
await navigate(cdp, url)
|
|
await waitForSelector(cdp, '.app')
|
|
await assertText(cdp, 'Верстак', 'ready: brand visible')
|
|
await assertEval(cdp, `document.querySelectorAll('.nav-item').length >= 3`, 'ready: system navigation rendered')
|
|
await assertEval(cdp, `document.querySelectorAll('.tree-item').length >= 2`, 'ready: workspace tree rendered')
|
|
await waitForSelector(cdp, '.global-search-input')
|
|
await assertEval(cdp, `document.querySelector('.global-search-input')?.placeholder === 'Поиск по Верстаку...'`, 'header: global search is visible')
|
|
await dispatchShortcut(cdp, 'k', true)
|
|
await assertEval(cdp, `document.activeElement === document.querySelector('.global-search-input')`, 'header: Ctrl+K focuses global search')
|
|
await setInputValue(cdp, '.global-search-input', 'Smoke')
|
|
await waitForSelector(cdp, '.global-search-results')
|
|
await assertText(cdp, 'Проект · Верстак / Smoke Project', 'search: node result shows type and breadcrumbs')
|
|
await assertText(cdp, 'Заметка · Верстак / Smoke Project', 'search: note result shows type and breadcrumbs')
|
|
await assertText(cdp, 'Файл · Верстак / Smoke Project / Assets', 'search: file result shows type and breadcrumbs')
|
|
await assertText(cdp, 'Ссылка · Верстак / Smoke Project', 'search: link result shows type and breadcrumbs')
|
|
await clickText(cdp, '.global-search-result', 'Smoke note')
|
|
await assertText(cdp, 'Rendered by GUI smoke.', 'search: note result opens note editor')
|
|
await dispatchBodyKeydown(cdp, 'Backspace')
|
|
await waitForGone(cdp, '.note-editor')
|
|
await screenshot(cdp, 'ready-main.png')
|
|
|
|
await click(cdp, '.sidebar-settings-btn')
|
|
await waitForSelector(cdp, '.settings-window')
|
|
await assertEval(cdp, `document.querySelectorAll('.settings-nav-icon svg').length === 8`, 'settings: all sidebar icons are SVG')
|
|
await assertEval(cdp, `[...document.querySelectorAll('.settings-nav-icon')].every((el) => el.textContent.trim() === '')`, 'settings: no text glyph icons remain')
|
|
await clickText(cdp, '.settings-nav-item', 'Синхронизация')
|
|
await assertText(cdp, 'Настройте подключение к серверу синхронизации.', 'settings: sync section opens')
|
|
await clickText(cdp, '.sync-actions .btn', 'Синхронизировать сейчас')
|
|
await assertText(cdp, 'Конфликты: 1', 'settings: sync conflict warning visible')
|
|
await assertText(cdp, 'Ошибки применения: 1', 'settings: sync apply error warning visible')
|
|
await clickText(cdp, '.settings-nav-item', 'Шаблоны')
|
|
await assertText(cdp, 'Шаблоны', 'settings: templates section opens')
|
|
await clickText(cdp, '.settings-nav-item', 'Рабочее пространство')
|
|
await assertText(cdp, 'Рабочее пространство', 'settings: workspace section opens')
|
|
await screenshot(cdp, 'settings.png')
|
|
await click(cdp, '.close-btn')
|
|
await waitForGone(cdp, '.settings-window')
|
|
await assertEval(cdp, `![...document.querySelectorAll('.tree-label')].some((el) => el.innerText.includes('Inbox Smoke Item'))`, 'workspace: captured item hidden from tree')
|
|
|
|
await clickText(cdp, '.nav-item', 'Неразобранное')
|
|
await assertText(cdp, 'Неразобранное', 'inbox: system view opens')
|
|
await assertEval(cdp, `!document.querySelector('.inbox-header h2')`, 'inbox: screen title is not duplicated inside body')
|
|
await assertText(cdp, 'Inbox Smoke Item', 'inbox: captured item visible')
|
|
await assertText(cdp, 'Текст', 'inbox: capture kind visible')
|
|
await assertText(cdp, 'Буфер обмена', 'inbox: capture source visible')
|
|
await assertEval(cdp, `!document.querySelector('.inbox-screen')?.innerText.includes('Manual Root Item')`, 'inbox: manual root is hidden')
|
|
await setClipboardText(cdp, 'https://example.test/from-clipboard')
|
|
await clickText(cdp, '.header-actions .btn', 'Вставить из буфера')
|
|
await assertText(cdp, 'example.test', 'inbox: clipboard URL captured')
|
|
await assertEval(cdp, `
|
|
(() => {
|
|
const row = [...document.querySelectorAll('.inbox-item')].find((el) => el.innerText.includes('example.test'));
|
|
if (!row) return false;
|
|
if (row.innerText.includes('Ссылка') || row.innerText.includes('URL') || row.innerText.includes('capture.kind.url')) return true;
|
|
throw new Error('URL row text: ' + row.innerText);
|
|
})()
|
|
`, 'inbox: clipboard URL kind visible')
|
|
await assertInboxItemButtonAbsent(cdp, 'example.test', 'Показать в проводнике', 'inbox: link has no explorer action')
|
|
await assertEval(cdp, `
|
|
(() => {
|
|
const row = [...document.querySelectorAll('.inbox-item')].find((el) => el.innerText.includes('example.test'));
|
|
if (!row) return false;
|
|
const iconButtons = [...row.querySelectorAll('.inbox-icon-btn')];
|
|
return iconButtons.length >= 3 && iconButtons.every((btn) => btn.title && btn.innerText.trim() === '');
|
|
})()
|
|
`, 'inbox: frequent actions are icon buttons with titles')
|
|
await clickInboxItemButton(cdp, 'example.test', 'Открыть')
|
|
await assertEval(cdp, `window.__VERSTAK_GUI_SMOKE__.state.openedUrls.includes('https://example.test/from-clipboard')`, 'inbox: open URL launches external URL')
|
|
await clickInboxItemButton(cdp, 'example.test', 'Разложить')
|
|
await waitForSelector(cdp, '.modal input[type="text"]')
|
|
await setInputValue(cdp, '.modal input[type="text"]', 'Smoke')
|
|
await waitForSelector(cdp, '.assign-search-result')
|
|
await clickText(cdp, '.assign-search-result', 'Smoke Project')
|
|
await clickText(cdp, '.modal-actions .btn', 'Разложить')
|
|
await waitForGone(cdp, '.modal-overlay')
|
|
await assertEval(cdp, `!document.querySelector('.inbox-screen')?.innerText.includes('example.test')`, 'inbox: assigned link leaves inbox')
|
|
await setClipboardText(cdp, 'mirv.top')
|
|
await clickText(cdp, '.header-actions .btn', 'Вставить из буфера')
|
|
await assertText(cdp, 'mirv.top', 'inbox: bare domain captured as URL')
|
|
await clickInboxItemButton(cdp, 'mirv.top', 'Открыть')
|
|
await assertEval(cdp, `window.__VERSTAK_GUI_SMOKE__.state.openedUrls.includes('https://mirv.top')`, 'inbox: bare domain opens normalized URL')
|
|
await clickInboxItemButton(cdp, 'mirv.top', 'Удалить')
|
|
await clickText(cdp, '.overlay .btn', 'Удалить')
|
|
await emitDroppedFiles(cdp, ['/tmp/smoke-drop-folder'])
|
|
await assertText(cdp, 'smoke-drop-folder', 'inbox: dropped folder captured')
|
|
await assertText(cdp, 'Перетаскивание', 'inbox: dropped source visible')
|
|
await clickInboxItemButton(cdp, 'smoke-drop-folder', 'Открыть')
|
|
await assertEval(cdp, `document.querySelector('.tab.active')?.innerText.includes('Файлы')`, 'inbox: open folder switches to files tab')
|
|
await assertText(cdp, 'captured-folder-file.txt', 'inbox: open folder shows captured folder contents')
|
|
await clickText(cdp, '.nav-item', 'Неразобранное')
|
|
await dispatchPasteImage(cdp, 'pasted-smoke.png', 'image/png', 'c21va2UtaW1hZ2U=')
|
|
await assertText(cdp, 'pasted-smoke.png', 'inbox: clipboard image captured')
|
|
await assertText(cdp, 'Изображение', 'inbox: clipboard image kind visible')
|
|
await clickInboxItemButton(cdp, 'smoke-drop-folder', 'Разложить')
|
|
await waitForSelector(cdp, '.modal input[type="text"]')
|
|
await setInputValue(cdp, '.modal input[type="text"]', 'Smoke')
|
|
await waitForSelector(cdp, '.assign-search-result')
|
|
await assertEval(cdp, `document.querySelector('.assign-search-result')?.innerText.includes('Smoke Project')`, 'inbox: assign target search works')
|
|
await clickText(cdp, '.assign-search-result', 'Smoke Project')
|
|
await clickText(cdp, '.modal-actions .btn', 'Разложить')
|
|
await waitForGone(cdp, '.modal-overlay')
|
|
await assertEval(cdp, `!document.querySelector('.inbox-screen')?.innerText.includes('smoke-drop-folder')`, 'inbox: assigned item leaves inbox')
|
|
await clickInboxItemButton(cdp, 'pasted-smoke.png', 'Открыть')
|
|
await waitForSelector(cdp, '.preview-image')
|
|
await assertText(cdp, 'pasted-smoke.png', 'inbox: open image shows preview')
|
|
await click(cdp, '.action-btn-close')
|
|
await clickInboxItemButton(cdp, 'pasted-smoke.png', 'Удалить')
|
|
await clickText(cdp, '.overlay .btn', 'Удалить')
|
|
await assertEval(cdp, `!document.querySelector('.inbox-screen')?.innerText.includes('pasted-smoke.png')`, 'inbox: deleted item leaves inbox')
|
|
await dispatchExternalDrag(cdp)
|
|
await waitForSelector(cdp, '.capture-drop-overlay')
|
|
await dispatchBodyKeydown(cdp, 'Escape')
|
|
await waitForGone(cdp, '.capture-drop-overlay')
|
|
await assertEval(cdp, `document.querySelector('.nav-item')?.click && !document.querySelector('.capture-drop-overlay')`, 'drag: Escape resets capture overlay')
|
|
await dispatchExternalDrag(cdp)
|
|
await waitForSelector(cdp, '.capture-drop-overlay')
|
|
await dispatchWindowBlur(cdp)
|
|
await waitForGone(cdp, '.capture-drop-overlay')
|
|
await assertEval(cdp, `!document.querySelector('.capture-drop-overlay')`, 'drag: blur resets capture overlay')
|
|
await screenshot(cdp, 'inbox.png')
|
|
await clickText(cdp, '.inbox-item', 'Inbox Smoke Item')
|
|
await assertText(cdp, 'Inbox Smoke Item', 'inbox: item opens from list')
|
|
await clickText(cdp, '.note-editor-actions .btn', 'Закрыть')
|
|
|
|
await clickText(cdp, '.nav-item', 'Корзина')
|
|
await assertEval(cdp, `!document.querySelector('.trash-header h2')`, 'trash: screen title is not duplicated inside body')
|
|
await assertText(cdp, 'Trash Smoke Folder', 'trash: deleted node visible')
|
|
await assertEval(cdp, `!document.body.innerText.includes('.verstak/trash') && !document.body.innerText.includes('node-trash_Trash-Smoke-Folder')`, 'trash: physical implementation entries are hidden')
|
|
await click(cdp, '.trash-row.folder .trash-row-icon')
|
|
await assertText(cdp, 'trash-child.txt', 'trash: opening deleted folder shows children immediately')
|
|
await assertText(cdp, 'Корзина / Trash Smoke Folder', 'trash: current folder breadcrumb visible')
|
|
await dispatchBodyKeydown(cdp, 'Backspace')
|
|
await assertEval(cdp, `document.body.innerText.includes('Trash Smoke Folder') && !document.body.innerText.includes('trash-child.txt')`, 'trash: Backspace returns to trash root')
|
|
await click(cdp, '.trash-row.folder .trash-row-icon')
|
|
await dispatchMouseBack(cdp)
|
|
await assertEval(cdp, `document.body.innerText.includes('Trash Smoke Folder') && !document.body.innerText.includes('trash-child.txt')`, 'trash: mouse Back returns to trash root')
|
|
await clickText(cdp, '.nav-item', 'Журнал')
|
|
await clickText(cdp, '.nav-item', 'Корзина')
|
|
await assertEval(cdp, `document.body.innerText.includes('Trash Smoke Folder') && !document.body.innerText.includes('trash-child.txt')`, 'trash: sidebar return uses stable root state')
|
|
await screenshot(cdp, 'trash.png')
|
|
|
|
await clickText(cdp, '.tree-label', 'Smoke Project')
|
|
await waitForSelector(cdp, '.tabs')
|
|
await assertText(cdp, 'Smoke Project', 'node: selected project visible')
|
|
await assertEval(cdp, `document.querySelectorAll('.tab').length === 8`, 'node: all primary tabs rendered')
|
|
await assertEval(cdp, `[...document.querySelectorAll('.tab')].map((el) => el.innerText.trim()).join('|') === 'Обзор|Заметки|Файлы|Ссылки|Действия|Активность|Журнал|Неразобранное'`, 'node: tabs use content-first order')
|
|
await assertEval(cdp, `document.querySelector('.tab-separator') !== null`, 'node: service tabs are visually separated')
|
|
await screenshot(cdp, 'node-overview.png')
|
|
|
|
await clickText(cdp, '.tab', 'Заметки')
|
|
await assertText(cdp, 'Smoke note', 'notes: existing note visible')
|
|
await clickText(cdp, '.btn', '+ Добавить заметку')
|
|
await waitForSelector(cdp, '.create-form input[type="text"]')
|
|
await setInputValue(cdp, '.create-form input[type="text"]', 'GUI smoke note')
|
|
await clickText(cdp, '.create-form .btn', 'Создать')
|
|
await assertText(cdp, 'GUI smoke note', 'notes: created note appears')
|
|
|
|
await clickText(cdp, '.tab', 'Файлы')
|
|
await clickText(cdp, '.tab', 'Ссылки')
|
|
await dispatchBodyKeydown(cdp, 'Backspace')
|
|
await assertEval(cdp, `document.querySelector('.tab.active')?.innerText.includes('Файлы')`, 'navigation: Backspace returns to previous tab')
|
|
await waitForSelector(cdp, '.file-row')
|
|
await assertText(cdp, 'Assets', 'files: folder row visible')
|
|
await clickFolderOpenButton(cdp, 'Assets')
|
|
await waitForSelector(cdp, '.back-btn')
|
|
await assertEval(cdp, `document.querySelector('.back-btn')?.innerText.trim() === 'Назад'`, 'files: back button has one textual label')
|
|
await screenshot(cdp, 'files-folder.png')
|
|
await click(cdp, '.back-btn')
|
|
await assertText(cdp, 'brief.md', 'files: back button returns to parent folder')
|
|
|
|
await clickText(cdp, '.tab', 'Ссылки')
|
|
await assertText(cdp, 'example.test', 'links: resolved link visible')
|
|
|
|
await clickText(cdp, '.tab', 'Действия')
|
|
await assertText(cdp, 'Deploy smoke', 'actions: action card visible')
|
|
await clickText(cdp, '.actions-tab .btn', 'Добавить действие')
|
|
await waitForSelector(cdp, '.modal input[type="text"]')
|
|
await dispatchKeydown(cdp, '.modal input[type="text"]', ' ')
|
|
await assertEval(cdp, `!!document.querySelector('.modal input[type="text"]')`, 'actions: space in title input keeps modal open')
|
|
await dispatchKeydown(cdp, '.modal input[type="text"]', 'Backspace')
|
|
await assertEval(cdp, `!!document.querySelector('.modal input[type="text"]')`, 'navigation: Backspace in input does not navigate')
|
|
await setInputValue(cdp, '.modal input[type="text"]', 'GUI smoke action with spaces')
|
|
await setInputValue(cdp, '.modal input[placeholder="https://example.com"]', 'https://example.test/action')
|
|
await clickText(cdp, '.modal-actions .btn', 'Создать')
|
|
await waitForGone(cdp, '.modal-overlay')
|
|
await assertText(cdp, 'GUI smoke action with spaces', 'actions: action with spaces saved')
|
|
|
|
await clickText(cdp, '.tab', 'Журнал')
|
|
await assertText(cdp, 'Manual smoke entry', 'worklog: entry visible')
|
|
await clickText(cdp, '.worklog-tab-suggestions .suggestion-actions .btn', 'Изменить')
|
|
await waitForSelector(cdp, '.modal-worklog')
|
|
await setInputValue(cdp, '.modal-worklog input[type="text"]', 'GUI smoke accepted suggestion')
|
|
await setInputValue(cdp, '.modal-worklog input[type="number"]', '35')
|
|
await setInputValue(cdp, '.modal-worklog textarea', 'Accepted after manual edit')
|
|
await clickText(cdp, '.modal-worklog .btn', 'Сохранить')
|
|
await waitForGone(cdp, '.modal-worklog')
|
|
await assertText(cdp, 'GUI smoke accepted suggestion', 'worklog: edited suggestion accepted')
|
|
await clickText(cdp, '.worklog-toolbar .btn', 'Добавить запись')
|
|
await waitForSelector(cdp, '.modal-worklog')
|
|
await setInputValue(cdp, '.modal-worklog input[type="text"]', 'GUI smoke worklog')
|
|
await setInputValue(cdp, '.modal-worklog input[type="number"]', '15')
|
|
await clickText(cdp, '.modal-worklog .btn', 'Сохранить')
|
|
await waitForGone(cdp, '.modal-worklog')
|
|
await assertText(cdp, 'GUI smoke worklog', 'worklog: created entry appears')
|
|
await clickText(cdp, '.worklog-entry', 'GUI smoke worklog')
|
|
await clickText(cdp, '.worklog-entry-actions .btn', 'Редактировать запись')
|
|
await waitForSelector(cdp, '.modal-worklog')
|
|
await setInputValue(cdp, '.modal-worklog input[type="text"]', 'GUI smoke worklog edited')
|
|
await setInputValue(cdp, '.modal-worklog input[type="number"]', '25')
|
|
await clickText(cdp, '.modal-worklog .btn', 'Сохранить')
|
|
await waitForGone(cdp, '.modal-worklog')
|
|
await assertText(cdp, 'GUI smoke worklog edited', 'worklog: edited entry appears')
|
|
await clickText(cdp, '.worklog-entry', 'GUI smoke worklog edited')
|
|
await clickText(cdp, '.worklog-entry-actions .btn', 'Удалить запись')
|
|
await clickText(cdp, '.overlay .btn', 'Удалить')
|
|
await assertEval(cdp, `!document.body.innerText.includes('GUI smoke worklog edited')`, 'worklog: deleted entry disappears')
|
|
|
|
await clickText(cdp, '.tab', 'Активность')
|
|
await assertText(cdp, 'Smoke activity', 'activity: per-node activity visible')
|
|
|
|
await emitDroppedFiles(cdp, ['/tmp/project-context-file.txt'])
|
|
await clickText(cdp, '.nav-item', 'Неразобранное')
|
|
await assertText(cdp, 'project-context-file.txt', 'inbox: node-context capture visible globally')
|
|
await assertText(cdp, 'Захвачено в: Smoke Project', 'inbox: global list shows capture context')
|
|
await assertText(cdp, 'Цель: Smoke Project', 'inbox: global list shows suggested target')
|
|
await clickInboxItemButton(cdp, 'project-context-file.txt', 'Удалить')
|
|
await clickText(cdp, '.overlay .btn', 'Удалить')
|
|
await assertEval(cdp, `!document.querySelector('.inbox-screen')?.innerText.includes('project-context-file.txt')`, 'inbox: node-context capture can be deleted')
|
|
|
|
await clickText(cdp, '.nav-item', 'Сегодня')
|
|
await assertText(cdp, 'Сегодня', 'today: system view opens')
|
|
await assertEval(cdp, `!document.querySelector('.today-header h2')`, 'today: screen title is not duplicated inside body')
|
|
await assertText(cdp, 'Smoke Project', 'today: dashboard data visible')
|
|
|
|
await clickText(cdp, '.nav-item', 'Журнал')
|
|
await waitForSelector(cdp, '.journal-screen')
|
|
await assertEval(cdp, `!document.querySelector('.journal-screen h2')`, 'journal: screen title is not duplicated inside body')
|
|
await clickText(cdp, '.journal-tab', 'Журнал работы')
|
|
await screenshot(cdp, 'journal.png')
|
|
await assertEval(cdp, `
|
|
(() => {
|
|
const summary = document.querySelector('.journal-summary');
|
|
const exportBlock = document.querySelector('.journal-export-section');
|
|
const filterBlock = document.querySelector('.journal-filter-section');
|
|
const table = document.querySelector('.journal-table-wrap');
|
|
if (!summary || !exportBlock || !filterBlock || !table) return false;
|
|
const top = (el) => el.getBoundingClientRect().top;
|
|
return top(summary) < top(exportBlock) && top(exportBlock) < top(filterBlock) && top(filterBlock) < top(table);
|
|
})()
|
|
`, 'journal: summary, export, filters, work list order')
|
|
await assertEval(cdp, `document.body.innerText.toLowerCase().includes('фильтры')`, 'journal: filter section visible')
|
|
await assertEval(cdp, `document.body.innerText.toLowerCase().includes('экспорт отчёта')`, 'journal: export section visible')
|
|
|
|
await clickText(cdp, '.nav-item', 'Активность')
|
|
await assertText(cdp, 'Активность', 'activity feed: system view opens')
|
|
await assertEval(cdp, `!document.querySelector('.activity-feed-header h2')`, 'activity: screen title is not duplicated inside body')
|
|
await assertText(cdp, 'Smoke activity', 'activity feed: event visible')
|
|
|
|
await clickText(cdp, '.nav-item', 'Сегодня')
|
|
await clickText(cdp, '.tree-label', 'Smoke Client')
|
|
await clickText(cdp, '.tree-label', 'Smoke Project')
|
|
await deleteSmokeNode(cdp, 'node-client')
|
|
await dispatchBodyKeydown(cdp, 'Backspace')
|
|
await assertEval(cdp, `document.querySelector('.header-title')?.innerText.trim() === 'Сегодня'`, 'navigation: Backspace skips deleted history entries')
|
|
|
|
await click(cdp, '.nav-add-btn')
|
|
await waitForSelector(cdp, '.modal-create')
|
|
await assertText(cdp, 'Создать элемент', 'create node: modal opens')
|
|
await clickText(cdp, '.template-card', 'Пустое дело')
|
|
await setInputValue(cdp, '.modal-create input[type="text"]', 'GUI Smoke Created')
|
|
await screenshot(cdp, 'create-node-modal.png')
|
|
await clickText(cdp, '.modal-actions .btn', 'Создать')
|
|
await waitForGone(cdp, '.modal-create')
|
|
await assertText(cdp, 'GUI Smoke Created', 'create node: created node appears')
|
|
|
|
await setViewport(cdp, 390, 844)
|
|
await navigate(cdp, url)
|
|
await waitForSelector(cdp, '.app')
|
|
await assertEval(cdp, `document.documentElement.scrollWidth <= window.innerWidth + 2`, 'mobile: no horizontal page overflow')
|
|
await screenshot(cdp, 'mobile-main.png')
|
|
|
|
console.log('OK: ready app smoke covers settings, inbox, trash, workspace, tabs, files, journal, activity, create modal, mobile viewport')
|
|
}
|
|
|
|
async function navigate(cdp, url) {
|
|
await cdp.send('Page.navigate', { url })
|
|
await waitForEvent(cdp, 'Page.loadEventFired', 15000)
|
|
await waitFor(cdp, `document.readyState === 'complete'`, 10000)
|
|
}
|
|
|
|
async function setViewport(cdp, width, height) {
|
|
await cdp.send('Emulation.setDeviceMetricsOverride', {
|
|
width,
|
|
height,
|
|
deviceScaleFactor: 1,
|
|
mobile: width < 600,
|
|
})
|
|
}
|
|
|
|
async function screenshot(cdp, name) {
|
|
const result = await cdp.send('Page.captureScreenshot', { format: 'png', captureBeyondViewport: false })
|
|
await writeFile(path.join(OUT_DIR, name), Buffer.from(result.data, 'base64'))
|
|
}
|
|
|
|
async function waitForSelector(cdp, selector, timeout = 10000) {
|
|
await waitFor(cdp, `Boolean(document.querySelector(${JSON.stringify(selector)}))`, timeout)
|
|
}
|
|
|
|
async function waitForGone(cdp, selector, timeout = 10000) {
|
|
await waitFor(cdp, `!document.querySelector(${JSON.stringify(selector)})`, timeout)
|
|
}
|
|
|
|
async function waitFor(cdp, expression, timeout = 10000) {
|
|
const deadline = Date.now() + timeout
|
|
while (Date.now() < deadline) {
|
|
const value = await evalValue(cdp, expression)
|
|
if (value) return
|
|
await sleep(100)
|
|
}
|
|
throw new Error(`Timed out waiting for: ${expression}`)
|
|
}
|
|
|
|
async function assertText(cdp, text, label) {
|
|
await waitFor(cdp, `document.body.innerText.includes(${JSON.stringify(text)})`, 10000)
|
|
console.log(`OK: ${label}`)
|
|
}
|
|
|
|
async function assertEval(cdp, expression, label) {
|
|
const ok = await evalValue(cdp, expression)
|
|
if (!ok) throw new Error(`Assertion failed: ${label}`)
|
|
console.log(`OK: ${label}`)
|
|
}
|
|
|
|
async function click(cdp, selector) {
|
|
const ok = await evalValue(cdp, `
|
|
(() => {
|
|
const el = document.querySelector(${JSON.stringify(selector)});
|
|
if (!el) return false;
|
|
el.click();
|
|
return true;
|
|
})()
|
|
`)
|
|
if (!ok) throw new Error(`Click target not found: ${selector}`)
|
|
await sleep(150)
|
|
}
|
|
|
|
async function clickText(cdp, selector, text) {
|
|
const ok = await evalValue(cdp, `
|
|
(() => {
|
|
const norm = (value) => (value || '').replace(/\\s+/g, ' ').trim();
|
|
const el = [...document.querySelectorAll(${JSON.stringify(selector)})]
|
|
.find((node) => norm(node.innerText || node.textContent).includes(${JSON.stringify(text)}));
|
|
if (!el) return false;
|
|
el.click();
|
|
return true;
|
|
})()
|
|
`)
|
|
if (!ok) throw new Error(`Click text target not found: ${selector} -> ${text}`)
|
|
await sleep(200)
|
|
}
|
|
|
|
async function setInputValue(cdp, selector, value) {
|
|
const ok = await evalValue(cdp, `
|
|
(() => {
|
|
const el = document.querySelector(${JSON.stringify(selector)});
|
|
if (!el) return false;
|
|
el.focus();
|
|
el.value = ${JSON.stringify(value)};
|
|
el.dispatchEvent(new Event('input', { bubbles: true }));
|
|
el.dispatchEvent(new Event('change', { bubbles: true }));
|
|
return true;
|
|
})()
|
|
`)
|
|
if (!ok) throw new Error(`Input target not found: ${selector}`)
|
|
await sleep(100)
|
|
}
|
|
|
|
async function dispatchKeydown(cdp, selector, key) {
|
|
const ok = await evalValue(cdp, `
|
|
(() => {
|
|
const el = document.querySelector(${JSON.stringify(selector)});
|
|
if (!el) return false;
|
|
el.focus();
|
|
const event = new KeyboardEvent('keydown', { key: ${JSON.stringify(key)}, bubbles: true, cancelable: true });
|
|
el.dispatchEvent(event);
|
|
return true;
|
|
})()
|
|
`)
|
|
if (!ok) throw new Error(`Keydown target not found: ${selector}`)
|
|
await sleep(100)
|
|
}
|
|
|
|
async function dispatchBodyKeydown(cdp, key) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `
|
|
(() => {
|
|
document.body.focus();
|
|
const event = new KeyboardEvent('keydown', { key: ${JSON.stringify(key)}, bubbles: true, cancelable: true });
|
|
window.dispatchEvent(event);
|
|
})()
|
|
`,
|
|
returnByValue: true,
|
|
})
|
|
await sleep(150)
|
|
}
|
|
|
|
async function dispatchShortcut(cdp, key, ctrlKey = false) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `
|
|
(() => {
|
|
const event = new KeyboardEvent('keydown', {
|
|
key: ${JSON.stringify(key)},
|
|
ctrlKey: ${ctrlKey ? 'true' : 'false'},
|
|
bubbles: true,
|
|
cancelable: true,
|
|
});
|
|
window.dispatchEvent(event);
|
|
})()
|
|
`,
|
|
returnByValue: true,
|
|
})
|
|
await sleep(150)
|
|
}
|
|
|
|
async function dispatchMouseBack(cdp) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `
|
|
(() => {
|
|
const event = new MouseEvent('auxclick', { button: 3, bubbles: true, cancelable: true });
|
|
window.dispatchEvent(event);
|
|
})()
|
|
`,
|
|
returnByValue: true,
|
|
})
|
|
await sleep(150)
|
|
}
|
|
|
|
async function deleteSmokeNode(cdp, id) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `window.__VERSTAK_GUI_SMOKE__.deleteNode(${JSON.stringify(id)})`,
|
|
awaitPromise: true,
|
|
returnByValue: true,
|
|
})
|
|
await sleep(150)
|
|
}
|
|
|
|
async function setClipboardText(cdp, value) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `window.__VERSTAK_GUI_SMOKE_CLIPBOARD__ = ${JSON.stringify(value)}`,
|
|
returnByValue: true,
|
|
})
|
|
}
|
|
|
|
async function setClipboardImage(cdp, name, type, base64) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `
|
|
window.__VERSTAK_GUI_SMOKE_CLIPBOARD__ = '';
|
|
window.__VERSTAK_GUI_SMOKE_CLIPBOARD_ITEMS__ = [{
|
|
types: [${JSON.stringify(type)}],
|
|
getType: async () => new File([Uint8Array.from(atob(${JSON.stringify(base64)}), c => c.charCodeAt(0))], ${JSON.stringify(name)}, { type: ${JSON.stringify(type)} }),
|
|
}];
|
|
`,
|
|
awaitPromise: true,
|
|
returnByValue: true,
|
|
})
|
|
}
|
|
|
|
async function dispatchPasteImage(cdp, name, type, base64) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `
|
|
(() => {
|
|
const bytes = Uint8Array.from(atob(${JSON.stringify(base64)}), c => c.charCodeAt(0));
|
|
const file = new File([bytes], ${JSON.stringify(name)}, { type: ${JSON.stringify(type)} });
|
|
const data = new DataTransfer();
|
|
data.items.add(file);
|
|
const event = new ClipboardEvent('paste', { bubbles: true, cancelable: true, clipboardData: data });
|
|
window.dispatchEvent(event);
|
|
})();
|
|
`,
|
|
awaitPromise: true,
|
|
returnByValue: true,
|
|
})
|
|
await sleep(300)
|
|
}
|
|
|
|
async function emitDroppedFiles(cdp, paths) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `window.__VERSTAK_GUI_SMOKE__.dropFiles(${JSON.stringify(paths)})`,
|
|
awaitPromise: true,
|
|
returnByValue: true,
|
|
})
|
|
await sleep(300)
|
|
}
|
|
|
|
async function dispatchExternalDrag(cdp) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `
|
|
(() => {
|
|
const data = new DataTransfer();
|
|
data.items.add(new File(['smoke'], 'drag-smoke.txt', { type: 'text/plain' }));
|
|
const enter = new DragEvent('dragenter', { bubbles: true, cancelable: true, dataTransfer: data });
|
|
const over = new DragEvent('dragover', { bubbles: true, cancelable: true, dataTransfer: data });
|
|
window.dispatchEvent(enter);
|
|
window.dispatchEvent(over);
|
|
})()
|
|
`,
|
|
awaitPromise: true,
|
|
returnByValue: true,
|
|
})
|
|
await sleep(150)
|
|
}
|
|
|
|
async function dispatchWindowBlur(cdp) {
|
|
await cdp.send('Runtime.evaluate', {
|
|
expression: `window.dispatchEvent(new Event('blur'))`,
|
|
returnByValue: true,
|
|
})
|
|
await sleep(150)
|
|
}
|
|
|
|
async function clickFolderOpenButton(cdp, name) {
|
|
const ok = await evalValue(cdp, `
|
|
(() => {
|
|
const rows = [...document.querySelectorAll('.file-row')];
|
|
const row = rows.find((el) => el.innerText.includes(${JSON.stringify(name)}));
|
|
if (!row) return false;
|
|
const btn = row.querySelector('[title="Открыть папку"], [aria-label="Открыть папку"]');
|
|
if (!btn) return false;
|
|
btn.click();
|
|
return true;
|
|
})()
|
|
`)
|
|
if (!ok) throw new Error(`Folder open button not found for ${name}`)
|
|
await sleep(300)
|
|
}
|
|
|
|
async function clickInboxItemButton(cdp, title, buttonText) {
|
|
const ok = await evalValue(cdp, `
|
|
(() => {
|
|
const norm = (value) => (value || '').replace(/\\s+/g, ' ').trim();
|
|
const row = [...document.querySelectorAll('.inbox-item')]
|
|
.find((node) => norm(node.innerText || node.textContent).includes(${JSON.stringify(title)}));
|
|
if (!row) return false;
|
|
const btn = [...row.querySelectorAll('button')]
|
|
.find((node) => norm(node.innerText || node.textContent).includes(${JSON.stringify(buttonText)}) ||
|
|
norm(node.getAttribute('title')).includes(${JSON.stringify(buttonText)}) ||
|
|
norm(node.getAttribute('aria-label')).includes(${JSON.stringify(buttonText)}));
|
|
if (!btn) return false;
|
|
btn.click();
|
|
return true;
|
|
})()
|
|
`)
|
|
if (!ok) throw new Error(`Inbox item button not found: ${title} -> ${buttonText}`)
|
|
await sleep(250)
|
|
}
|
|
|
|
async function assertInboxItemButtonAbsent(cdp, title, buttonText, label) {
|
|
await assertEval(cdp, `
|
|
(() => {
|
|
const norm = (value) => (value || '').replace(/\\s+/g, ' ').trim();
|
|
const row = [...document.querySelectorAll('.inbox-item')]
|
|
.find((node) => norm(node.innerText || node.textContent).includes(${JSON.stringify(title)}));
|
|
if (!row) return false;
|
|
return ![...row.querySelectorAll('button')]
|
|
.some((node) => norm(node.innerText || node.textContent).includes(${JSON.stringify(buttonText)}) ||
|
|
norm(node.getAttribute('title')).includes(${JSON.stringify(buttonText)}) ||
|
|
norm(node.getAttribute('aria-label')).includes(${JSON.stringify(buttonText)}));
|
|
})()
|
|
`, label)
|
|
}
|
|
|
|
async function evalValue(cdp, expression) {
|
|
const result = await cdp.send('Runtime.evaluate', {
|
|
expression,
|
|
awaitPromise: true,
|
|
returnByValue: true,
|
|
userGesture: true,
|
|
})
|
|
if (result.exceptionDetails) {
|
|
const detail = result.exceptionDetails.exception?.description || result.exceptionDetails.text || 'Runtime.evaluate exception'
|
|
throw new Error(detail)
|
|
}
|
|
return result.result?.value
|
|
}
|
|
|
|
async function startPreview(port) {
|
|
const viteBin = path.join(FRONTEND, 'node_modules', '.bin', process.platform === 'win32' ? 'vite.cmd' : 'vite')
|
|
const child = spawn(viteBin, ['preview', '--host', HOST, '--port', String(port), '--strictPort'], {
|
|
cwd: FRONTEND,
|
|
stdio: ['ignore', 'pipe', 'pipe'],
|
|
env: process.env,
|
|
})
|
|
processes.push(child)
|
|
child.stdout.on('data', (buf) => process.stdout.write(prefixLines('vite', buf)))
|
|
child.stderr.on('data', (buf) => process.stderr.write(prefixLines('vite', buf)))
|
|
child.on('exit', (code) => {
|
|
if (code !== null && code !== 0) console.error(`vite preview exited with code ${code}`)
|
|
})
|
|
return child
|
|
}
|
|
|
|
async function startChromium(port) {
|
|
const profile = await mkdtemp(path.join(os.tmpdir(), 'verstak-chromium-'))
|
|
const child = spawn(CHROMIUM, [
|
|
'--headless=new',
|
|
'--disable-gpu',
|
|
'--disable-dev-shm-usage',
|
|
'--no-first-run',
|
|
'--no-default-browser-check',
|
|
'--disable-background-networking',
|
|
'--disable-sync',
|
|
'--metrics-recording-only',
|
|
'--disable-component-update',
|
|
'--disable-extensions',
|
|
`--remote-debugging-port=${port}`,
|
|
`--user-data-dir=${profile}`,
|
|
'--window-size=1280,900',
|
|
'about:blank',
|
|
], {
|
|
stdio: ['ignore', 'pipe', 'pipe'],
|
|
env: process.env,
|
|
})
|
|
child.__profile = profile
|
|
processes.push(child)
|
|
child.stderr.on('data', (buf) => {
|
|
const text = buf.toString()
|
|
const noisy = [
|
|
'DevTools listening',
|
|
'google_apis/gcm/engine/registration_request.cc',
|
|
'PHONE_REGISTRATION_ERROR',
|
|
]
|
|
if (!noisy.some((part) => text.includes(part))) process.stderr.write(prefixLines('chromium', buf))
|
|
})
|
|
await waitForHttp(`http://${HOST}:${port}/json/version`, 15000)
|
|
return child
|
|
}
|
|
|
|
async function openPage(port) {
|
|
let target
|
|
const newUrl = `http://${HOST}:${port}/json/new?about:blank`
|
|
let response = await fetch(newUrl, { method: 'PUT' })
|
|
if (!response.ok) response = await fetch(newUrl)
|
|
if (!response.ok) throw new Error(`Unable to create Chromium target: ${response.status}`)
|
|
target = await response.json()
|
|
return CDP.connect(target.webSocketDebuggerUrl)
|
|
}
|
|
|
|
class CDP {
|
|
constructor(ws) {
|
|
this.ws = ws
|
|
this.nextId = 1
|
|
this.pending = new Map()
|
|
this.listeners = new Map()
|
|
ws.onmessage = (event) => {
|
|
const msg = JSON.parse(event.data)
|
|
if (msg.id && this.pending.has(msg.id)) {
|
|
const { resolve, reject } = this.pending.get(msg.id)
|
|
this.pending.delete(msg.id)
|
|
if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)))
|
|
else resolve(msg.result || {})
|
|
return
|
|
}
|
|
const listeners = this.listeners.get(msg.method) || []
|
|
for (const fn of listeners) fn(msg.params || {})
|
|
}
|
|
}
|
|
|
|
static async connect(url) {
|
|
const ws = new WebSocket(url)
|
|
await new Promise((resolve, reject) => {
|
|
ws.onopen = resolve
|
|
ws.onerror = () => reject(new Error(`WebSocket connection failed: ${url}`))
|
|
})
|
|
return new CDP(ws)
|
|
}
|
|
|
|
on(method, fn) {
|
|
const list = this.listeners.get(method) || []
|
|
list.push(fn)
|
|
this.listeners.set(method, list)
|
|
}
|
|
|
|
send(method, params = {}) {
|
|
const id = this.nextId++
|
|
this.ws.send(JSON.stringify({ id, method, params }))
|
|
return new Promise((resolve, reject) => {
|
|
this.pending.set(id, { resolve, reject })
|
|
setTimeout(() => {
|
|
if (this.pending.has(id)) {
|
|
this.pending.delete(id)
|
|
reject(new Error(`CDP timeout: ${method}`))
|
|
}
|
|
}, 15000)
|
|
})
|
|
}
|
|
|
|
close() {
|
|
try {
|
|
this.ws.close()
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
function waitForEvent(cdp, method, timeout) {
|
|
return new Promise((resolve, reject) => {
|
|
const timer = setTimeout(() => reject(new Error(`Timed out waiting for ${method}`)), timeout)
|
|
cdp.on(method, (params) => {
|
|
clearTimeout(timer)
|
|
resolve(params)
|
|
})
|
|
})
|
|
}
|
|
|
|
async function waitForHttp(url, timeout) {
|
|
const deadline = Date.now() + timeout
|
|
while (Date.now() < deadline) {
|
|
try {
|
|
const response = await fetch(url)
|
|
if (response.ok) return
|
|
} catch {}
|
|
await sleep(150)
|
|
}
|
|
throw new Error(`Timed out waiting for ${url}`)
|
|
}
|
|
|
|
function freePort() {
|
|
return new Promise((resolve, reject) => {
|
|
const server = net.createServer()
|
|
server.listen(0, HOST, () => {
|
|
const address = server.address()
|
|
server.close(() => resolve(address.port))
|
|
})
|
|
server.on('error', reject)
|
|
})
|
|
}
|
|
|
|
async function cleanup() {
|
|
for (const child of processes.reverse()) {
|
|
if (!child.killed) child.kill('SIGTERM')
|
|
if (child.__profile) await rm(child.__profile, { recursive: true, force: true }).catch(() => {})
|
|
}
|
|
}
|
|
|
|
function findChromium() {
|
|
const candidates = [
|
|
process.env.CHROMIUM_BIN,
|
|
'/usr/bin/chromium',
|
|
'/usr/bin/chromium-browser',
|
|
'/usr/bin/google-chrome',
|
|
'/usr/bin/google-chrome-stable',
|
|
].filter(Boolean)
|
|
return candidates.find((candidate) => existsSync(candidate)) || ''
|
|
}
|
|
|
|
function prefixLines(label, buf) {
|
|
return buf.toString().split('\n').filter(Boolean).map((line) => `[${label}] ${line}\n`).join('')
|
|
}
|
|
|
|
function sleep(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms))
|
|
}
|
|
|
|
function fail(message) {
|
|
console.error(`FAIL: ${message}`)
|
|
process.exit(1)
|
|
}
|
|
|
|
try {
|
|
await main()
|
|
} finally {
|
|
await cleanup()
|
|
}
|
|
|
|
function wailsMockSource() {
|
|
return `
|
|
(() => {
|
|
const now = '2026-06-04T10:00:00Z';
|
|
const clone = (value) => JSON.parse(JSON.stringify(value));
|
|
const mode = new URL(location.href).searchParams.get('smokeMode') || 'ready';
|
|
|
|
Object.defineProperty(navigator, 'clipboard', {
|
|
configurable: true,
|
|
value: {
|
|
readText: async () => window.__VERSTAK_GUI_SMOKE_CLIPBOARD__ || '',
|
|
read: async () => window.__VERSTAK_GUI_SMOKE_CLIPBOARD_ITEMS__ || [],
|
|
},
|
|
});
|
|
|
|
const templates = [
|
|
{ id: 'folder.default', title: 'template.folder.default', icon: 'folder', enabled: true },
|
|
{ id: 'project.default', title: 'template.project.default', icon: 'project', enabled: true },
|
|
{ id: 'client.default', title: 'template.client.default', icon: 'client', enabled: true },
|
|
{ id: 'document.default', title: 'template.document.default', icon: 'document', enabled: true },
|
|
{ id: 'recipe.default', title: 'template.recipe.default', icon: 'recipe', enabled: true },
|
|
];
|
|
|
|
const state = {
|
|
nodes: [
|
|
{
|
|
id: 'node-project',
|
|
title: 'Smoke Project',
|
|
type: 'project',
|
|
section: 'projects',
|
|
createdAt: now,
|
|
has_children: true,
|
|
children: [
|
|
{ id: 'node-folder', title: 'Research', type: 'folder', section: 'projects', parent_id: 'node-project', createdAt: now, has_children: false, children: [] },
|
|
],
|
|
},
|
|
{ id: 'node-client', title: 'Smoke Client', type: 'client', section: 'clients', createdAt: now, has_children: false, children: [] },
|
|
{ id: 'node-inbox', title: 'Inbox Smoke Item', type: 'folder', section: '', captureInbox: true, captureKind: 'text', captureSource: 'clipboard', createdAt: now, has_children: false, children: [] },
|
|
{ id: 'node-manual-root', title: 'Manual Root Item', type: 'folder', section: '', createdAt: now, has_children: false, children: [] },
|
|
],
|
|
notes: {
|
|
'node-project': [{ id: 'note-1', title: 'Smoke note', createdAt: now }],
|
|
},
|
|
noteContent: {
|
|
'note-1': '# Smoke note\\\\nRendered by GUI smoke.',
|
|
},
|
|
files: {
|
|
'node-project': [
|
|
{ id: 'file-folder', nodeId: 'file-folder', name: 'Assets', type: 'folder', size: 0, createdAt: now },
|
|
{ id: 'file-brief', nodeId: 'file-brief', fileId: 'file-brief', name: 'brief.md', type: 'file', size: 1280, createdAt: now },
|
|
],
|
|
'file-folder': [
|
|
{ id: 'file-nested', nodeId: 'file-nested', fileId: 'file-nested', name: 'nested.txt', type: 'file', size: 64, createdAt: now },
|
|
],
|
|
},
|
|
actions: {
|
|
'node-project': [{ id: 'action-1', title: 'Deploy smoke', type: 'open_url', data: 'https://example.test' }],
|
|
},
|
|
worklog: {
|
|
'node-project': [{ id: 'wl-1', nodeId: 'node-project', summary: 'Manual smoke entry', details: 'Smoke details', minutes: 45, billable: true, approximate: false, source: 'manual', createdAt: now, date: '2026-06-04' }],
|
|
},
|
|
links: {
|
|
'node-project': [],
|
|
},
|
|
trashNodes: [
|
|
{ id: 'node-trash', title: 'Trash Smoke Folder', type: 'folder', fsPath: 'Trash Smoke Folder', nodePath: 'Smoke / Trash Smoke Folder', deletedAt: now },
|
|
{ id: 'node-trash-child', parentId: 'node-trash', title: 'trash-child.txt', type: 'file', fsPath: 'Trash Smoke Folder/trash-child.txt', nodePath: 'Smoke / Trash Smoke Folder / trash-child.txt', deletedAt: now },
|
|
{ id: 'node-trash-nested', parentId: 'node-trash', title: 'Nested Trash Folder', type: 'folder', fsPath: 'Trash Smoke Folder/Nested Trash Folder', nodePath: 'Smoke / Trash Smoke Folder / Nested Trash Folder', deletedAt: now },
|
|
],
|
|
openedUrls: [],
|
|
};
|
|
|
|
const fileNodeDetails = {
|
|
'note-1': { id: 'note-1', title: 'Smoke note', type: 'note', parent_id: 'node-project', createdAt: now, has_children: false },
|
|
'file-folder': { id: 'file-folder', title: 'Assets', type: 'folder', parent_id: 'node-project', createdAt: now, has_children: false, children: [] },
|
|
'file-brief': { id: 'file-brief', title: 'brief.md', type: 'file', parent_id: 'node-project', createdAt: now, has_children: false },
|
|
'file-nested': { id: 'file-nested', title: 'nested.txt', type: 'file', parent_id: 'file-folder', createdAt: now, has_children: false },
|
|
};
|
|
|
|
const events = [
|
|
{ id: 'event-1', nodeId: 'node-project', eventType: 'note_updated', title: 'Smoke activity', targetType: 'note', targetId: 'note-1', createdAt: now },
|
|
{ id: 'event-2', nodeId: 'node-project', eventType: 'file_added', title: 'brief.md', targetType: 'file', targetId: 'file-brief', targetPath: '/tmp/brief.md', createdAt: now },
|
|
];
|
|
|
|
function allNodes() {
|
|
const result = [];
|
|
function walk(items) {
|
|
for (const item of items) {
|
|
result.push(item);
|
|
if (item.children) walk(item.children);
|
|
}
|
|
}
|
|
walk(state.nodes);
|
|
return result;
|
|
}
|
|
|
|
function findNode(id) {
|
|
return allNodes().find((node) => node.id === id) || null;
|
|
}
|
|
|
|
function childrenOf(id) {
|
|
const node = findNode(id);
|
|
return node?.children || [];
|
|
}
|
|
|
|
function parseCaptureContext(contextJSON) {
|
|
let raw = {};
|
|
try { raw = JSON.parse(contextJSON || '{}') || {}; } catch {}
|
|
const out = {};
|
|
if (raw.contextType === 'node' && raw.nodeId) {
|
|
out.captureContextType = 'node';
|
|
out.captureContextNodeId = raw.nodeId;
|
|
out.suggestedTargetNodeId = raw.suggestedTargetNodeId || raw.nodeId;
|
|
out.captureContextLabel = findNode(raw.nodeId)?.title || raw.nodeId;
|
|
out.suggestedTargetLabel = findNode(out.suggestedTargetNodeId)?.title || out.suggestedTargetNodeId;
|
|
} else if (raw.contextType === 'section') {
|
|
out.captureContextType = 'section';
|
|
out.captureContextSection = raw.section || 'root';
|
|
out.captureContextLabel = out.captureContextSection;
|
|
} else {
|
|
out.captureContextType = 'global';
|
|
out.captureContextSection = raw.section || 'root';
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function hostnameForURL(value) {
|
|
try { return new URL(value).hostname; } catch { return ''; }
|
|
}
|
|
|
|
function normalizeURL(value) {
|
|
const raw = String(value || '').trim();
|
|
if (!raw || /[\\s]/.test(raw) || raw.includes('@')) return '';
|
|
try {
|
|
const parsed = new URL(raw);
|
|
return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.hostname ? raw : '';
|
|
} catch {
|
|
try {
|
|
const withScheme = 'https://' + raw;
|
|
const parsed = new URL(withScheme);
|
|
return parsed.hostname && parsed.hostname.includes('.') ? withScheme : '';
|
|
} catch {
|
|
return '';
|
|
}
|
|
}
|
|
}
|
|
|
|
function inboxDTO(node) {
|
|
return {
|
|
...node,
|
|
captureKind: node.captureKind || '',
|
|
sourceKind: node.sourceKind || node.captureKind || '',
|
|
captureSource: node.captureSource || '',
|
|
captureStatus: node.captureStatus || 'unresolved',
|
|
captureContextType: node.captureContextType || 'global',
|
|
captureContextNodeId: node.captureContextNodeId || '',
|
|
captureContextSection: node.captureContextSection || '',
|
|
suggestedTargetNodeId: node.suggestedTargetNodeId || '',
|
|
captureContextLabel: node.captureContextLabel || '',
|
|
suggestedTargetLabel: node.suggestedTargetLabel || '',
|
|
capturedAt: node.capturedAt || node.createdAt || '',
|
|
url: node.url || '',
|
|
hostname: node.hostname || '',
|
|
};
|
|
}
|
|
|
|
function detachNode(id, items = state.nodes) {
|
|
const idx = items.findIndex((node) => node.id === id);
|
|
if (idx >= 0) {
|
|
const [node] = items.splice(idx, 1);
|
|
return node;
|
|
}
|
|
for (const item of items) {
|
|
if (!item.children) continue;
|
|
const found = detachNode(id, item.children);
|
|
if (found) return found;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function readyStatus() {
|
|
return {
|
|
status: 'ready',
|
|
vaultPath: '/tmp/verstak-smoke-vault',
|
|
vaultExists: true,
|
|
defaultPath: '/tmp/verstak-smoke-vault',
|
|
appConfig: appConfig(),
|
|
};
|
|
}
|
|
|
|
function appConfig() {
|
|
return {
|
|
version: 1,
|
|
vault_path: '/tmp/verstak-smoke-vault',
|
|
theme: 'system',
|
|
language: 'ru',
|
|
enabled_templates: templates.map((template) => template.id),
|
|
enabled_plugins: [],
|
|
first_run_completed: true,
|
|
vault: { sync: { enabled: false, server_url: '', sync_interval: 0 } },
|
|
};
|
|
}
|
|
|
|
const App = {
|
|
GetStartupStatus: async () => {
|
|
if (mode === 'first_run') return { status: 'first_run', defaultPath: '/tmp/verstak-smoke-vault' };
|
|
if (mode === 'recovery') return { status: 'recovery', vaultPath: '/tmp/missing-verstak-vault', defaultPath: '/tmp/verstak-smoke-vault', appConfig: appConfig() };
|
|
return readyStatus();
|
|
},
|
|
GetDefaultVaultPath: async () => '/tmp/verstak-smoke-vault',
|
|
CheckVaultPath: async () => ({ writable: true, description: 'Smoke path is writable' }),
|
|
CreateVault: async () => readyStatus(),
|
|
OpenVault: async () => readyStatus(),
|
|
PickDirectory: async () => '/tmp/verstak-smoke-vault',
|
|
Quit: async () => true,
|
|
|
|
VerstakVersion: async () => 'verstak-gui/smoke',
|
|
GetAppConfig: async () => appConfig(),
|
|
SaveAppConfig: async () => true,
|
|
GetVaultInfo: async () => ({ path: '/tmp/verstak-smoke-vault', nodeCount: allNodes().length, fileCount: 2 }),
|
|
VaultCheck: async () => ({ ok: true, errors: [], warnings: [] }),
|
|
|
|
ListSystemViews: async () => [
|
|
{ id: 'today', label: 'Сегодня' },
|
|
{ id: 'inbox', label: 'Неразобранное' },
|
|
{ id: 'trash', label: 'Корзина' },
|
|
{ id: 'activity', label: 'Активность' },
|
|
{ id: 'journal', label: 'Журнал' },
|
|
],
|
|
ListWorkspaceTree: async () => clone(state.nodes.filter((node) => node.captureInbox !== true)),
|
|
ListWorkspaceChildren: async (id) => clone(childrenOf(id)),
|
|
ListInboxNodes: async () => clone(state.nodes.filter((node) => !node.parent_id && node.captureInbox === true).map(inboxDTO)),
|
|
ListInboxNodesForTarget: async (nodeId) => clone(state.nodes.filter((node) => node.captureInbox === true && (node.captureContextNodeId === nodeId || node.suggestedTargetNodeId === nodeId)).map(inboxDTO)),
|
|
CaptureTextWithContext: async (text, source, contextJSON) => {
|
|
const ctx = parseCaptureContext(contextJSON);
|
|
const node = { id: 'node-capture-text-' + Date.now(), title: String(text || '').trim().split('\\n').find(Boolean) || 'Captured text', type: 'note', section: '', captureInbox: true, captureKind: 'text', sourceKind: 'text', captureSource: source || 'paste', captureStatus: 'unresolved', createdAt: now, capturedAt: now, has_children: false, children: [], ...ctx };
|
|
state.nodes.push(node);
|
|
return clone(inboxDTO(node));
|
|
},
|
|
CaptureText: async (text) => App.CaptureTextWithContext(text, 'clipboard', '{}'),
|
|
CaptureURLWithContext: async (url, title, source, contextJSON) => {
|
|
const ctx = parseCaptureContext(contextJSON);
|
|
const hostname = hostnameForURL(url);
|
|
const node = { id: 'node-capture-url-' + Date.now(), title: title || hostname || url, type: 'link', section: '', captureInbox: true, captureKind: 'url', sourceKind: 'url', captureSource: source || 'paste', captureStatus: 'unresolved', url, hostname, createdAt: now, capturedAt: now, has_children: false, children: [], ...ctx };
|
|
state.nodes.push(node);
|
|
return clone(inboxDTO(node));
|
|
},
|
|
CaptureURL: async (url, title) => App.CaptureURLWithContext(url, title, 'clipboard', '{}'),
|
|
CapturePathWithContext: async (sourcePath, source, contextJSON) => {
|
|
const ctx = parseCaptureContext(contextJSON);
|
|
const title = String(sourcePath || '').split('/').filter(Boolean).pop() || 'Dropped file';
|
|
const kind = title.includes('folder') ? 'folder' : 'file';
|
|
const node = { id: 'node-capture-path-' + Date.now(), title, type: kind === 'folder' ? 'folder' : 'file', section: '', captureInbox: true, captureKind: kind, sourceKind: kind, captureSource: source || 'drop', captureStatus: 'unresolved', createdAt: now, capturedAt: now, has_children: false, children: [], ...ctx };
|
|
if (kind === 'folder') {
|
|
state.files[node.id] = [{ id: 'captured-folder-file', nodeId: 'captured-folder-file', fileId: 'captured-folder-file', name: 'captured-folder-file.txt', type: 'file', size: 42, createdAt: now }];
|
|
} else {
|
|
state.files[node.id] = [{ id: node.id, nodeId: node.id, fileId: node.id, name: title, type: 'file', size: 42, createdAt: now }];
|
|
}
|
|
state.nodes.push(node);
|
|
return clone(inboxDTO(node));
|
|
},
|
|
CapturePath: async (sourcePath) => App.CapturePathWithContext(sourcePath, 'drop', '{}'),
|
|
CaptureFileDataWithContext: async (filename, _dataBase64, source, contextJSON) => {
|
|
const ctx = parseCaptureContext(contextJSON);
|
|
const node = { id: 'node-capture-data-' + Date.now(), title: filename, type: 'file', section: '', captureInbox: true, captureKind: filename.endsWith('.png') ? 'image' : 'file', sourceKind: filename.endsWith('.png') ? 'image' : 'file', captureSource: source || 'paste', captureStatus: 'unresolved', createdAt: now, capturedAt: now, has_children: false, children: [], ...ctx };
|
|
state.files[node.id] = [{ id: node.id, nodeId: node.id, fileId: node.id, name: filename, type: 'file', size: 32, mime: filename.endsWith('.png') ? 'image/png' : 'text/plain', createdAt: now }];
|
|
state.nodes.push(node);
|
|
return clone(inboxDTO(node));
|
|
},
|
|
CaptureFileData: async (filename, dataBase64) => App.CaptureFileDataWithContext(filename, dataBase64, 'clipboard', '{}'),
|
|
ReadClipboardText: async () => window.__VERSTAK_GUI_SMOKE_CLIPBOARD__ || '',
|
|
CaptureClipboardTextWithContext: async (contextJSON) => {
|
|
const text = String(window.__VERSTAK_GUI_SMOKE_CLIPBOARD__ || '').trim();
|
|
if (!text) throw new Error('clipboard is empty');
|
|
const normalizedURL = normalizeURL(text);
|
|
if (normalizedURL) return App.CaptureURLWithContext(normalizedURL, '', 'clipboard_button', contextJSON);
|
|
return App.CaptureTextWithContext(text, 'clipboard_button', contextJSON);
|
|
},
|
|
ResolveInboxNode: async (nodeId, targetParentId) => {
|
|
const node = detachNode(nodeId);
|
|
const parent = findNode(targetParentId);
|
|
if (!node || !parent) throw new Error('assign target not found');
|
|
if (node.sourceKind === 'url' || node.captureKind === 'url') {
|
|
state.links[targetParentId] = state.links[targetParentId] || [];
|
|
state.links[targetParentId].push({ id: 'link-' + Date.now(), nodeId: targetParentId, title: node.title, url: node.url, hostname: node.hostname || hostnameForURL(node.url), note: '', source: node.captureSource, capturedAt: node.capturedAt || now, createdAt: now, updatedAt: now });
|
|
return clone(parent);
|
|
}
|
|
node.captureInbox = false;
|
|
node.captureKind = '';
|
|
node.captureSource = '';
|
|
node.parent_id = targetParentId;
|
|
parent.children = parent.children || [];
|
|
parent.children.push(node);
|
|
parent.has_children = true;
|
|
return clone(node);
|
|
},
|
|
ResolveInboxNodeHere: async (nodeId) => {
|
|
const node = findNode(nodeId);
|
|
if (!node?.suggestedTargetNodeId) throw new Error('suggested target is required');
|
|
return App.ResolveInboxNode(nodeId, node.suggestedTargetNodeId);
|
|
},
|
|
AssignInboxNode: async (nodeId, targetParentId) => App.ResolveInboxNode(nodeId, targetParentId),
|
|
DeleteInboxNode: async (nodeId) => {
|
|
const node = detachNode(nodeId);
|
|
if (!node) throw new Error('inbox node not found');
|
|
return true;
|
|
},
|
|
ListLinks: async (nodeId) => clone(state.links[nodeId] || []),
|
|
UpdateLink: async (id, title, url, note) => {
|
|
const list = Object.values(state.links).flat();
|
|
const link = list.find((item) => item.id === id);
|
|
if (!link) throw new Error('link not found');
|
|
Object.assign(link, { title, url, note, hostname: hostnameForURL(url), updatedAt: now });
|
|
return clone(link);
|
|
},
|
|
DeleteLink: async (id) => {
|
|
for (const key of Object.keys(state.links)) {
|
|
state.links[key] = state.links[key].filter((link) => link.id !== id);
|
|
}
|
|
return true;
|
|
},
|
|
OpenLink: async () => true,
|
|
OpenURL: async (url) => { state.openedUrls.push(url); return true },
|
|
ListTrash: async () => clone({
|
|
trashPath: '/tmp/verstak-smoke-vault/.verstak/trash',
|
|
count: state.trashNodes.length,
|
|
nodes: state.trashNodes,
|
|
entries: [{ name: 'node-trash_Trash-Smoke-Folder', path: '/tmp/verstak-smoke-vault/.verstak/trash/node-trash_Trash-Smoke-Folder', isDir: true, size: 0, modifiedAt: now }],
|
|
}),
|
|
TrashCount: async () => state.trashNodes.length,
|
|
RestoreTrashNodesJSON: async (idsJSON) => {
|
|
const ids = JSON.parse(idsJSON || '[]');
|
|
state.trashNodes = state.trashNodes.filter((node) => !ids.includes(node.id));
|
|
return true;
|
|
},
|
|
PurgeTrashNodesJSON: async (idsJSON) => {
|
|
const ids = JSON.parse(idsJSON || '[]');
|
|
state.trashNodes = state.trashNodes.filter((node) => !ids.includes(node.id) && !ids.includes(node.parentId));
|
|
return true;
|
|
},
|
|
EmptyTrash: async () => { state.trashNodes = []; return true },
|
|
OpenTrashFolder: async () => true,
|
|
ListEnabledTemplates: async () => clone(templates),
|
|
AllTemplates: async () => clone(templates),
|
|
SetTemplateEnabled: async () => true,
|
|
GetNodeDetail: async (id) => clone(findNode(id) || fileNodeDetails[id] || null),
|
|
GetNodeTitle: async (id) => findNode(id)?.title || '',
|
|
Search: async (query) => {
|
|
const q = String(query || '').toLowerCase();
|
|
return [
|
|
{ nodeId: 'node-project', title: 'Smoke Project', type: 'project', path: 'Верстак / Smoke Project', snippet: '' },
|
|
{ nodeId: 'note-1', title: 'Smoke note', type: 'note', path: 'Верстак / Smoke Project', snippet: 'Rendered by GUI smoke.' },
|
|
{ nodeId: 'file-brief', title: 'brief.md', type: 'file', path: 'Верстак / Smoke Project / Assets', snippet: '' },
|
|
{ nodeId: 'link-smoke', title: 'example.test', type: 'link', path: 'Верстак / Smoke Project', snippet: 'https://example.test' },
|
|
].filter((item) => (item.title + ' ' + item.snippet + ' ' + item.path).toLowerCase().includes(q));
|
|
},
|
|
SearchNodes: async (query) => allNodes().filter((node) => node.title.toLowerCase().includes(String(query || '').toLowerCase())).map((node) => ({ id: node.id, title: node.title, path: '/Smoke/' + node.title, type: node.type })),
|
|
CreateNodeFromTemplate: async (parentId, title, templateId) => {
|
|
const id = 'node-created-' + Date.now();
|
|
const parent = parentId ? findNode(parentId) : null;
|
|
const node = { id, title, type: templateId?.split('.')[0] || 'folder', section: parent?.section || '', parent_id: parentId || '', createdAt: now, has_children: false, children: [] };
|
|
if (parentId) {
|
|
if (parent) {
|
|
parent.children = parent.children || [];
|
|
parent.children.push(node);
|
|
parent.has_children = true;
|
|
}
|
|
} else {
|
|
state.nodes.push(node);
|
|
}
|
|
return clone(node);
|
|
},
|
|
MoveNode: async () => true,
|
|
DuplicateNode: async () => true,
|
|
DeleteNode: async () => true,
|
|
RenameNode: async () => true,
|
|
ValidateName: async () => true,
|
|
OpenFolder: async () => true,
|
|
|
|
ListTodayView: async () => ({
|
|
date: '2026-06-04',
|
|
summary: { changedCases: 1, notes: 1, files: 1 },
|
|
groups: [{ nodeId: 'node-project', nodeTitle: 'Smoke Project', nodeKind: 'project', lastActivityAt: now, events }],
|
|
events,
|
|
}),
|
|
ListActivityFeed: async () => clone(events),
|
|
ListActivityByNode: async (nodeId) => clone(events.filter((event) => event.nodeId === nodeId)),
|
|
|
|
ListNotes: async (nodeId) => clone(state.notes[nodeId] || []),
|
|
CreateNote: async (nodeId, title) => {
|
|
const note = { id: 'note-' + Date.now(), title, createdAt: now };
|
|
state.notes[nodeId] = [...(state.notes[nodeId] || []), note];
|
|
state.noteContent[note.id] = '# ' + title;
|
|
return clone(note);
|
|
},
|
|
ReadNote: async (id) => state.noteContent[id] || '',
|
|
SaveNote: async (id, content) => { state.noteContent[id] = content; return true; },
|
|
|
|
ListItems: async (folderId) => clone(state.files[folderId] || []),
|
|
ListFiles: async (nodeId) => clone(state.files[nodeId] || []),
|
|
CreateEmptyFile: async (parentId, name) => {
|
|
const file = { id: 'file-' + Date.now(), nodeId: 'file-' + Date.now(), fileId: 'file-' + Date.now(), name, type: 'file', size: 0, createdAt: now };
|
|
state.files[parentId] = [...(state.files[parentId] || []), file];
|
|
return clone(file);
|
|
},
|
|
PickFile: async () => '/tmp/smoke.txt',
|
|
PreviewImport: async () => ({ files: 1, folders: 0, totalBytes: 64, isDangerous: false }),
|
|
AddPathCopy: async () => true,
|
|
AddPathLink: async () => true,
|
|
DeleteFileOrFolder: async () => true,
|
|
OpenFile: async () => true,
|
|
GetFileBase64: async () => 'data:image/png;base64,c21va2UtaW1hZ2U=',
|
|
ReadFileText: async () => 'Smoke file content',
|
|
|
|
ListActions: async (nodeId) => clone(state.actions[nodeId] || []),
|
|
CreateAction: async (nodeId, kind, title, data) => {
|
|
const action = { id: 'action-' + Date.now(), title, type: kind, data };
|
|
state.actions[nodeId] = [...(state.actions[nodeId] || []), action];
|
|
return clone(action);
|
|
},
|
|
DeleteAction: async () => true,
|
|
RunAction: async () => true,
|
|
|
|
ListWorklog: async (nodeId) => clone(state.worklog[nodeId] || []),
|
|
CreateWorklogFull: async (nodeId, summary, details, date, minutes, approximate, billable) => {
|
|
const entry = { id: 'wl-' + Date.now(), nodeId, summary, details, date, minutes, approximate, billable, source: 'manual', createdAt: now };
|
|
state.worklog[nodeId] = [...(state.worklog[nodeId] || []), entry];
|
|
return clone(entry);
|
|
},
|
|
UpdateWorklogEntry: async (id, summary, details, date, minutes, approximate, billable) => {
|
|
for (const nodeId of Object.keys(state.worklog)) {
|
|
const idx = state.worklog[nodeId].findIndex((entry) => entry.id === id);
|
|
if (idx >= 0) {
|
|
const updated = { ...state.worklog[nodeId][idx], summary, details, date, minutes, approximate, billable, updatedAt: now };
|
|
state.worklog[nodeId][idx] = updated;
|
|
return clone(updated);
|
|
}
|
|
}
|
|
throw new Error('worklog entry not found');
|
|
},
|
|
DeleteWorklogEntry: async (id) => {
|
|
for (const nodeId of Object.keys(state.worklog)) {
|
|
state.worklog[nodeId] = state.worklog[nodeId].filter((entry) => entry.id !== id);
|
|
}
|
|
return true;
|
|
},
|
|
GetSuggestions: async () => [{
|
|
nodeId: 'node-project',
|
|
nodeTitle: 'Smoke Project',
|
|
summary: 'Review smoke activity',
|
|
suggestedMin: 20,
|
|
confidence: 'high',
|
|
eventIds: events.map((event) => event.id),
|
|
events,
|
|
}],
|
|
AcceptSuggestionWith: async () => true,
|
|
AcceptSuggestionFull: async (nodeId, summary, details, date, minutes, approximate, billable) => {
|
|
const entry = { id: 'wl-suggestion-' + Date.now(), nodeId, summary, details, date: date || '2026-06-04', minutes, approximate, billable, source: 'suggestion', createdAt: now };
|
|
state.worklog[nodeId] = [...(state.worklog[nodeId] || []), entry];
|
|
return clone(entry);
|
|
},
|
|
ListWorklogReport: async () => clone(state.worklog['node-project'].map((entry) => ({ ...entry, nodeTitle: 'Smoke Project', nodePath: '/Smoke Project', _hasEvents: false }))),
|
|
WorklogReportSummary: async () => ({ totalMinutes: 45, totalEntries: 1, byDay: [{ label: '2026-06-04', minutes: 45, count: 1 }], byNode: [{ label: 'Smoke Project', minutes: 45, count: 1 }] }),
|
|
GetWorklogEntryEvents: async () => [],
|
|
SaveWorklogReport: async (format) => 'saved ' + format,
|
|
|
|
SyncStatus: async () => ({ configured: true, serverUrl: 'https://sync.example.test', deviceId: 'smoke-device', deviceName: 'Smoke Device', connected: true, revoked: false, unpushedOps: 0 }),
|
|
GetSyncSettings: async () => ({ enabled: true, serverUrl: 'https://sync.example.test', deviceId: 'smoke-device', deviceName: 'Smoke Device', syncInterval: 0, lastStatus: 'connected' }),
|
|
SyncNow: async () => ({ pushed: 0, pulled: 0, conflicts: [{ entityId: 'node-project' }], applyErrors: [{ opId: 'remote-op-1', error: 'smoke apply error' }] }),
|
|
SyncTestConnection: async () => true,
|
|
SyncConfigure: async () => true,
|
|
SyncSetInterval: async () => true,
|
|
SyncDisconnect: async () => true,
|
|
ResetSyncKey: async () => true,
|
|
WriteDebugLog: async () => true,
|
|
OpenPluginsFolder: async () => true,
|
|
OpenVaultFolder: async () => true,
|
|
};
|
|
|
|
window.go = { main: { App } };
|
|
const runtimeHandlers = {};
|
|
window.runtime = {
|
|
EventsOn: (name, handler) => { runtimeHandlers[name] = handler; },
|
|
EventsOff: (name) => { delete runtimeHandlers[name]; },
|
|
};
|
|
window.__VERSTAK_GUI_SMOKE__ = {
|
|
mode,
|
|
state,
|
|
events,
|
|
dropFiles: async (paths) => {
|
|
if (runtimeHandlers['files-dropped']) await runtimeHandlers['files-dropped'](paths);
|
|
},
|
|
deleteNode: async (id) => {
|
|
detachNode(id);
|
|
},
|
|
};
|
|
})();
|
|
`
|
|
}
|