body {
    font-family: Georama;
}

h1 {
    color: #6F8AF6 !important;
}

h2 {
    color: #6F8AF6 !important;
}

h3 {
    color: #6F8AF6 !important;
}

h4 {
    color: #6F8AF6 !important;
}

.two-columns {
    display: grid; 
    grid-template-columns: 1fr 1fr;
    gap: 10px
}

.two-columns h4 {
    margin-top: 0 !important;
}

.group {
    line-height: 140% !important;
}

.avatar-sample {
    grid-template-columns: 1fr 1fr 1fr;
    display: grid;
    gap: 10px;
}

@media only screen and (max-width: 600px) {
    .avatar-sample {
        grid-template-columns: 1fr;
    }
}

/* ─── Search modal ─────────────────────────────────────────────────────────── */

#ts-overlay {
    display: none;
    position: fixed;
    inset: 0;
    z-index: 99999;
    background: rgba(0, 0, 0, 0.55);
    align-items: flex-start;
    justify-content: center;
    padding-top: 12vh;
    backdrop-filter: blur(2px);
}

#ts-modal {
    background: #ffffff;
    border-radius: 14px;
    width: 100%;
    max-width: 620px;
    margin: 0 16px;
    box-shadow: 0 24px 64px rgba(0, 0, 0, 0.28);
    overflow: hidden;
    font-family: Georama, system-ui, sans-serif;
}

:root[class*="dark"] #ts-modal,
.dark #ts-modal {
    background: #1c1c1e;
    border: 1px solid rgba(255, 255, 255, 0.1);
}

#ts-input-row {
    display: flex;
    align-items: center;
    gap: 10px;
    padding: 14px 18px;
    border-bottom: 1px solid #ebebeb;
}

:root[class*="dark"] #ts-input-row,
.dark #ts-input-row {
    border-bottom-color: rgba(255, 255, 255, 0.08);
}

#ts-icon {
    width: 18px;
    height: 18px;
    flex-shrink: 0;
    color: #9ca3af;
}

#ts-input {
    flex: 1;
    border: none;
    outline: none;
    background: transparent;
    font-size: 15px;
    color: #111827;
    font-family: inherit;
}

:root[class*="dark"] #ts-input,
.dark #ts-input {
    color: #f3f4f6;
}

#ts-input::placeholder {
    color: #9ca3af;
}

#ts-esc-badge {
    font-size: 11px;
    padding: 2px 6px;
    border-radius: 5px;
    background: #f3f4f6;
    color: #6b7280;
    border: 1px solid #e5e7eb;
    flex-shrink: 0;
}

:root[class*="dark"] #ts-esc-badge,
.dark #ts-esc-badge {
    background: #2d2d2f;
    color: #9ca3af;
    border-color: rgba(255, 255, 255, 0.1);
}

#ts-results {
    max-height: 360px;
    overflow-y: auto;
    padding: 6px 0;
}

.ts-result {
    display: flex;
    flex-direction: column;
    gap: 2px;
    padding: 10px 18px;
    text-decoration: none;
    cursor: pointer;
    transition: background 0.1s;
    border-left: 3px solid transparent;
}

.ts-result:hover,
.ts-result-active {
    background: #f0f4ff;
    border-left-color: #6F8AF6;
}

:root[class*="dark"] .ts-result:hover,
:root[class*="dark"] .ts-result-active,
.dark .ts-result:hover,
.dark .ts-result-active {
    background: rgba(111, 138, 246, 0.12);
    border-left-color: #889EF8;
}

.ts-result-title {
    font-size: 14px;
    font-weight: 600;
    color: #111827;
    line-height: 1.3;
}

:root[class*="dark"] .ts-result-title,
.dark .ts-result-title {
    color: #f3f4f6;
}

.ts-result-desc {
    font-size: 12px;
    color: #6b7280;
    line-height: 1.4;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
}

#ts-footer {
    display: flex;
    gap: 16px;
    padding: 8px 18px;
    border-top: 1px solid #ebebeb;
    font-size: 11px;
    color: #9ca3af;
}

:root[class*="dark"] #ts-footer,
.dark #ts-footer {
    border-top-color: rgba(255, 255, 255, 0.08);
}

#ts-footer kbd {
    display: inline-block;
    padding: 1px 5px;
    border-radius: 4px;
    background: #f3f4f6;
    border: 1px solid #e5e7eb;
    color: #374151;
    font-size: 10px;
    margin-right: 2px;
}

:root[class*="dark"] #ts-footer kbd,
.dark #ts-footer kbd {
    background: #2d2d2f;
    border-color: rgba(255, 255, 255, 0.1);
    color: #d1d5db;
}

@media (max-width: 600px) {
    #ts-overlay {
        padding-top: 0;
        align-items: flex-end;
    }
    #ts-modal {
        border-radius: 14px 14px 0 0;
        margin: 0;
        max-width: 100%;
    }
}


.changelog-table {
  width: 100%;
  border-collapse: collapse;
  margin: 1rem 0;
}

.changelog-table th,
.changelog-table td {
  padding: 0.75rem;
  text-align: left;
  border-bottom: 1px solid var(--mint-border-color);
}

.changelog-table th {
  font-weight: 600;
  background-color: var(--mint-bg-color);
}

.changelog-table tr:hover {
  background-color: var(--mint-bg-color);
} 

// ─── Search modal ────────────────────────────────────────────────────────────

(function initDocSearch() {
  var fuseInstance = null;
  var modalOpen = false;
  var selectedIndex = -1;

  function loadScript(src, onLoad) {
    var s = document.createElement("script");
    s.src = src;
    s.onload = onLoad;
    document.head.appendChild(s);
  }

  function fetchSearchIndex(onReady) {
    fetch("/search-index.json")
      .then(function (r) { return r.json(); })
      .then(function (data) { onReady(data); })
      .catch(function (err) {
        console.warn("[tolky-search] index not available:", err);
      });
  }

  function buildFuse(data) {
    fuseInstance = new Fuse(data, {
      keys: [
        { name: "title", weight: 0.6 },
        { name: "description", weight: 0.3 },
        { name: "text", weight: 0.1 },
      ],
      threshold: 0.4,
      includeScore: true,
      minMatchCharLength: 2,
    });
  }

  function createModal() {
    var overlay = document.createElement("div");
    overlay.id = "ts-overlay";
    overlay.setAttribute("role", "dialog");
    overlay.setAttribute("aria-modal", "true");
    overlay.setAttribute("aria-label", "Buscar na documentação");
    overlay.innerHTML =
      '<div id="ts-modal">' +
        '<div id="ts-input-row">' +
          '<svg id="ts-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>' +
          '<input id="ts-input" type="text" placeholder="Buscar na documentação…" autocomplete="off" spellcheck="false" />' +
          '<kbd id="ts-esc-badge">Esc</kbd>' +
        "</div>" +
        '<div id="ts-results"></div>' +
        '<div id="ts-footer">' +
          "<span><kbd>↵</kbd> abrir</span>" +
          "<span><kbd>↑</kbd><kbd>↓</kbd> navegar</span>" +
          "<span><kbd>Esc</kbd> fechar</span>" +
        "</div>" +
      "</div>";

    overlay.addEventListener("click", function (e) {
      if (e.target === overlay) closeModal();
    });

    document.body.appendChild(overlay);

    document.getElementById("ts-input").addEventListener("input", onInput);
    document.getElementById("ts-input").addEventListener("keydown", onKeydown);
  }

  function onInput(e) {
    var query = e.target.value.trim();
    selectedIndex = -1;
    renderResults(query ? fuseInstance && fuseInstance.search(query, { limit: 8 }) : []);
  }

  function renderResults(results) {
    var container = document.getElementById("ts-results");
    if (!results || !results.length) {
      container.innerHTML = "";
      return;
    }
    container.innerHTML = results.map(function (r, i) {
      return (
        '<a class="ts-result" href="' + r.item.url + '" data-idx="' + i + '">' +
          '<span class="ts-result-title">' + escapeHtml(r.item.title) + "</span>" +
          (r.item.description
            ? '<span class="ts-result-desc">' + escapeHtml(r.item.description) + "</span>"
            : "") +
        "</a>"
      );
    }).join("");

    container.querySelectorAll(".ts-result").forEach(function (el) {
      el.addEventListener("click", closeModal);
    });
  }

  function escapeHtml(str) {
    return str.replace(/[&<>"']/g, function (c) {
      return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c];
    });
  }

  function onKeydown(e) {
    var results = document.querySelectorAll(".ts-result");
    if (e.key === "ArrowDown") {
      e.preventDefault();
      selectedIndex = Math.min(selectedIndex + 1, results.length - 1);
      highlightSelected(results);
    } else if (e.key === "ArrowUp") {
      e.preventDefault();
      selectedIndex = Math.max(selectedIndex - 1, 0);
      highlightSelected(results);
    } else if (e.key === "Enter" && selectedIndex >= 0) {
      e.preventDefault();
      if (results[selectedIndex]) results[selectedIndex].click();
    } else if (e.key === "Escape") {
      closeModal();
    }
  }

  function highlightSelected(results) {
    results.forEach(function (el, i) {
      el.classList.toggle("ts-result-active", i === selectedIndex);
    });
    if (results[selectedIndex]) {
      results[selectedIndex].scrollIntoView({ block: "nearest" });
    }
  }

  function openModal() {
    if (modalOpen) return;
    modalOpen = true;
    var overlay = document.getElementById("ts-overlay");
    if (!overlay) createModal();
    document.getElementById("ts-overlay").style.display = "flex";
    document.getElementById("ts-results").innerHTML = "";
    document.getElementById("ts-input").value = "";
    selectedIndex = -1;
    setTimeout(function () {
      var input = document.getElementById("ts-input");
      if (input) input.focus();
    }, 50);
  }

  function closeModal() {
    modalOpen = false;
    var overlay = document.getElementById("ts-overlay");
    if (overlay) overlay.style.display = "none";
  }

  function interceptNativeSearchButton() {
    var selectors = [
      'button[id*="search"]',
      'button[class*="search"]',
      '[role="search"] button',
      'button[aria-label*="search" i]',
      'button[aria-label*="busca" i]',
      'button[aria-label*="buscar" i]',
    ];
    for (var i = 0; i < selectors.length; i++) {
      var btn = document.querySelector(selectors[i]);
      if (btn) {
        btn.addEventListener("click", function (e) {
          e.stopPropagation();
          e.preventDefault();
          openModal();
        }, true);
        return true;
      }
    }
    var allButtons = document.querySelectorAll("button");
    for (var j = 0; j < allButtons.length; j++) {
      var text = allButtons[j].textContent || "";
      if (text.indexOf("⌘K") !== -1 || text.indexOf("Ctrl K") !== -1 || text.indexOf("Search") !== -1) {
        allButtons[j].addEventListener("click", function (e) {
          e.stopPropagation();
          e.preventDefault();
          openModal();
        }, true);
        return true;
      }
    }
    return false;
  }

  document.addEventListener("keydown", function (e) {
    if ((e.metaKey || e.ctrlKey) && e.key === "k") {
      e.preventDefault();
      e.stopPropagation();
      openModal();
    }
    if (e.key === "Escape" && modalOpen) closeModal();
  }, true);

  loadScript(
    "https://cdn.jsdelivr.net/npm/fuse.js@7.0.0/dist/fuse.min.js",
    function () {
      fetchSearchIndex(function (data) {
        buildFuse(data);
        if (!interceptNativeSearchButton()) {
          var observer = new MutationObserver(function () {
            if (interceptNativeSearchButton()) observer.disconnect();
          });
          observer.observe(document.body, { childList: true, subtree: true });
        }
      });
    }
  );
})();

// ─────────────────────────────────────────────────────────────────────────────

// Cria um novo elemento link para o CSS
var link = document.createElement('link');
link.rel = 'stylesheet';
link.href = 'https://minichat.tolky.to/css/style.css';

// Adiciona o elemento link ao head do documento
document.head.appendChild(link);


// Cria um novo elemento script para o JavaScript
var script = document.createElement('script');
script.type = 'module';
script.async = true;
script.src = 'https://minichat.tolky.to/main.js';

// Adiciona o elemento script ao documento
document.body.appendChild(script);


// Configura o objeto tolky no window
window.tolky = window.tolky || {
    config: {
        slug: 'us',
        firstMessage: 'Olá, em que posso ajudá-lo?'
    }
};

// Cria um novo elemento link para o CSS
var font = document.createElement('link');
font.rel = 'stylesheet';
font.href = 'https://fonts.googleapis.com/css2?family=Georama:ital,wght@0,100..700;1,100..700&display=swap';


// Adiciona o elemento link ao head do documento
document.head.appendChild(font);

/*
  Build a search index JSON from all MDX files in the project.
  Output: public/search-index.json
  Run: node scripts/docs/build-search-index.js
*/

const fs = require("fs");
const path = require("path");

const PROJECT_ROOT = path.resolve(__dirname, "..", "..");
const OUTPUT_FILE = path.join(PROJECT_ROOT, "public", "search-index.json");

const INDEXED_DIRS = ["content", "changelog", "essentials", "documents"];
const INDEXED_ROOT_FILES = ["introduction.mdx"];

function collectMdxFiles(dir) {
  if (!fs.existsSync(dir)) return [];

  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
    if (entry.name.startsWith(".") || entry.name.startsWith("_")) return [];
    const fullPath = path.join(dir, entry.name);
    if (entry.isDirectory()) return collectMdxFiles(fullPath);
    if (entry.name.endsWith(".mdx") || entry.name.endsWith(".md"))
      return [fullPath];
    return [];
  });
}

function parseFrontmatter(content) {
  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
  if (!match) return {};

  const result = {};
  for (const line of match[1].split("\n")) {
    const colonIndex = line.indexOf(":");
    if (colonIndex === -1) continue;
    const key = line.slice(0, colonIndex).trim();
    const value = line
      .slice(colonIndex + 1)
      .trim()
      .replace(/^["']|["']$/g, "");
    if (key) result[key] = value;
  }

  return result;
}

function extractPlainText(content) {
  return content
    .replace(/^---[\s\S]*?---\r?\n/, "")
    .replace(/^import\s+.*$/gm, "")
    .replace(/^export\s+.*$/gm, "")
    .replace(/```[\s\S]*?```/g, "")
    .replace(/`[^`]+`/g, "")
    .replace(/<[^>]+>/g, " ")
    .replace(/^#{1,6}\s+/gm, "")
    .replace(/\[([^\]]+)\]$[^)]+$/g, "$1")
    .replace(/[*_]{1,2}([^*_\n]+)[*_]{1,2}/g, "$1")
    .replace(/^\s*[-*+>]\s+/gm, "")
    .replace(/\s+/g, " ")
    .trim()
    .slice(0, 400);
}

function filePathToUrl(filePath) {
  return (
    "/" +
    path
      .relative(PROJECT_ROOT, filePath)
      .replace(/\\/g, "/")
      .replace(/\.mdx?$/, "")
  );
}

function buildEntry(filePath) {
  const content = fs.readFileSync(filePath, "utf-8");
  const frontmatter = parseFrontmatter(content);
  const text = extractPlainText(content);
  const url = filePathToUrl(filePath);
  const title =
    frontmatter.title ||
    path.basename(filePath, path.extname(filePath)).replace(/-/g, " ");

  return {
    title,
    description: frontmatter.description || "",
    url,
    text,
  };
}

function run() {
  const allFiles = [
    ...INDEXED_ROOT_FILES.map((f) => path.join(PROJECT_ROOT, f)).filter((f) =>
      fs.existsSync(f)
    ),
    ...INDEXED_DIRS.flatMap((dir) =>
      collectMdxFiles(path.join(PROJECT_ROOT, dir))
    ),
  ];

  const entries = allFiles.map(buildEntry);

  fs.mkdirSync(path.dirname(OUTPUT_FILE), { recursive: true });
  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(entries));

  console.log(
    `Search index built: ${entries.length} pages → ${path.relative(PROJECT_ROOT, OUTPUT_FILE)}`
  );
}

run();



/*
  Generate changelog/index.mdx from files in changelog/ directory.
  - Reads all files matching v*.mdx
  - Extracts frontmatter title/description if present
  - Derives version and date from content when possible
  - Sorts by semantic-ish version (desc) then by file mtime
*/

const fs = require("fs");
const path = require("path");

const CHANGELOG_DIR = path.join(process.cwd(), "changelog");
const INDEX_FILE = path.join(CHANGELOG_DIR, "index.mdx");

function readFileSafe(filePath) {
  try {
    return fs.readFileSync(filePath, "utf8");
  } catch (e) {
    return "";
  }
}

function parseFrontmatter(content) {
  const fmMatch = content.match(/^---[\s\S]*?---/);
  if (!fmMatch) return {};
  const fm = fmMatch[0].replace(/^---\n?|\n?---$/g, "");
  const result = {};
  for (const line of fm.split("\n")) {
    const m = line.match(/^([a-zA-Z0-9_\-]+):\s*(.*)$/);
    if (m) {
      const key = m[1].trim();
      let value = m[2].trim();
      value = value.replace(/^"|"$/g, "").replace(/^'|'$/g, "");
      result[key] = value;
    }
  }
  return result;
}

function extractVersionFromFilename(filename) {
  const base = path.basename(filename, ".mdx");
  return base; // e.g., v3.0.31 or v1.0.418-prod
}

function extractDateFromContent(content) {
  // Look for patterns like 03 de Agosto, 2025 or 15 de Janeiro, 2025 etc.
  const dateMatch = content.match(
    /\b(\d{1,2})\s+de\s+[A-Za-zçáéíóúãõ]+,\s+(\d{4})/
  );
  if (dateMatch) return dateMatch[0];
  // Or YYYY-MM-DD-ish
  const isoMatch = content.match(/\b\d{4}-\d{2}-\d{2}\b/);
  if (isoMatch) return isoMatch[0];
  return null;
}

function toSortableVersion(ver) {
  // Extract numeric parts from vX.Y.Z[-label]
  const m = ver.match(/^v?(\d+)\.(\d+)\.(\d+)/);
  if (!m) return [-1, -1, -1];
  return [parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10)];
}

function generateIndex(items) {
  const header =
    `---\n` +
    `title: "Novidades no Tolky"\n` +
    `description: "Acompanhe todas as atualizações e melhorias do Tolky"\n` +
    `icon: "star"\n` +
    `---\n\n` +
    `## Índice de Versões\n\n`;

  const rows = [
    "| Versão      | Descrição                               | Data de Publicação  | Detalhes                           |",
    "| ----------- | --------------------------------------- | ------------------- | ---------------------------------- |",
  ];

  for (const it of items) {
    const version = `**${it.version}**`;
    const description = it.description || it.title || "";
    const date = it.date || "";
    const link = `[Ver detalhes](/changelog/${it.slug})`;
    rows.push(`| ${version} | ${description} | ${date} | ${link} |`);
  }

  const sections = items
    .map((it) => {
      const title = it.title || it.version;
      const dateLine = it.date ? `**Data:** ${it.date}  ` : "";
      return `\n### ${title}\n\n${dateLine}\n**Principais melhorias:**\n\n- Consulte os detalhes completos no documento desta versão.\n\n[Ver detalhes completos →](/changelog/${it.slug})\n\n---\n`;
    })
    .join("\n");

  return (
    header +
    rows.join("\n") +
    "\n\n" +
    sections +
    "\n" +
    "_Para mais informações sobre cada versão, clique nos links acima para acessar os detalhes completos de cada atualização._\n"
  );
}

function run() {
  if (!fs.existsSync(CHANGELOG_DIR)) {
    console.error("Changelog directory not found:", CHANGELOG_DIR);
    process.exit(1);
  }

  const files = fs
    .readdirSync(CHANGELOG_DIR)
    .filter(
      (f) =>
        f.endsWith(".mdx") && f !== "index.mdx" && /^v[0-9].*\.mdx$/.test(f)
    );

  const items = files.map((f) => {
    const full = path.join(CHANGELOG_DIR, f);
    const content = readFileSafe(full);
    const fm = parseFrontmatter(content);
    const version = extractVersionFromFilename(f);
    const date = extractDateFromContent(content);
    const title = fm.title || "";
    const description = fm.description || "";
    const stats = fs.statSync(full);
    return {
      slug: version,
      version,
      title,
      description,
      date,
      mtimeMs: stats.mtimeMs,
      sortKey: toSortableVersion(version),
    };
  });

  items.sort((a, b) => {
    // Sort by semantic version desc; fallback to mtime desc
    for (let i = 0; i < 3; i++) {
      if (a.sortKey[i] !== b.sortKey[i]) return b.sortKey[i] - a.sortKey[i];
    }
    return b.mtimeMs - a.mtimeMs;
  });

  const output = generateIndex(items);
  fs.writeFileSync(INDEX_FILE, output, "utf8");
  console.log(
    `Generated ${path.relative(process.cwd(), INDEX_FILE)} with ${
      items.length
    } entries.`
  );
}

run();



#!/usr/bin/env node
/**
 * Script para capturar screenshots do Dashboard v2 (https://v2.gestao.tolky.to)
 * e salvar em docs/images/ para atualização da documentação.
 *
 * Uso:
 *   npm run capture-dashboard
 *
 * Com login automático (credenciais via variáveis de ambiente):
 *   DASHBOARD_EMAIL=seu@email.com DASHBOARD_PASSWORD=sua_senha npm run capture-dashboard
 *
 * Sem credenciais: o script abre o navegador e aguarda login manual + Enter.
 */

const fs = require('fs');
const path = require('path');

const DASHBOARD_URL = 'https://v2.gestao.tolky.to';
const IMAGES_DIR = path.resolve(__dirname, '..', '..', '..', 'images');
const SCREENSHOT_DELAY_MS = 2000;

const SECTION_IDS = [
  'insights',
  'barra-creditos',
  'funil',
  'satisfacao',
  'assuntos',
  'top10',
];

const EMAIL = process.env.DASHBOARD_EMAIL;
const PASSWORD = process.env.DASHBOARD_PASSWORD;
const AUTO_LOGIN = Boolean(EMAIL && PASSWORD);

function ensureImagesDir() {
  if (!fs.existsSync(IMAGES_DIR)) {
    fs.mkdirSync(IMAGES_DIR, { recursive: true });
  }
}

async function performLogin(page) {
  const emailInput =
    (await page.$('input[type="email"]')) ||
    (await page.$('input[name="email"]')) ||
    (await page.$('input[autocomplete="email"]'));
  const passwordInput =
    (await page.$('input[type="password"]')) ||
    (await page.$('input[name="password"]'));

  if (!emailInput || !passwordInput) {
    console.log('Formulário de login não encontrado. Faça login manualmente.');
    return false;
  }

  await emailInput.type(EMAIL, { delay: 50 });
  await passwordInput.type(PASSWORD, { delay: 50 });
  await new Promise((r) => setTimeout(r, 300));

  const submit =
    (await page.$('button[type="submit"]')) ||
    (await page.$('form button')) ||
    (await page.$('button'));
  if (submit) {
    await submit.click();
    await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 15000 }).catch(() => {});
    await new Promise((r) => setTimeout(r, 3000));
    return true;
  }
  return false;
}

async function captureWithPuppeteer() {
  let puppeteer;
  try {
    puppeteer = require('puppeteer');
  } catch {
    console.error('Puppeteer não encontrado. Instale com: npm install -D puppeteer');
    process.exit(1);
  }

  ensureImagesDir();

  const browser = await puppeteer.launch({
    headless: false,
    defaultViewport: { width: 1920, height: 1080 },
    args: ['--start-maximized'],
  });

  const page = await browser.newPage();
  await page.goto(DASHBOARD_URL, { waitUntil: 'networkidle2', timeout: 30000 });

  if (AUTO_LOGIN) {
    console.log('\n=== Tentando login automático ===');
    const loggedIn = await performLogin(page);
    if (!loggedIn) {
      console.log('Login automático falhou. Faça login manualmente e pressione Enter...\n');
      await new Promise((resolve) => process.stdin.once('data', resolve));
    } else {
      console.log('Login realizado. Aguardando carregamento do dashboard...\n');
      await new Promise((r) => setTimeout(r, 4000));
    }
  } else {
    console.log('\n=== Dashboard aberto ===');
    console.log('Faça login manualmente na janela do navegador.');
    console.log('Quando o dashboard estiver visível, pressione Enter para capturar...\n');
    await new Promise((resolve) => process.stdin.once('data', resolve));
  }

  console.log('Capturando screenshots...\n');

  const fullPath = path.join(IMAGES_DIR, 'dashboard-full.png');
  await page.screenshot({ path: fullPath, fullPage: true });
  console.log('  ✓ dashboard-full.png (página completa)');

  await new Promise((r) => setTimeout(r, SCREENSHOT_DELAY_MS));

  const viewportPath = path.join(IMAGES_DIR, 'dashboard-viewport.png');
  await page.screenshot({ path: viewportPath });
  console.log('  ✓ dashboard-viewport.png (viewport)');

  const skipInteractive = process.env.SKIP_INTERACTIVE === '1' || process.env.CI === 'true';
  if (skipInteractive) {
    console.log('\nModo automático: extraindo seções da página completa...');
    const bodyHeight = await page.evaluate(() => document.body.scrollHeight);
    const viewportHeight = 1080;
    const sectionHeight = Math.floor(bodyHeight / SECTION_IDS.length);
    for (let i = 0; i < SECTION_IDS.length; i++) {
      const scrollY = Math.min(i * sectionHeight, bodyHeight - viewportHeight);
      await page.evaluate((y) => window.scrollTo(0, y), scrollY);
      await new Promise((r) => setTimeout(r, 800));
      const sectionPath = path.join(IMAGES_DIR, `${SECTION_IDS[i]}.png`);
      await page.screenshot({ path: sectionPath });
      console.log(`  ✓ ${SECTION_IDS[i]}.png`);
    }
  } else {
    console.log('\nPara capturar seções individuais, role a página até cada seção');
    console.log('e pressione Enter. Os arquivos serão sobrescritos na ordem:');
    SECTION_IDS.forEach((id, i) => console.log(`  ${i + 1}. ${id}.png`));
    console.log('\nPressione Enter para cada seção (ou Ctrl+C para encerrar).\n');
    for (const id of SECTION_IDS) {
      await new Promise((resolve) => process.stdin.once('data', resolve));
      const sectionPath = path.join(IMAGES_DIR, `${id}.png`);
      await page.screenshot({ path: sectionPath });
      console.log(`  ✓ ${id}.png salvo`);
    }
  }

  console.log('\nScreenshots salvos em:', IMAGES_DIR);
  await browser.close();
}

captureWithPuppeteer().catch((err) => {
  console.error('Erro:', err);
  process.exit(1);
});



const { chromium } = require('playwright');
const path = require('path');

const IMAGES_DIR = path.resolve(__dirname, '..', '..', '..', 'images');
const LOGIN_URL = 'https://v2.gestao.tolky.to';

const SECTIONS = [
  {
    filename: 'relatorios-atendimentos.png',
    titleText: 'Atendimentos',
    excludeTitleText: 'Histórico',
    label: 'Atendimentos',
  },
  {
    filename: 'relatorios-horas-economizadas.png',
    titleText: 'Horas Economizadas',
    label: 'Horas Economizadas',
  },
  {
    filename: 'relatorios-respostas.png',
    titleText: 'Respostas',
    excludeTitleText: 'fora',
    label: 'Respostas',
  },
  {
    filename: 'relatorios-fora-horario.png',
    titleText: 'fora do horário',
    label: 'Respostas fora do horário',
  },
  {
    filename: 'relatorios-historico.png',
    titleText: 'Histórico de Atendimentos',
    label: 'Histórico de Atendimentos',
  },
  {
    filename: 'relatorios-tickets.png',
    titleText: 'Distribuição de Tickets',
    label: 'Distribuição de Tickets',
  },
  {
    filename: 'relatorios-campanhas.png',
    titleText: 'Mensagens Enviadas',
    label: 'Campanhas',
  },
  {
    filename: 'relatorios-satisfacao.png',
    titleText: 'Satisfação dos Atendimentos',
    label: 'Satisfação dos Atendimentos',
  },
  {
    filename: 'relatorios-assuntos.png',
    titleText: 'Assuntos mais Relevantes',
    label: 'Assuntos mais Relevantes',
  },
  {
    filename: 'relatorios-smart-tags.png',
    titleText: 'Smart Tags',
    label: 'Smart Tags',
  },
];

async function login(page) {
  await page.goto(LOGIN_URL, { waitUntil: 'networkidle' });

  const emailInput = page.locator('input[type="email"], input[name="email"], input[placeholder*="mail" i]').first();
  await emailInput.waitFor({ timeout: 10000 });
  await emailInput.fill('patrick@tolky.to');

  const passwordInput = page.locator('input[type="password"]').first();
  await passwordInput.fill('Patrick@1234');

  await page.keyboard.press('Enter');
  await page.waitForNavigation({ waitUntil: 'networkidle', timeout: 15000 }).catch(() => {});
  await page.waitForTimeout(2000);
}

const CARD_MAX_WIDTH_RATIO = 0.7;

async function findCardElement(page, titleText, excludeTitleText) {
  const handle = await page.evaluateHandle(
    ({ titleText, excludeTitleText, maxWidthRatio }) => {
      const viewportWidth = window.innerWidth;
      const sidebarMaxX = 180;

      const allText = Array.from(document.querySelectorAll('p, h1, h2, h3, h4, h5, h6, span, div, a'));

      const titleNodes = allText.filter((el) => {
        if (el.children.length > 2) return false;
        const ownText = el.textContent.trim();
        if (!ownText.includes(titleText)) return false;
        if (excludeTitleText && ownText.includes(excludeTitleText)) return false;

        const rect = el.getBoundingClientRect();
        if (rect.x < sidebarMaxX) return false;

        return true;
      });

      for (const node of titleNodes) {
        let candidate = node.parentElement;
        for (let i = 0; i < 10; i++) {
          if (!candidate || candidate === document.body) break;
          const rect = candidate.getBoundingClientRect();
          const widthRatio = rect.width / viewportWidth;
          if (rect.width > 100 && rect.height > 60 && widthRatio < maxWidthRatio) {
            return candidate;
          }
          candidate = candidate.parentElement;
        }
      }
      return null;
    },
    { titleText, excludeTitleText, maxWidthRatio: CARD_MAX_WIDTH_RATIO }
  );

  return handle.asElement();
}

async function screenshotSection(page, section) {
  const outputPath = path.join(IMAGES_DIR, section.filename);

  try {
    const element = await findCardElement(page, section.titleText, section.excludeTitleText);

    if (!element) {
      console.warn(`⚠️  ${section.label}: elemento não encontrado`);
      return;
    }

    await page.evaluate((el) => el.scrollIntoView({ block: 'center' }), element);
    await page.waitForTimeout(400);

    await element.screenshot({ path: outputPath, type: 'png' });
    console.log(`✅ ${section.label} → ${section.filename}`);
  } catch (err) {
    console.warn(`⚠️  ${section.label}: erro → ${err.message}`);
  }
}

async function run() {
  const browser = await chromium.launch({ headless: true });
  const page = await browser.newPage();
  await page.setViewportSize({ width: 1440, height: 900 });

  try {
    console.log('🔐 Fazendo login...');
    await login(page);
    console.log('✅ Login realizado\n');

    for (const section of SECTIONS) {
      await screenshotSection(page, section);
    }

    console.log('\n✅ Todos os screenshots salvos em', IMAGES_DIR);
  } finally {
    await browser.close();
  }
}

run().catch(console.error);



Converse com o Tolky

Comunidade

tolky

Suporte do Tolky

Plataforma de IA conversacional omnicanal para automatizar relacionamentos e transformar o atendimento da sua empresa.

Bem-vindo ao Tolky

Entenda a arquitetura, os conceitos e as boas práticas que fazem o Tolky entregar interações inteligentes, seguras e personalizadas.

Como funciona?

Exemplos de Uso

Compreenda como funcionam os Modelos de Linguagem de Grande Escala (LLM) e como utilizá-los de forma estratégica no Tolky.

Modelos de Linguagem

Entenda os 5 pilares que sustentam um avatar realmente inteligente: identidade & comportamento, base de conhecimento, automações, integrações e busca na internet.

Os 5 Pilares da Inteligência Conversacional

Defina a identidade, o envelope e o comportamento permanente do Avatar.

Identidade e Comportamento

Estruture listas e conteúdos que o Avatar utilizará como base de conhecimento nas conversas.

Base de Conhecimento

Configure fluxos de automação e decisões para o Avatar.

Visão geral

Conecte o avatar a APIs, MCP e outras ferramentas externas.

Integrações

Use a web para ampliar o repertório do avatar com informações vivas e atualizadas.

Busca na Internet

Guia rápido para acessar o painel de administração do Tolky e gerenciar seus avatares e conteúdos.

Ambiente de Gestão

Painel de monitoramento e análise para acompanhar, comprovar e evoluir a performance da IA conversacional do Tolky.

Dashboard

Inbox centralizado para monitorar, filtrar e interagir com todas as conversas do avatar em tempo real.

Atendimentos

Guia funcional e técnico da área de Tickets para operação diária, configuração e integração

Tickets

Criação e acompanhamento de campanhas de disparo de mensagens personalizadas via WhatsApp.

Campanhas

Dashboard de satisfação com análise automática de sentimentos, insights gerados por IA e acompanhamento de NPS.

Feedbacks e NPS

Etiquetas aplicadas automaticamente pela IA para segmentar e identificar padrões nos atendimentos.

Smart Tags

Estrutura prática para treinar o avatar com os três pilares principais

Treinamento do Avatar

Organize e evolua a base de conteúdo que guia as respostas do avatar

Pilar 1 - Chunks

Defina fluxos de decisão para transformar intenção em ação com controle

Pilar 2 - Decisions

Padronize instruções de follow-up para retomadas consistentes e seguras

Pilar 3 - Envelope Instrucional

Boas praticas para reduzir alucinacao operacional com falha segura e contrato deterministico entre API e LLM

Confiabilidade no Envelope Instrucional

Boas práticas para criar e estruturar conteúdo no Tolky, garantindo relevância e eficiência nas respostas do avatar.

Antes de começar

Conjuntos de conteúdo usados para treinar e personalizar os avatares do Tolky.

Datasets

Guia para criar, editar e excluir blocos de conteúdo nos datasets do Tolky.

Adicionando Novos Conteúdos

Guia prático para aplicar formatação Markdown nos blocos de conteúdo do Tolky.

Formatando os Blocos

Guia para incorporar imagens e vídeos em blocos de conteúdo do Tolky utilizando Markdown.

Imagens e Vídeos

Como o Tolky entende significado e contexto nas buscas.

Busca Semântica

Boas práticas para gerenciar conteúdo e datasets no Tolky.

Dicas

Monitorar e interagir com conversas no painel do Tolky.

Gerenciando Mensagens

O widget interativo do Tolky para sites e aplicativos, com personalização total e integração fluida.

Minichat

Guia passo a passo para instalar e configurar o minichat do Tolky no seu site, incluindo a inserção de código HTML e CSS, e o registro de domínios autorizados para uso.

Integrar minichat com meu site

Benefícios de integrar o Tolky ao WhatsApp.

Objetivo da Integração

Como obter chip físico ou número VoIP para WhatsApp Business.

Adquirindo um Chip

Como criar conta na Meta e vincular número ao WhatsApp Business.

Criando Conta na Meta

Instruções detalhadas para conectar sua conta do WhatsApp Business à plataforma Tolky, desde o login até o teste de funcionamento.

Conectando ao Tolky

Lista de verificação para confirmar que todas as etapas de configuração e integração do Tolky com o WhatsApp foram concluídas com sucesso.

Checklist

Como integrar seu sistema ao Power CRM via Power API.

Power CRM

Guia para criar conta no Facebook, configurar Business e conectar WhatsApp ao Tolky.

Manual de Integração WhatsApp

Configuração e exemplos para integração do HubSpot com o Tolky, recebendo dados de tickets, deals e objetos personalizados via API.

Integração HubSpot (Recebimento)

Guia rápido de integração com a API Tolky Reasoning em uma página

Quick Start - API Tolky Reasoning

Obtenha tokens de acesso para hosts associados ao seu domínio.

Obter Tokens de Acesso

Processa perguntas usando a inteligência do Tolky, mantendo o contexto das conversas e retornando respostas personalizadas

Visão Geral

Dispara mensagens com contexto personalizado e instruções específicas para processamento pela IA

Mensagens com IA

Dispara mensagens com texto pré-definido e substituição de variáveis dinâmicas para um ou mais destinatários

Mensagem Fixa

Dispara notificações via WhatsApp usando templates pré-aprovados pela Meta

Mensagem Fixa com Template

Cria uma conversação e retorna os IDs de lead, conversação e sessão para uso com o Tolky Reasoning

Criar ID de Conversação

Atualiza campos de tickets e move entre estágios do pipeline

Atualizar Ticket

Busca tickets por ticketId, leadId ou conversationId com filtros opcionais

Obter Tickets

Registro de funcionalidades da plataforma com busca semântica integrada

Tolky Features

Registra uma nova funcionalidade da plataforma e a torna disponível para busca semântica

Criar feature

Retorna as funcionalidades da plataforma com filtros opcionais por módulo e status

Listar features

Atualiza parcialmente uma funcionalidade existente

Atualizar feature

Desativa uma funcionalidade e a remove da busca semântica

Deletar feature

Como autenticar, consultar, atualizar e resetar a configuração de follow-up via API pública

API Pública de Follow-up

Análise em tempo real e recomendações para melhorar a qualidade de decisions, smart tags e chunks

Advisor

Área dedicada a gerenciar mídias, links e outros assets com verificação de saúde, encurtamento e controle de ciclo de vida.

Buscar Asset

Interpreta expressões em português e devolve datas e horários concretos para agendamentos, reagendamentos e lembretes.

Crono — Guia de Uso

Valida URLs em um texto e substitui links quebrados por um marcador

Validar Links em Texto (Utils)

Gera um token criptografado (hash) a partir de um objeto arbitrário

Gerar Hash (Crypto)

Processa um texto e substitui marcadores {{hash:...}} por tokens {{kripto:...}}

Criptografar Marcadores em Texto (Crypto)

Descriptografa um token (hash) e retorna o objeto original

Recuperar Objeto do Hash (Crypto)

Processa um texto e substitui tokens {{kripto:...}} por seus valores descriptografados

Descriptografar Marcadores em Texto (Crypto)

Endpoint interno para executar a suíte de testes e obter um resumo.

Executar Testes (Jest)

Como o Tolky detecta e trata URLs inválidas em textos e conteúdos.

Verificação de Links Quebrados

Capture e organize dados estruturados de conversas com IA em formulários reutilizáveis

FormFlow

Guia prático para escolher, chamar e combinar captura estruturada e análise de diálogo

FormFlow e Doc Analyzer

Eventos em tempo real para captura, valores e progresso de execução do FormFlow via Socket.IO

WebSocket

Motor genérico que transforma instruções em plano executável, com persistência, retry, auditoria e eventos em tempo real

Sequential Thinking

O que o Sequential Thinking faz, quando usar e exemplos práticos de uso

Retorna o catálogo de ações que o motor pode planejar e executar ao usar runWithAgents

Listar Ações Disponíveis

Executa o motor com ações de sandbox para testes locais, sem efeitos colaterais externos

Executar com Sandbox

Executa o motor com agentes reais do sistema (ragSearch, respondToUser) em produção

Executar com Agentes Reais

Inicia o fluxo OAuth com o SSO do PJe e retorna a URL de autorização para o usuário.

Iniciar Autenticação PDPJ

Verifica o status de autenticação de uma sessão PDPJ a partir do ID de conversa.

Verificar Sessão PDPJ

Extrai informações estruturadas de imagens, áudios, vídeos, documentos e páginas web usando um pipeline multi-modelo com GPT-4.1, Whisper e Gemini 2.0 Flash

Visão Computacional

Repositório central de busca híbrida sobre conversations, leads e tickets com FTS, trigram e busca numérica

Sistema OmniSearch

Baixa e processa um feed XML (ex.: 123i) via streaming, realizando upsert em properties.

Ingestão de Feed XML de Imóveis

Analisa conversas em lote com JSON Schema e instruções; armazena resultados em conversations_reports

Doc Analyzer V4 — Análise em Massa

Converte envelope textual para o JSON canônico base_envelope

Reverse Engineer de Envelope

Reduza e particione conteúdos longos com ou sem IA, via endpoint único

SmartCut

Receitas prontas para usar SmartCut com texto, asset, URL e modos com ou sem IA

SmartCut - Casos de uso

Divida conteúdos longos em blocos temáticos prontos para processamento individual por IA

SmartSplit

Encontra trechos de texto repetidos no payload de IA e mostra exatamente onde estão e quanto espaço estão desperdiçando

Payload Dedup

Acompanhe todas as atualizações e melhorias do Tolky

Novidades no Tolky

O que é a versão 2.0 do Tolky e o que ela representa para a evolução da plataforma

Introdução

Visão geral de todas as mudanças e novidades da versão 2.0 do Tolky, organizadas por página

Resumo das Novidades

Nova interface da plataforma Tolky — navegação redesenhada, carregamento mais rápido, suporte a light/dark mode e seleção de idiomas

Interface

Tela de atendimentos redesenhada — filtros avançados, visualização em tabela, conversa inline e muito mais controle sobre cada interação

Gestão de tickets redesenhada — quadro Kanban, visualização em tabela, detalhes completos do contato e rastreamento de eventos por ticket

Gestão de contatos redesenhada — tabela completa, filtros por período, busca integrada e exportação em CSV e Excel

Contatos

Painel de campanhas redesenhado com resumo de performance, histórico visual e métricas de entrega em tempo real

Nova tela de Identidade — configuração estruturada do avatar com modo simplificado, modo avançado e histórico com reversão

Identidade

A antiga Gestão de Conteúdos foi renomeada e redesenhada como Base de Conhecimento — nova organização por listas, abas de Arquivos e Links, e indicador de espaço utilizado

Início

Entendendo o Tolky

Primeiros Passos

Gerenciando o Avatar

Canais e Integrações

Referência da API

Novidades

Essenciais

V1.0.621

Mudanças

Ajuste na Programação de Follow-Ups