How matt-fontes/sendscriptwhatsapp works
Tipo e propósito do projeto (pelo file tree + README)
Este projeto não é uma aplicação web/server nem um “sistema” clássico com múltiplos serviços. É um repositório de scripts JavaScript para serem colados e executados no console do navegador enquanto o usuário está no WhatsApp Web, com o objetivo de enviar automaticamente, em sequência, o texto completo do script do Shrek ou do Bee Movie para um chat (amigo/grupo).
Arquitetura dominante: automação client-side “injetada” (user-driven) em uma página existente (WhatsApp Web).
Componentes do repo: somente dois scripts + README de instruções.
O que o file tree diz sobre a arquitetura
Top-level:
• shrekSendScript.js
• beeMovieSendScript.js
• README.md
Isso indica:
• Não há backend, build, dependências, testes, nem empacotamento.
• O comportamento do “sistema” está todo dentro de cada arquivo .js.
• A interação principal é com o DOM/objetos JS do WhatsApp Web (ou com a área de input) e eventos de teclado/click.
O que o README acrescenta (fluxo operacional real)
O README define o “pipeline” do usuário:
Script passa a enviar mensagens automaticamente.
Isso é essencial para o diagrama, porque o “gatilho” do sistema é humano (usuário) e o ambiente é o browser + WhatsApp Web.
4a) Identifique os componentes principais (blocos do diagrama)
Para ser fiel ao projeto, seus blocos devem refletir ambiente, ator, script, e alvos:
Usuário
• Ações: copiar/colar, permitir colagem, iniciar execução.
Browser (Chrome/Firefox) + DevTools Console
• Onde o script é injetado e executado.
• Inclua a etapa “allow pasting” como um “gate”/restrição do ambiente (Chrome).
WhatsApp Web (Aplicação Web)
• Página/SPA do WhatsApp rodando no browser.
• Contém os elementos de UI: caixa de mensagem, botão enviar, chat aberto.
Send Script (um dos arquivos)
• shrekSendScript.js ou beeMovieSendScript.js
• Dentro dele, você pode representar subcomponentes lógicos (mesmo que sejam funções soltas):
• Fonte do texto (string/array/linhas do script do filme)
• Scheduler/Loop (envio em intervalos para evitar travar/limites)
• Inserção no input (setar valor/innerText/dispatch events)
• Ação de envio (simular Enter/click no botão enviar)
WhatsApp Backend (Serviço remoto do WhatsApp)
• Mesmo não estando no repo, é parte do fluxo real: mensagens saem do browser para o backend do WhatsApp.
Destinatário (Contato/Grupo)
• Recebe as mensagens.
Observação: embora o repositório tenha poucos arquivos, o diagrama “de sistema” fica mais preciso quando você inclui o contexto externo (WhatsApp Web + backend), porque é aí que os efeitos acontecem.
4b) Determine relações e interações (setas / data flow)
O que você precisa mostrar com setas direcionais:
Usuário → GitHub/Arquivo .js
• “Copia conteúdo do script”
Usuário → DevTools Console
• “allow pasting” (se Chrome) e “cola + executa”
DevTools Console → Runtime JS da página (WhatsApp Web)
• “injeta/executa JS no contexto da aba”
Script JS → DOM/UI do WhatsApp Web
• “escreve na caixa de texto”
• “dispara eventos (keydown/enter) ou clica em enviar”
WhatsApp Web → WhatsApp Backend
• “envia mensagens via rede”
WhatsApp Backend → Destinatário
• “entrega mensagens”
Se quiser detalhar o “miolo”, desenhe também o loop:
• Texto do filme → (segmentação/linhas) → fila → scheduler → envio repetido
4c) Padrões/decisões arquiteturais relevantes
Mesmo simples, há princípios que valem representar:
• Injeção manual via console (não é extensão, não é userscript manager; depende do usuário)
• Automação por manipulação de UI (o script não usa API oficial; interage com elementos/inputs)
• Dependência forte do DOM do WhatsApp Web (frágil a mudanças de UI/seletores/comportamento)
• Rate/Timing control (provável uso de setInterval/setTimeout para cadenciar envios)
• Execução local, sem persistência (nenhum estado em servidor; tudo efêmero na aba)
4d) Tecnologias e “bibliotecas”
• JavaScript puro (sem libs no repo)
• Browser DOM APIs / Events
• WhatsApp Web (plataforma alvo)
• DevTools Console (mecanismo de injeção)
Como “tailorar” o diagrama para este tipo de projeto (script/tool)
Este projeto se encaixa melhor como open-source tool / automação do que como app full-stack.
Então, no diagrama:
• Foque no ponto de integração: “Script roda dentro da aba do WhatsApp Web”.
• Mostre claramente o ator humano (inicia o fluxo) e a restrição do ambiente (allow pasting).
• Mostre a automação como um loop controlado por tempo (para não parecer “um único envio”).
Sugestão de dois níveis de diagrama (recomendado para ficar “bem detalhado” sem confundir):
• Usuário, Browser/Console, WhatsApp Web, WhatsApp Backend, Destinatário.
• Componentes lógicos do script (Text Source / Parser / Queue / Scheduler / UI Injector / Sender).
Labels claros
• Nomeie os nós com termos do repo e do ambiente:
• shrekSendScript.js / beeMovieSendScript.js
• “DevTools Console (Chrome)”
• “WhatsApp Web (DOM + UI)”
• “WhatsApp Backend (External)”
• “Contato/Grupo”
Setas e direções
• Use setas unidirecionais para:
• controle (usuário inicia)
• execução (console injeta)
• dados (texto do filme vira mensagens)
• rede (web app → backend → recipient)
Cores/formas (padronize)
• Azul (interno do repo): os scripts
• Cinza (ambiente do cliente): Browser, DevTools, WhatsApp Web UI
• Laranja/vermelho (externo/terceiros): WhatsApp Backend, Destinatário
• Formas:
• Retângulos = componentes
• Cilindro (se quiser) = “backend/serviço” (mesmo que não seja DB)
• Notas/Callouts = restrições (“Chrome block paste → allow pasting”)
Detalhes finais que aumentam muito a “acurácia”
• Indique explicitamente que o script depende de:
• chat aberto no WhatsApp Web
• foco na caixa de mensagem (muitas automações dependem disso)
• Adicione uma nota: “Pode quebrar com mudanças no WhatsApp Web/seletores”.
• Se o script tiver delays, represente como “intervalo (ms)” no Scheduler (mesmo que você não saiba o valor exato, desenhe o conceito).
Se você quiser deixar o diagrama perfeito, abra shrekSendScript.js e beeMovieSendScript.js e extraia:
• como o texto está armazenado (string única vs array)
• como ele encontra o input (querySelector/XPath)
• como dispara o envio (evento Enter vs click)
• qual política de timing (intervalo fixo, backoff, etc.)
Esses detalhes viram rótulos no diagrama de componentes e tornam a arquitetura “exata”, não apenas conceitual.