Sinalização em Tempo Real

A Sinalização em Tempo Real é um sistema avançado orientado a eventos para lidar com a comunicação assíncrona em fluxos de trabalho automatizados. Essa arquitetura baseada em sinais permite uma interação perfeita entre scripts de automação e sistemas externos, sendo o tratamento de Autenticação Multifator (MFA) uma de suas aplicações mais críticas.

Visão Geral

O sistema de Sinalização em Tempo Real fornece uma estrutura robusta para gerenciar eventos assíncronos em fluxos de trabalho de automação. Embora a verificação de MFA represente um caso de uso primário, a arquitetura flexível do sistema oferece suporte a diversos cenários orientados a eventos.

A Autenticação Multifator (MFA) é um recurso de segurança crítico que frequentemente se torna um gargalo para fluxos de trabalho automatizados, causando falhas ou bloqueios de conta.

Por que o tratamento de MFA é crítico para a automação:

✅ Garanta acesso ininterrupto: Trate códigos SMS inesperados, OTPs por e-mail ou autenticação TOTP sem interromper o fluxo de trabalho

✅ Evite travamentos do fluxo de trabalho: A automação tradicional congela quando surgem solicitações de MFA, enquanto o Agent Browser lida com elas de forma tranquila

✅ Mantenha sessões estáveis: Tarefas de longa duração permanecem conectadas com gerenciamento seguro do estado de verificação

✅ Reduza o risco da conta: O comportamento de verificação semelhante ao humano diminui a probabilidade de acionar mecanismos de segurança

Além do MFA: Sistema Universal de Eventos

O sistema de sinalização vai além da autenticação para lidar com:

• Envios de formulários e atualizações de status
• Notificações de progresso de tarefas
• Callbacks de API e webhooks
• Interações de usuário e mudanças de estado
• Coordenação de processos entre sistemas
• Monitoramento em tempo real e alertas

Solução completa de sinalização:

• Verificação de MFA confiável (caso de uso primário)
• Tratamento universal de eventos para necessidades de automação
• Múltiplos métodos de entrada para códigos e dados
• Processamento assíncrono (não bloqueante)
• Suporte completo a APIs CDP e HTTP
• Compatibilidade universal com fluxos de autenticação

APIs Suportadas

O Scrapeless oferece suporte tanto às interfaces CDP quanto HTTP para sinalização em tempo real:

APIs CDP

As APIs de Sinal CDP permitem enviar e receber sinais por meio de canais de eventos em fluxos de trabalho de automação de navegador. Saiba mais

Signal.send

Envia dados de sinal para um canal de eventos especificado.

Formato da Requisição:

{
  "method": "Signal.send",
  "params": {
    "event": "string",
    "data": "object"
  }
}

Parâmetros:

Exemplo:

await client.send('Signal.send', {
  event: 'mfa_code',
  data: { code: '123456', type: 'sms' }
});

Signal.wait

Aguarda dados de sinal em um canal de eventos especificado.

Formato da Requisição:

{
  "method": "Signal.wait",
  "params": {
    "event": "string",
    "timeout": 60000
  }
}

Parâmetros:

Exemplo:

const result = await client.send('Signal.wait', {
  event: 'mfa_code',
  timeout: 60000
});
console.log('Received MFA code:', result.data);

Signal.list

Lista todos os nomes de eventos pendentes na fila.

Formato da Requisição:

{
  "method": "Signal.list",
  "params": {}
}

Parâmetros: Nenhum obrigatório

Exemplo:

const list = await client.send('Signal.list');
console.log('Pending events:', list.events);
// Output: ["mfa_code", "captcha_result", "order_status"]
 
// Check for specific event
if (list.events.includes('mfa_code')) {
  console.log('MFA code in queue');
}

Signal.stats

Recupera estatísticas da fila e informações sobre os assinantes.

Formato da Requisição:

{
  "method": "Signal.stats",
  "params": {}
}

Parâmetros: Nenhum obrigatório

Campos de Resposta:

Exemplo:

const client = await page.target().createCDPSession();
 
// Get statistics
const stats = await client.send('Signal.stats');
console.log('Pending events:', stats.events);
console.log('Waiting subscribers:', stats.waiters);

Signal.clear

Limpa eventos específicos ou todos os eventos da fila.

Formato da Requisição:

{
  "method": "Signal.clear",
  "params": {
    "event": "string (optional)"
  }
}

Parâmetros:

APIs REST HTTP

Para sistemas externos, os endpoints REST HTTP oferecem uma alternativa mais simples à configuração de conexão CDP. Isso elimina a necessidade de estabelecer conexões WebSocket para cada transmissão de dados. Saiba mais

Prefixo Padrão do Endpoint do Navegador: https://browser.scrapeless.com/browser/{taskId}

POST /signal/send

Envia um sinal via HTTP.

Formato da Requisição:

POST https://browser.scrapeless.com/browser/{taskId}/signal/send?x-api-token={API_KEY}
Content-Type: application/json
 
{
  "event": "string",
  "data": "object"
}

Parâmetros:

Exemplo:

curl -X POST 'https://browser.scrapeless.com/browser/{taskId}/signal/send?x-api-token={API_KEY}' \
  -H 'Content-Type: application/json' \
  -d '{
    "event": "mfa_code",
    "data": { "code": "123456", "type": "sms" }
  }'

GET /signal/wait

Aguarda um sinal via requisição HTTP GET.

Formato da Requisição:

GET https://browser.scrapeless.com/browser/{taskId}/signal/wait?x-api-token={API_KEY}&event={event}&timeout={timeout}

Parâmetros:

Exemplo:

# Wait for MFA code with 60 second timeout
curl -X GET 'https://browser.scrapeless.com/browser/{taskId}/signal/wait?x-api-token={API_KEY}&event=mfa_code&timeout=60000'

GET /signal/list

Lista todos os nomes de eventos pendentes.

Formato da Requisição:

GET https://browser.scrapeless.com/browser/{taskId}/signal/list?x-api-token={API_KEY}

Parâmetros: Nenhum obrigatório

Exemplo:

# List all pending events
curl -X GET 'https://browser.scrapeless.com/browser/{taskId}/signal/list?x-api-token={API_KEY}'

GET /signal/stats

Recupera estatísticas da fila.

Formato da Requisição:

GET https://browser.scrapeless.com/browser/{taskId}/signal/stats?x-api-token={API_KEY}

Parâmetros: Nenhum obrigatório

Exemplo:

# Get queue statistics
curl -X GET 'https://browser.scrapeless.com/browser/{taskId}/signal/stats?x-api-token={API_KEY}'

DELETE /signal/clear

Limpa eventos da fila.

Formato da Requisição:

DELETE https://browser.scrapeless.com/browser/{taskId}/signal/clear?x-api-token={API_KEY}
Content-Type: application/json
 
{
  "event": "string (optional)"
}

Parâmetros:

Exemplo:

# Clear specific event
curl -X DELETE 'https://browser.scrapeless.com/browser/{taskId}/signal/clear?x-api-token={API_KEY}' \
  -H 'Content-Type: application/json' \
  -d '{"event": "mfa_code"}'
 
# Clear all events
curl -X DELETE 'https://browser.scrapeless.com/browser/{taskId}/signal/clear?x-api-token={API_KEY}'

Melhores Práticas

Use Timeouts Apropriados

Defina valores de timeout com base nos atrasos de verificação esperados. Os tempos típicos de entrega de MFA variam de 10 a 60 segundos.

Tratamento de Erros

Sempre verifique os códigos de status da resposta (200, 408, 400) para lidar adequadamente com os casos de sucesso, timeout e erro.

Monitoramento da Fila

Verifique regularmente as estatísticas da fila para detectar condições de acúmulo que possam indicar problemas no sistema.

Nomenclatura de Canais de Eventos

Use nomes descritivos para os canais de eventos (por exemplo, mfa_code, email_verification, totp_token) para evitar confusão em cenários com múltiplos eventos.

Processamento Assíncrono

Aproveite o tratamento assíncrono de sinais para evitar o bloqueio do script enquanto aguarda a entrada do usuário.

Limpeza da Fila

Limpe eventos obsoletos da fila para manter o desempenho do sistema e evitar problemas de memória.

Exemplo Completo

const puppeteer = require('puppeteer-core');
 
(async () => {
    const API_TOKEN = 'API Key';
    const API_URL = 'https://api.scrapeless.com/api/v2/browser'; // Create session task API endpoint
 
    try {
        // Step 1: Get session taskId via HTTP API
        const sessionResponse = await fetch(API_URL, {
            method: 'GET',
            headers: {'x-api-token': API_TOKEN},
        });
 
        const {taskId} = await sessionResponse.json();
        console.log('Session created with task ID:', taskId);
 
        // Step 2: Connect to browser by taskId
        const browser = await puppeteer.connect({
            browserWSEndpoint: `wss://api.scrapeless.com/browser/${taskId}`,
            headers: {'x-api-token': API_TOKEN},
        });
 
        // Step 3: Navigate to page and wait for signal
        const page = await browser.newPage();
        await page.goto("https://example.com", {waitUntil: "domcontentloaded"});
 
        const client = await page.createCDPSession();
 
        console.log('Waiting for example event...');
        const result = await client.send('Signal.wait', {
            event: 'example_event',
            timeout: 60000
        });
 
        console.log('Received example data:', result.data);
 
        await browser.close();
    } catch (error) {
        console.error('Error occurred:', error);
    }
})();

# Send data to example event using curl
# Replace {taskId} with the session ID from the first step
curl 'https://browser.scrapeless.com/browser/{taskId}/signal/send' \
  -H 'content-type: application/json' \
  -H 'token: API Key' \
  --data-raw $'{  "event":"example_event",  "data":{ "email":"example@host.com", "password": "mypassword"  }}'

O sistema de Sinalização em Tempo Real do Agent Browser fornece uma estrutura robusta e flexível para lidar com a autenticação multifator em fluxos de trabalho automatizados. Ao combinar as interfaces CDP e HTTP com um sistema inteligente de fila de eventos, ele permite a integração perfeita de sistemas de verificação externos, mantendo a segurança e a confiabilidade.

Seja você criando scripts de automação simples ou orquestrações complexas entre múltiplos sistemas, a arquitetura assíncrona e não bloqueante do sistema de sinais garante que seus fluxos de trabalho sejam concluídos de forma confiável — mesmo quando a verificação por MFA é necessária.