corisco 1.3.11-hml → 1.7.0-hml

package/README.md

@@ -1,428 +1,344 @@
-# ChatJT - Extensão para Captura de Documentos PJe
+# Corisco - Módulo de Extração e Integração de Dados
 
-Esta extensão do Chrome integra com o sistema PJe (Processo Judicial Eletrônico) para capturar documentos automaticamente e enviá-los para o ChatJT.
+O Corisco é uma biblioteca JavaScript desacoplada, projetada para ser injetada em páginas web e atuar como um *content script* inteligente. Sua principal responsabilidade é identificar o contexto da página, carregar ferramentas de extração específicas e fornecer uma interface para a captura de dados, que são então enviados para sistemas externos, como o ChatJT.
 
-## Arquitetura
+## Arquitetura Desacoplada
 
-### Visão Geral
+A arquitetura do Corisco foi desenhada para ser modular e flexível, separando a lógica de extração da extensão de navegador.
 
-A extensão é composta por múltiplos módulos que trabalham em conjunto para detectar, capturar e processar documentos do PJe:
+- **Extensão de Navegador**: Atua como um carregador. Sua única função é injetar o script `corisco.umd.js` nas páginas permitidas.
+- **Corisco (`corisco.umd.js`)**: É o cérebro da operação. Uma vez injetado, ele:
+  1. Analisa a URL atual.
+  2. Consulta o arquivo de configuração (`config.ts`) para determinar qual ferramenta (ex: `pje`) é apropriada para o host.
+  3. Carrega o gerenciador da ferramenta (ex: `PJeManager`).
+  4. O gerenciador inicializa a UI e as ações de extração disponíveis para aquela página.
 
 ```mermaid
 graph TD
-    subgraph Content Script
-        A[content.js] --> B[UI Panel]
-        B --> C[ChatJT Iframe]
+    subgraph "Extensão de Navegador"
+        A[Content Script]
     end
 
-    subgraph PJe Tool
-        D[main.js] --> E[PJeCurrentDocumentCapture]
-        D --> F[PJeSelectedDocuments]
-        D --> G[PJeTimeline]
+    subgraph "Página Web (ex: PJe)"
+        B(corisco.umd.js)
+        C{"Ferramenta <br/> (ex: PJeManager)"}
+        D[UI e Iframe]
     end
-
-    E --> H[Captura Doc. Atual]
-    F --> I[Captura Docs. Selecionados]
-    G --> J[Captura Timeline]
-
-    subgraph Comunicação
-        H --> C
-        I --> C
-        J --> C
-    end
-
+    
+    A -- Injeta --> B
+    B -- Analisa URL e carrega --> C
+    C -- Controla --> D
+    C -- Extrai dados de --> E[DOM da Página]
+    D -- Envia dados para --> F["Serviço Externo (ChatJT)"]
 ```
 
-### Fluxo de Funcionamento
+## Utilização e Build
 
-```mermaid
-sequenceDiagram
-    participant User as Usuário
-    participant Page as Página PJe
-    participant CS as Content Script
-    participant PJeTool as Módulos PJe
-    participant Iframe as ChatJT Iframe
-
-    Page->>CS: Carrega página
-    CS->>PJeTool: Scripts são injetados (manifest.json)
-    PJeTool->>PJeTool: pje-document.js inicializa módulos
-    PJeTool->>Page: Observa mudanças no DOM
-
-    User->>Page: Navega para um documento
-    PJeTool->>PJeTool: Detecta e captura documento
-    PJeTool->>Iframe: Envia dados via postMessage
-
-    User->>Page: Seleciona documentos na timeline
-    User->>Iframe: Clica em "Anexar Selecionados"
-    Iframe->>PJeTool: Solicita extração
-    PJeTool->>Iframe: Envia documentos capturados
-```
+O Corisco é construído como um bundle UMD (Universal Module Definition), o que permite que ele seja facilmente injetado e executado em qualquer ambiente de navegador.
 
-## Estrutura de Arquivos
-
-```text
-chat-jt-extensao/
-├── manifest.json              # Configuração da extensão
-├── config.js                  # Configurações centralizadas
-├── content.js                 # Script principal injetado
-├── popup/                     # Interface do popup
-├── tools/                     # Módulos de captura PJe
-│   └── pje
-│       ├── main.js                    # Gerenciador principal
-│       ├── pje-current-document.js    # Captura documento atual
-│       ├── pje-selected-documents.js  # Captura documentos selecionados
-│       └── pje-timeline.js            # Extração da timeline
-├── public/                    # Assets (ícones, etc.)
-└── styles/                    # Estilos CSS
-```
-
-## Módulos Principais
-
-### 1. Main (Gerenciador Principal)
-
-- **Responsabilidade**: Coordena todos os módulos e gerencia comunicação
-- **Funcionalidades**:
-  - Inicialização dos módulos especializados
-  - Distribuição de mensagens entre módulos
-  - Métodos comuns (extração de IDs, download de PDFs, etc.)
-
-### 2. PJeCurrentDocumentCapture
-
-- **Responsabilidade**: Captura do documento atualmente visualizado
-- **Funcionalidades**:
-  - Detecção automática de documentos
-  - Captura de PDFs via API
-  - Fallback para captura como TXT
-  - Observação de mudanças no DOM
-
-### 3. PJeSelectedDocuments
-
-- **Responsabilidade**: Captura de múltiplos documentos selecionados
-- **Funcionalidades**:
-  - Detecção de documentos marcados/selecionados
-  - Captura em lote
-  - Identificação por cor de fundo e classes CSS
-
-### 4. PJeTimeline
-
-- **Responsabilidade**: Extração da timeline do processo
-- **Funcionalidades**:
-  - Mapeamento de documentos na timeline
-  - Correlação entre IDs alfanuméricos e numéricos
-  - Extração de metadados dos documentos
-
-## Configuração
-
-### config.js
-
-Este arquivo centraliza todas as configurações da extensão:
-
-```javascript
-window.EXTENSION_CONFIG = {
- // Configurações da aplicação
- app: {
-  name: 'ChatJT', // Nome da extensão
-  version: '1.0', // Versão
-  iframe_url: 'http://localhost:3000/chat', // URL do ChatJT
- },
-
- // Configurações da interface
- ui: {
-  panel: {
-   min_width: 520, // Largura mínima do painel
-   max_width_ratio: 0.5, // Máximo 50% da tela
-  },
- },
-
- // Assets da extensão
- assets: {
-  icon: 'public/logo-white-128.png', // Ícone principal
-  chevron: 'public/chevron-right.svg', // Ícone de seta
- },
-
- // Configurações de desenvolvimento
- development: {
-  debug: true, // Habilita logs
-  log_level: 1, // Nível de detalhamento (1-3)
- },
-};
-```
+### Instalação
 
-#### Parâmetros Configuráveis
-
-- **`app.iframe_url`**: URL do ChatJT (altere para produção)
-- **`ui.panel.min_width`**: Largura mínima do painel lateral
-- **`ui.panel.max_width_ratio`**: Proporção máxima da tela
-- **`development.debug`**: Habilita/desabilita logs no console
-- **`development.log_level`**: Controla verbosidade dos logs (1=básico, 2=detalhado, 3=verbose)
-
-### manifest.json
-
-Arquivo de configuração principal da extensão Chrome:
-
-```json
-{
- "manifest_version": 3,
- "name": "ChatJT",
- "version": "1.0",
- "description": "Extensão ChatJT para captura de documentos PJe",
-
- "permissions": ["storage", "tabs", "activeTab"],
-
- "host_permissions": [
-  "https://pje-hml.trt19.jus.br/*", // Hosts permitidos
-  "https://pje.trt19.jus.br/*"
- ],
-
- "content_scripts": [
-  {
-   "matches": ["https://*.jus.br/*"],
-   "css": ["style.css"],
-   "js": [
-    "config.js",
-    "utils.js",
-    "tools/pje/main.js",
-    "tools/pje/pje-current-document.js",
-    "tools/pje/pje-selected-documents.js",
-    "tools/pje/pje-timeline.js",
-    "content.js"
-   ]
-  }
- ],
-
- "web_accessible_resources": [
-  {
-   "resources": ["public/*"],
-   "matches": ["https://*.jus.br/*"]
-  }
- ]
-}
-```
+1. **Clone o repositório**: `git clone <url-do-repositorio>`
+2. **Instale as dependências**: `npm install`
 
-#### Principais Alterações no Manifest
+### Build
 
-1. **Adicionar novos hosts**:
+Para compilar o projeto, utilize os comandos de build do Vite. O resultado será um arquivo `corisco.umd.js` na pasta `dist`.
 
-    ```json
-    "host_permissions": [
-      "https://pje-hml.trt19.jus.br/*",
-      "https://pje.trt19.jus.br/*",
-      "https://pje.trt1.jus.br/*"  // Novo host
-    ]
-    ```
+- **Build de Desenvolvimento**:
 
-## Sistema de Logs
+  ```bash
+  npm run build:dev
+  ```
 
-A extensão possui um sistema de logging centralizado com 3 níveis:
+- **Build de Homologação**:
 
-- **Nível 1 (info)**: Informações básicas
-- **Nível 2 (detail)**: Informações detalhadas
-- **Nível 3 (verbose)**: Informações muito detalhadas
+  ```bash
+  npm run build:hml
+  ```
 
-```javascript
-ChatJTLog.info('Mensagem básica');
-ChatJTLog.detail('Informação detalhada');
-ChatJTLog.verbose('Informação muito detalhada');
-ChatJTLog.warn('Aviso');
-ChatJTLog.error('Erro');
-```
+- **Build de Produção**:
 
-## Comunicação Entre Módulos
+  ```bash
+  npm run build:prd
+  ```
 
-A comunicação acontece através de `postMessage` entre os módulos e o iframe:
+O arquivo gerado pode ser injetado pela extensão do navegador ou diretamente em uma página HTML, utilizando a tag `<script>`.
 
-```javascript
-// Envio de documento capturado
-this.pjeDocument.sendToIframe({
- type: 'DOCUMENT_EXTRACTED',
- document: documentData,
+```html
+<!-- Inclui o Corisco -->
+<script src="caminho/para/corisco.umd.js"></script>
+
+<!-- Inicializa Corisco -->
+<script>
+document.addEventListener('DOMContentLoaded', async function() {
+    try {
+        // Aguarda Corisco estar disponível
+        if (window.Corisco) {
+            console.log('Iniciando Corisco...');
+            await window.Corisco.start();
+            console.log('Corisco iniciado com sucesso na versão ' + window.Corisco.getVersion());
+
+            window.Corisco.toggleShowUi('unmapped', true); // Habilita UI para ações não mapeadas
+            window.Corisco.toggleShowUi('mapped', true); // Habilita UI para ações mapeadas
+        } else {
+            console.error('Corisco não foi carregado!');
+        }
+    } catch (error) {
+        console.error('Erro ao iniciar Corisco:', error);
+    }
 });
+</script>
 
-// Tipos de mensagens suportadas
-DOCUMENT_EXTRACTED; // Documento capturado
-DOCUMENT_DETECTED; // Documento detectado
-DOCUMENT_REMOVED; // Documento removido
-SELECTED_DOCUMENTS_EXTRACTED; // Documentos selecionados
-TIMELINE_DATA_EXTRACTED; // Timeline extraída
-```
-
-## Instalação e Desenvolvimento
-
-1. **Clone o repositório**
-2. **Configure o ambiente**:
-    - Altere os config.[env].ts dentro de `src/config/` conforme necessário
-    - Ajuste manifest.json para os hosts desejados
-3. **Instale as dependências**
-    - Execute `npm install` (é necessário ter o Node.js instalado)
-4. **Faça o build da extensão em Desenvolvimento**
-    - Execute `npm run build:dev` para gerar os arquivos necessários em `dist/`
-5. **Carregue no Chrome**:
-    - Abra `chrome://extensions/`
-    - Ative "Modo desenvolvedor"
-    - Clique em "Carregar extensão sem compactação"
-    - Selecione a pasta `dist/`
-
-### Versionamento automático
-
-Para atualizar a versão automaticamente, utilize o comando `npm run bump` com os parâmetros desejados:
-
-```bash
-# Para aumentar a versão patch 0.0.+1
-npm run bump:patch
-
-# Para aumentar a versão minor 0.+1.0
-npm run bump:minor
-
-# Para aumentar a versão major +1.0.0
-npm run bump:major
-
-# Para designar uma versão específica
-npm run bump -- 1.2.3
 ```
 
-Esse comando atualizará o `package.json`, `manifest.json` e outros arquivos de configuração em `src/config/` com a nova versão.
+## Ferramentas Disponíveis
 
-## Publicação do Módulo NPM
+Atualmente, o Corisco possui as seguintes ferramentas implementadas:
 
-### Configuração do Repositório Nexus
+- **[PJe](./src/tools/pje/README.md)**: Ferramenta para extração de dados do sistema PJe.
+- **Exemplo**: Ferramenta de demonstração.
 
-A extensão utiliza o repositório npm interno do TRT19 para publicação de pacotes.
+## Como Adicionar uma Nova Ferramenta de Extração
 
-**Repositório Local**: `https://nexus.trt19.jus.br/repository/npm/`
+Adicionar suporte a um novo site ou sistema (uma "ferramenta") envolve 4 passos principais. Vamos usar como exemplo a criação de uma ferramenta chamada `exemplo`.
 
-**Repositório Público**: `https://registry.npmjs.org/`
+### Passo 1: Criar o Gerenciador da Ferramenta (`ExemploManager`)
 
-### Configuração de Autenticação
+Crie uma nova pasta em `src/tools/`, como `src/tools/exemplo/`, e dentro dela, o arquivo `manager.ts`. Este arquivo conterá a classe principal da sua ferramenta.
 
-1. **Gere as credenciais em base64**:
+```typescript
+// src/tools/exemplo/manager.ts
 
-    - Utilize o comando abaixo, substituindo `user` e `password` pelas suas credenciais do Nexus (senha de rede):
+import logger from '../../lib/logger';
+import type { IAction, IMessagePayload } from '../../types/messages.types';
+import { MessageHandler } from '../../lib/messages';
+import { MESSAGE_SOURCES } from '../../types/messages.types';
+import { compareVersions } from '../../lib/helpers';
 
-    ```bash
-    echo -n 'user:password' | openssl base64
-    ```
+export class ExemploManager extends MessageHandler{
+    private static instance: ExemploManager;
+    actions!: IAction[];
 
-2. **Configure o arquivo `~/.npmrc`**:
-
-    - Crie se não existir e adicione a linha abaixo, substituindo `<valor_base64_gerado>` pelo valor obtido no passo anterior:
+    private constructor(version?: string, actions?: IAction[]) {
+        if (ExemploManager.instance) {
+            logger.warn('ExemploManager já foi inicializado, retornando instância existente');
+            return ExemploManager.instance;
+        }
 
-    ```bash
-    //nexus.trt19.jus.br/repository/npm/:_auth=<valor_base64_gerado>
-    ```
+        super(MESSAGE_SOURCES.EXTENSION);
+        super.set_version(version || '0.0.0');
 
-3. **Verifique a autenticação**:
+        logger.info(`ExemploManager iniciado - Versão: ${this.get_version()}`);
 
-    ```bash
-    npm whoami --registry=https://nexus.trt19.jus.br/repository/npm/
-    ```
+        this.actions =
+            actions?.filter((action) => {
+                if (!action.versao_min || !action.versao_max) return false;
+                const minOk = compareVersions(this.get_version(), action.versao_min) >= 0;
+                const maxOk = compareVersions(this.get_version(), action.versao_max) <= 0;
 
-    - Deve retornar o nome do usuário se a autenticação estiver correta.
+                return minOk && maxOk;
+            }) || [];
 
-### Publicação
+        logger.info(`Actions disponíveis após filtro de versão: ${this.actions.map(a => a.job).join(', ')}`);
 
-Para publicar uma nova versão do pacote:
+        // Define esta instância como a instância singleton
+        ExemploManager.instance = this;
 
-```bash
-# 1. Atualize a versão (se necessário)
-npm run bump:patch  # ou minor/major
+        this.initialize();
+    }
 
-# 2. Faça o build do projeto
-npm run build:prd
+    public static getInstance(version: string, actions: IAction[]): ExemploManager {
+        if (!ExemploManager.instance) {
+            ExemploManager.instance = new ExemploManager(version, actions);
+        }
+        return ExemploManager.instance;
+    }
+
+    private initialize() {
+        logger.info('Gerenciador de Exemplo inicializado');
+        // Lógica de inicialização: adicionar listeners, etc.
+        // this.setupMessageListener();
+    }
+
+    public handlePayload(message: IMessagePayload) {
+        // Processa uma mensagem e executa a extração
+        if (message.type === 'EXTRACT_EXEMPLO_DATA') {
+            this.extractData();
+        }
+    }
+
+    private extractData() {
+        // Lógica principal de extração de dados da página
+        const data = document.querySelector('h1')?.textContent;
+        logger.info('Dados extraídos:', data);
+        // Envia os dados extraídos...
+        this.sendSuccessMessage('SINGLE_DOCUMENT_EXTRACTED', { document: data });
+        // Se houver erro, use:
+        // this.sendErrorMessage('EXTRACTION_ERROR', { error: 'Descrição do erro' });
+        // Consulte o arquivo lib/messages.ts para mais detalhes sobre envio de mensagens
+        // Os tipos de mensagem disponíveis estão em src/types/messages.types.ts
+        // SINGLE_DOCUMENT_EXTRACTED ==> envio de documento único extraído
+        // MULTIPLE_DOCUMENTS_EXTRACTED ==> envio de múltiplos documentos extraídos
+        // METADATA_EXTRACTED ==> envio de metadados extraídos
+        // ...
+
+    }
+
+    public destroy() {
+        logger.info('Gerenciador de Exemplo destruído');
+        // Limpa listeners e remove elementos da UI
+    }
+}
+```
 
-# 3. Publique no repositório interno
-npm publish --registry=https://nexus.trt19.jus.br/repository/npm/
+### Passo 2: Definir os Tipos de Mensagem (`messages.types.ts`)
 
-# 4. (Opcional) Publique no repositório público
-npm publish --registry=https://registry.npmjs.org/
+Para que o `Iframe` possa solicitar uma extração, você precisa definir um novo tipo de mensagem em `src/types/messages.types.ts`.
 
-```
+Esta mensagem será o gatilho para a ação de extração da sua ferramenta.
 
-### Instalação de Pacotes Publicados
+```typescript
+// src/types/messages.types.ts
 
-Para instalar pacotes do repositório interno em outros projetos:
+export const MESSAGE_TYPES = {
+    // ... outros tipos
+    EXTRACT_FULL_PROCESS: 'EXTRACT_FULL_PROCESS',
 
-```bash
-# Instalar usando o registry específico
-npm install --registry=https://nexus.trt19.jus.br/repository/npm/ nome-do-pacote
+    // === Ferramenta Exemplo ===
+    EXTRACT_EXEMPLO_DATA: 'EXTRACT_EXEMPLO_DATA',
 
-# Ou configurar o registry globalmente
-npm config set registry https://nexus.trt19.jus.br/repository/npm/
-npm install nome-do-pacote
+    // === ERRORS ===
+    // ... outros tipos
+} as const;
 ```
 
-Também é possível acessar via tag \<script> usando JSDelivr (com o repositório público):
-
-```html
-<script src="https://cdn.jsdelivr.net/npm/corisco@1.3.0-dev/dist/corisco.umd.js"></script>
+### Passo 3: Configurar a Ferramenta (`config.ts`)
+
+Agora, registre a nova ferramenta em `src/config.ts`. É aqui que você define em quais sites (`allowed_hosts`) a ferramenta deve ser ativada e quais ações (`actions`) ela oferece, utilizando **regex** para correspondência de URLs.
+
+No campo mapping, você pode definir padrões de URL para mapear ações específicas.
+
+```typescript
+// src/config.ts
+
+const EXTENSION_CONFIG = {
+    // ...
+    action_map: [
+        {
+            "tool": "pje",
+            // ... config do pje
+        },
+        {
+            "tool": "exemplo",
+            "allowed_hosts": [
+                "/^https?:\\/\\/www\\.exemplo\\.com\\/.*$/"
+            ],
+            "actions": [
+                {
+                    "name": "Extrair Título",
+                    "description": "Extrai o título principal da página de exemplo.",
+                    "job": "exemplo-titulo",
+                    "loading_message": "Extraindo título...",
+                    "icon_menu": "HEADING_1",
+                    "message": "EXTRACT_EXEMPLO_DATA", // Mensagem definida no Passo 2
+                    "auto_capture": false,
+                    "metadata_capture": false,
+                    "versao_min": "0.0.0",
+                    "versao_max": "999.9.9"
+                }
+            ],
+            "mapping": {
+                "/\\/posts\\/\\d+/": ["exemplo-titulo"]
+            },
+            "extra_config": {}
+        }
+    ]
+};
 ```
 
-### Uso via CDN
-
-Para usar o Corisco via CDN em uma página web:
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Página com Corisco</title>
-</head>
-<body>
-    
-    <!-- Carrega Corisco via CDN -->
-    <script src="https://cdn.jsdelivr.net/npm/corisco@1.3.0-dev/dist/corisco.umd.js"></script>
-    
-    <!-- Inicializa Corisco -->
-    <script>
-    document.addEventListener('DOMContentLoaded', async function() {
-        try {
-            // Aguarda Corisco estar disponível
-            if (window.Corisco) {
-                console.log('Iniciando Corisco...');
-                await window.Corisco.start();
-                console.log('Corisco iniciado com sucesso na versão ' + window.Corisco.getVersion());
-            } else {
-                console.error('Corisco não foi carregado!');
+#### Explicação dos Campos
+
+- `tool`: Nome identificador da ferramenta.
+- `allowed_hosts`: Array de expressões regulares que definem os domínios onde a ferramenta será ativada.
+- `actions`: Lista de ações que a ferramenta pode executar, cada uma com suas propriedades.
+  - `name`: Nome da ação exibida na UI.
+  - `description`: Descrição da ação.
+  - `job`: Nome do job associado à ação.
+  - `loading_message`: Mensagem exibida durante o carregamento no Chat-JT.
+  - `icon_menu`: Ícone associado à ação no menu do Chat-JT.
+  - `message`: Mensagem enviada para o iframe.
+  - `auto_capture`: Indica se a captura é automática (sem interação do usuário).
+  - `metadata_capture`: Indica se é captura de metadados.
+  - `versao_min`: Versão mínima da aplicação host necessária para a ação (será confrontada com a versão passada em `Corisco.start('x.y.z')`, se houver).
+  - `versao_max`: Versão máxima da aplicação host suportada para a ação.
+
+- `mapping`: Define padrões de URL para mapear ações específicas.
+- `extra_config`: Campo para configurações adicionais específicas da ferramenta.
+
+‼️ A lista de ícones de menu disponíveis é formada por todos os ícones presentes em `src/lib/components/icons/` do repositório do Chat-JT. Use o nome do arquivo (sem extensão) para definir o `icon_menu`, em caixa alta e separado por "_". Exemplo: `BOOK_TEXT` para o arquivo `BookText.svelte`.
+
+### Passo 4: Integrar o Gerenciador no Core (`index.ts`)
+
+Finalmente, ensine o Corisco a carregar seu novo `ExemploManager`. No arquivo `src/index.ts`, importe o gerenciador e adicione um `case` no `switch` dentro de `initializeComponents`.
+
+```typescript
+// src/index.ts
+
+// 1. Importe o novo manager
+import { PJeManager } from './tools/pje/manager';
+import { ExemploManager } from './tools/exemplo/manager'; // <-- Adicione aqui
+
+class CoriscoContentScript {
+    // ...
+    private manager: PJeManager | ExemploManager | null = null; // <-- Atualize o tipo
+
+    // ...
+
+    async initializeComponents(url: string) {
+        // ...
+        for (const toolConfig of this.config.action_map) {
+            // ...
+            if (isHostMatch) {
+                // ...
+                switch (toolConfig.tool) {
+                    case 'pje':
+                        this.manager = PJeManager.getInstance(version, toolConfig.actions);
+                        break;
+                    case 'exemplo': // <-- Adicione o case para sua ferramenta
+                        this.manager = ExemploManager.getInstance(version, toolConfig.actions);
+                        break;
+                    default:
+                        logger.warn(`Nenhum gerenciador encontrado para a ferramenta: ${toolConfig.tool}`);
+                }
+                break;
             }
-        } catch (error) {
-            console.error('Erro ao iniciar Corisco:', error);
         }
-    });
-    </script>
-    
-</body>
-</html>
-```
-
-#### Verificar se está funcionando
-
-Após o carregamento, você pode verificar no console do navegador:
-
-```javascript
-// Verifica se Corisco está carregado
-console.log('Corisco disponível:', !!window.Corisco);
-
-// Verifica se está inicializado
-console.log('Corisco inicializado:', window.Corisco?.isInitialized());
-
-// Verifica versão
-console.log('Versão:', window.Corisco?.getVersion());
+        // ...
+    }
+
+    public destroy() {
+        if (!this.initialized) return;
+        this.ui?.destroy();
+        this.manager?.destroy(); // O método destroy será chamado polimorficamente
+        this.initialized = false;
+    }
+    // ...
+}
 ```
 
-## Troubleshooting
+Após seguir esses passos e fazer o build, o Corisco carregará automaticamente a ferramenta `exemplo` quando você navegar para `www.exemplo.com`, e a ação "Extrair Título" aparecerá no menu de anexos do Chat-JT.
 
-### Problemas com Publicação NPM
+### Como funciona o fluxo de mensagens
 
-**Erro de autenticação**:
+No exemplo acima, ao criar a ação `Extrair Título`, você definiu a mensagem `EXTRACT_EXEMPLO_DATA`. Veja como o fluxo de mensagens funciona:
 
-- Verifique se as credenciais base64 estão corretas no `~/.npmrc`
-- Teste a autenticação: `npm whoami --registry=https://nexus.trt19.jus.br/repository/npm/`
+1. **Gatilho da Ação**: Quando o usuário seleciona a ação "Extrair Título" (que será mostrada no menu de anexos do Chat-JT), o iframe envia uma mensagem para o Corisco do tipo `EXTRACT_EXEMPLO_DATA`.
 
-**Erro de permissão**:
+2. **Processamento da Mensagem**: O `ExemploManager` escuta por mensagens desse tipo e, ao recebê-las, inicia o processo de extração de dados da página.
 
-- Verifique se o usuário tem permissão de publicação no repositório Nexus
-- Contate o administrador do Nexus para liberação de acesso
+3. **Envio dos Resultados**: Após a extração, o `ExemploManager` envia uma mensagem de volta para o Corisco com os dados extraídos, utilizando um dos tipos de mensagem definidos (por exemplo, `SINGLE_DOCUMENT_EXTRACTED`).
 
-**Versão já existe**:
+4. **Atualização da UI**: O iframe recebe a mensagem com os dados ou documentos extraídos e atualiza a interface do usuário conforme necessário, exibindo os resultados da ação (no exemplo, será enviado e anexado ao contexto um documento extraído contendo o título da página).
 
-- Atualize a versão: `npm run bump:patch` ou `minor` ou `major`
-- Ou force a republicação: `npm publish --force --registry=...`
+⚠️ Ações que são marcadas como `auto_capture: true` serão executadas automaticamente pelo Corisco ao carregar a página, sem necessidade de interação do usuário. Nesse caso, o fluxo de mensagens é o mesmo, mas o gatilho inicial é o envio da mensagem `AUTO_CAPTURE_DETECTION` sempre que a página for carregada ou atualizada, não a seleção manual da ação.