Croncool

Inspecione trabalhos agendados, execuções, workflows duráveis e a saúde dos webhooks; execute um trabalho confirmado.

Ver em cron.coolExperimente este MCPPatrocinado

Documentação

Drive seus trabalhos agendados a partir do seu próprio código: uma API REST com chaves com escopo e limites de taxa por chave, o histórico completo de execução de cada execução e webhooks assinados quando algo acontece.

Chaves de API

Obtenha uma chave e autentique

A API REST do Cron permite que seu próprio backend faça tudo o que o painel faz com suas tarefas agendadas: criá-las e editá-las, executar uma imediatamente e ler o que aconteceu em cada execução passada.

Abra seu projeto no painel do Cron e crie uma chave de API em Chaves de API. O segredo é mostrado uma vez, quando a chave é criada, e nunca mais — guarde-o em um local seguro. Uma chave pertence a um único projeto, então o projeto é implícito pela chave e nunca precisa ser enviado.

Autentique cada requisição com autenticação básica HTTP contendo apenas o segredo da chave, codificado em base64, no cabeçalho Authorization.

# The Authorization header is HTTP Basic auth carrying only the key secret,
# with no username and no colon.
Authorization: Basic $(printf %s YOUR_API_KEY_SECRET | base64)

Todo endpoint fica sob https://api.cron.cool. Requisições feitas com uma chave são limitadas por chave; exceder o limite retorna 429.

Início rápido

Suas três primeiras chamadas

Liste as tarefas do seu projeto, agende uma nova e leia seu histórico de execução.

# List the cron jobs of the project the key belongs to
curl https://api.cron.cool/api/jobs \
  -H "Authorization: Basic $(printf %s YOUR_API_KEY_SECRET | base64)"

# Create a job that calls your endpoint every five minutes.
# expression is an EventBridge Scheduler expression — rate(5 minutes) or
# cron(0/5 * * * ? *), not a five-field unix crontab line.
curl -X POST https://api.cron.cool/api/jobs \
  -H "Authorization: Basic $(printf %s YOUR_API_KEY_SECRET | base64)" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "warm-cache",
    "type": "webhook",
    "expression": "rate(5 minutes)",
    "url": "https://example.com/warm-cache",
    "httpMethod": "POST",
    "contentType": "application/json",
    "input": { "reason": "scheduled warm-up" }
  }'

# Read the last executions of that job
curl https://api.cron.cool/api/jobs/JOB_ID/executions?limit=20 \
  -H "Authorization: Basic $(printf %s YOUR_API_KEY_SECRET | base64)"

Navegue pela referência completa da API — cada endpoint com seus parâmetros, corpo da requisição, respostas e escopo necessário.

CLI

Interface de linha de comando

Os mesmos projetos, tarefas e status de execução estão disponíveis no seu terminal através do croncool CLI. Instale-o globalmente com npm ou execute-o ad hoc com npx.

A autenticação é um comando: croncool login abre seu navegador para entrar na sua conta Croncool e armazena uma sessão para comandos posteriores — sem chave de API para colar.

# Install once, globally
npm install -g croncool
# or run it ad hoc without installing
npx croncool --help

# Log in — opens your browser to sign in and stores a session
croncool login

# List your projects with their ids
croncool projects list

# The jobs of one project, with schedule and id
croncool jobs list --projectId PROJECT_ID

# One job's schedule, target and last execution status
croncool jobs read JOB_ID

# Fire a job right now
croncool jobs execute JOB_ID

O CLI é open source em github.com/croncool/cli e publicado como croncool no npm. Execute qualquer comando com --help para ver suas opções.

Escopos

Menor privilégio por padrão

Cada chave carrega uma lista de escopos, então uma integração que só precisa observar suas tarefas nunca obtém a capacidade de alterá-las. Novas chaves começam somente leitura; amplie-as explicitamente no painel. Uma requisição cuja chave não possui o escopo que um endpoint exige é recusada com 403.

  • jobs:readListe suas tarefas cron e leia uma única tarefa.
  • jobs:writeCrie, atualize e exclua tarefas, e execute uma sob demanda.
  • executions:readLeia o histórico de execução de uma tarefa.
  • workflows:readLeia execuções de workflow hospedado, etapas, eventos e hooks.
  • workflows:writeCrie eventos de workflow, enfileire e despache trabalho, cancele e reproduza execuções.

Os escopos workflows:read e workflows:write controlam os endpoints que o runtime de workflow hospedado chama em seu nome. A referência em /api/ cobre os endpoints de tarefa e assinatura de webhook que você mesmo chama; os endpoints de workflow não fazem parte dela.

Conector MCP

Use o Croncool a partir do Claude e ChatGPT

O conector MCP remoto do Croncool permite que um assistente inspecione os projetos, tarefas, execuções, workflows duráveis e a saúde de entrega de webhooks já disponíveis para sua organização conectada. Adicione a mesma URL de produção em qualquer host que suporte MCP remoto sobre HTTP:

https://mcp.cron.cool/mcp

Escolha a opção do host para adicionar um conector personalizado ou servidor MCP, cole essa URL e conclua a tela de entrada e consentimento OAuth do Croncool. Nunca cole uma chave de API em uma conversa. OAuth mantém cada chamada dentro da organização e dos escopos aprovados para essa conta conectada.

Ferramentas disponíveis

  • list_projectsEncontre projetos acessíveis e seus ids exatos.
  • list_jobsNavegue por agendamentos de tarefas seguros e origens de destino dentro da organização autenticada.
  • get_jobInspecione o agendamento, método, origem de destino e status mais recente de uma tarefa.
  • get_job_runsRevise o status de execução limitado, código HTTP, duração e metadados de tempo.
  • list_workflowsResuma contagens de execuções de workflow hospedado para um projeto exato.
  • list_workflow_runsNavegue por status de workflow seguro e metadados de tempo.
  • get_workflow_runInspecione uma execução de workflow e um rastreamento de etapas limitado sem payloads.
  • list_webhook_subscriptionsAudite origens de endpoints, filtros de eventos e saúde de entrega sem segredos.
  • show_project_overviewRenderize uma visão geral limitada de projeto e tarefa em hosts MCP compatíveis.
  • run_jobExecute uma tarefa existente agora após confirmação explícita; cada chamada pode causar efeitos reais a jusante.

Limite seguro de dados

Os resultados do conector usam listas de permissão campo a campo. Entradas de requisição de tarefa, userinfo da URL de destino, caminhos, consultas e fragmentos, corpos de resposta de execução e erros, entradas e saídas de workflow, caminhos e consultas de endpoints de webhook, segredos de assinatura, credenciais, tokens e campos de propriedade da organização nunca são visíveis ao modelo. Destinos de destino e webhook são reduzidos à sua origem HTTP ou HTTPS.

Executando uma tarefa agora

run_job é a única ferramenta do conector que altera o estado. Ela invoca a requisição já configurada em uma tarefa exata. Esse serviço a jusante pode gravar dados, enviar mensagens, cobrar por trabalho ou acionar outro terceiro. O Croncool não adiciona uma chave de idempotência ou timeout de aplicação, então o resultado pode ser desconhecido após um timeout de transporte e repetir a chamada pode duplicar efeitos. O assistente deve primeiro mostrar a tarefa exata e a origem de destino, pedir confirmação explícita, invocá-la uma vez e usar get_job_runs para verificar o resultado registrado em vez de tentar novamente automaticamente.

Exemplos de solicitações

  • “Liste meus projetos Croncool e mostre a visão geral do primeiro projeto.”
  • “Mostre execuções com falha do workflow nightly-sync neste projeto e inspecione a falha mais recente.”
  • “Audite minhas assinaturas de webhook e sinalize qualquer uma desabilitada após falhas repetidas de entrega.”

Habilidades do Agente

Ensine seu agente de codificação a usar o Croncool

O Croncool oferece Habilidades do Agente — guias que seguem o padrão agentskills.io e ensinam agentes de codificação a inspecionar e operar tarefas agendadas com o croncool CLI e o conector MCP, em vez de adivinhar comandos e ferramentas.

# Install the Croncool skills into your coding agent
npx skills add croncool/skills

Um comando instala as habilidades no Claude Code, Cursor, Codex, Gemini CLI e em qualquer outro agente que siga o padrão Skills. O CLI também inclui os mesmos guias, com versão correspondente aos comandos que ele fornece: croncool skills get <name> imprime um sob demanda.

As habilidades são open source em github.com/croncool/skills. Usuários do Claude também podem instalar o plugin Croncool Claude, que agrupa o conector junto com as habilidades: github.com/croncool/claude-plugin.

Webhooks

Webhooks assinados

Adicione uma assinatura de webhook ao seu projeto e o Cron envia via POST os eventos que você escolheu para o seu servidor conforme eles acontecem.

  • job.createdUma tarefa foi criada.
  • job.updatedUma tarefa foi editada, pausada ou retomada.
  • job.deletedUma tarefa foi excluída.
  • job.executedUma tarefa foi executada; o payload é a execução, com seu status, status http, duração e corpo de resposta truncado.
POST https://your-server.com/cron-webhook

{
  "event": "job.executed",
  "timestamp": 1719000000,
  "data": { "...": "..." }
}

Verifique a assinatura

Cada entrega carrega um cabeçalho X-Croncool-Signature no formato t=timestamp,v1=signature, onde a assinatura é um HMAC-SHA256 de timestamp.body com chave no segredo da assinatura mostrado a você uma vez quando a assinatura foi criada. Recalcule-o sobre o corpo bruto e compare antes de confiar no payload.

import crypto from 'node:crypto'

// body must be the RAW request body, byte for byte
function verify(header, body, secret) {
  const [t, v1] = (header || '').split(',').map(part => part.split('=')[1])
  if (!t || !v1) return false

  const expected = crypto
    .createHmac('sha256', secret)
    .update(\`${t}.${body}\`)
    .digest('hex')

  // timingSafeEqual throws on a length mismatch, so a malformed signature
  // has to be rejected before the comparison rather than by it.
  if (v1.length !== expected.length) return false

  return crypto.timingSafeEqual(Buffer.from(v1), Buffer.from(expected))
}

A entrega é uma tentativa de melhor esforço com timeout de cinco segundos e sem novas tentativas, então responda 2xx rapidamente e faça o trabalho de forma assíncrona. Um endpoint que falha vinte vezes seguidas é desabilitado automaticamente e precisa ser reabilitado no painel.

Comece a construir