DM automática por comentário no Instagram

node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

create table if not exists public.ig_keyword_rules (
  id           bigint generated always as identity primary key,
  keyword      text not null,
  match_mode   text not null default 'word' check (match_mode in ('word','exact')),
  media_id     text,
  message_text text not null,
  priority     int  not null default 100,
  active       boolean not null default true,
  created_at   timestamptz not null default now()
);

create table if not exists public.ig_comment_queue (
  id                 bigint generated always as identity primary key,
  comment_id         text not null unique,
  ig_account_id      text not null,
  commenter_id       text,
  username           text,
  comment_text       text,
  media_id           text,
  rule_id            bigint references public.ig_keyword_rules(id) on delete set null,
  message_text       text not null,
  status             text not null default 'pending'
                     check (status in ('pending','processing','sent','skipped','failed')),
  attempts           int  not null default 0,
  max_attempts       int  not null default 4,
  send_after         timestamptz not null default now(),
  locked_at          timestamptz,
  comment_created_at timestamptz not null,
  sent_message_id    text,
  last_error         text,
  created_at         timestamptz not null default now(),
  processed_at       timestamptz,
  updated_at         timestamptz not null default now()
);

create index if not exists ig_queue_pending_idx
  on public.ig_comment_queue (send_after) where status = 'pending';
create index if not exists ig_queue_processing_idx
  on public.ig_comment_queue (locked_at) where status = 'processing';

create table if not exists public.ig_settings (
  key        text primary key,
  value      text not null,
  updated_at timestamptz not null default now()
);

alter table public.ig_keyword_rules enable row level security;
alter table public.ig_comment_queue enable row level security;
alter table public.ig_settings      enable row level security;

create or replace function public.claim_ig_comments(batch_size int default 5)
returns setof public.ig_comment_queue
language sql
as $$
  update public.ig_comment_queue q
     set status = 'processing', attempts = q.attempts + 1,
         locked_at = now(), updated_at = now()
   where q.id in (
     select id from public.ig_comment_queue
      where status = 'pending' and send_after <= now() and attempts < max_attempts
      order by send_after
      limit batch_size
      for update skip locked
   )
  returning q.*;
$$;

create or replace function public.maintain_ig_queue(window_hours int default 160, stuck_minutes int default 5)
returns jsonb
language plpgsql
as $$
declare n_expired int; n_reaped int;
begin
  update public.ig_comment_queue
     set status = 'failed', last_error = 'janela da Private Reply expirada', updated_at = now()
   where status = 'pending'
     and comment_created_at < now() - make_interval(hours => window_hours);
  get diagnostics n_expired = row_count;

  update public.ig_comment_queue
     set status = case when attempts >= max_attempts then 'failed' else 'pending' end,
         last_error = 'travado em processing; liberado', locked_at = null, updated_at = now()
   where status = 'processing'
     and locked_at < now() - make_interval(mins => stuck_minutes);
  get diagnostics n_reaped = row_count;

  return jsonb_build_object('expired', n_expired, 'reaped', n_reaped);
end;
$$;

create or replace function public.skip_ig_comment(cid text)
returns boolean
language sql
as $$
  with upd as (
    update public.ig_comment_queue
       set status = 'skipped', updated_at = now()
     where comment_id = cid and status = 'pending'
    returning 1
  )
  select exists (select 1 from upd);
$$;

revoke execute on function public.claim_ig_comments(int)      from public, anon, authenticated;
revoke execute on function public.maintain_ig_queue(int, int) from public, anon, authenticated;
revoke execute on function public.skip_ig_comment(text)       from public, anon, authenticated;

create extension if not exists pg_cron;

select cron.schedule('ig-cleanup', '7 4 * * *', $$
  delete from public.ig_comment_queue
   where status in ('sent','skipped','failed')
     and updated_at < now() - interval '90 days';
$$);

-- Qualquer post
insert into public.ig_keyword_rules (keyword, message_text)
values ('quero', 'Oi! Aqui está o link: https://seu-link');

-- Só um post específico. Ganha da regra global.
-- insert into public.ig_keyword_rules (keyword, media_id, message_text, priority)
-- values ('ebook', 'ID_DA_MIDIA', 'Aqui está o ebook: https://...', 10);

curl.exe "https://graph.instagram.com/v26.0/me?fields=user_id,username&access_token=IG_ACCESS_TOKEN"

curl.exe -X POST "https://graph.instagram.com/v26.0/me/subscribed_apps?subscribed_fields=comments,messages&access_token=IG_ACCESS_TOKEN"

curl.exe "https://graph.instagram.com/v26.0/me/subscribed_apps?access_token=IG_ACCESS_TOKEN"

npx supabase login
npx supabase init
npx supabase link --project-ref PROJECT_REF
npx supabase functions new ig-webhook

import { createClient } from "npm:@supabase/supabase-js@2";

const supabase = createClient(
  Deno.env.get("SUPABASE_URL")!,
  Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!,
);

const VERIFY_TOKEN = Deno.env.get("META_VERIFY_TOKEN")!;
const APP_SECRET = Deno.env.get("META_APP_SECRET")!;
const OWN_IG_USER_ID = Deno.env.get("OWN_IG_USER_ID") ?? "";
const JITTER_SECONDS = Number(Deno.env.get("SEND_JITTER_SECONDS") ?? "20");

const hmacKey = crypto.subtle.importKey(
  "raw", new TextEncoder().encode(APP_SECRET),
  { name: "HMAC", hash: "SHA-256" }, false, ["verify"],
);

function hexToBytes(hex: string): Uint8Array | null {
  if (!/^[0-9a-f]{64}$/i.test(hex)) return null;
  const out = new Uint8Array(32);
  for (let i = 0; i < 32; i++) out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
  return out;
}

async function validSignature(raw: Uint8Array, header: string | null): Promise<boolean> {
  if (!header?.startsWith("sha256=")) return false;
  const sig = hexToBytes(header.slice(7));
  if (!sig) return false;
  return crypto.subtle.verify("HMAC", await hmacKey, sig, raw);
}

function normalize(s: string): string {
  return s.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase()
    .replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
}

type Rule = {
  id: number; keyword: string; match_mode: "word" | "exact";
  media_id: string | null; message_text: string; priority: number;
};

function matches(text: string, rule: Rule): boolean {
  const kw = normalize(rule.keyword);
  if (!kw) return false;
  if (rule.match_mode === "exact") return text === kw;
  return ` ${text} `.includes(` ${kw} `);
}

function pickRule(rules: Rule[], text: string, mediaId: string | null): Rule | null {
  return rules
    .filter((r) => r.media_id === null || r.media_id === mediaId)
    .filter((r) => matches(text, r))
    .sort((a, b) => {
      const spec = Number(b.media_id !== null) - Number(a.media_id !== null);
      return spec !== 0 ? spec : a.priority - b.priority;
    })[0] ?? null;
}

function eventDate(time: unknown): Date {
  const n = Number(time);
  if (!Number.isFinite(n) || n <= 0) return new Date();
  return new Date(n > 1e12 ? n : n * 1000);
}

Deno.serve(async (req) => {
  if (req.method === "GET") {
    const url = new URL(req.url);
    if (url.searchParams.get("hub.mode") === "subscribe" &&
        url.searchParams.get("hub.verify_token") === VERIFY_TOKEN) {
      return new Response(url.searchParams.get("hub.challenge") ?? "", { status: 200 });
    }
    return new Response("forbidden", { status: 403 });
  }

  if (req.method !== "POST") return new Response("method not allowed", { status: 405 });

  const raw = new Uint8Array(await req.arrayBuffer());
  if (!(await validSignature(raw, req.headers.get("x-hub-signature-256")))) {
    return new Response("invalid signature", { status: 401 });
  }

  let body: any;
  try { body = JSON.parse(new TextDecoder().decode(raw)); }
  catch { return new Response("bad json", { status: 400 }); }

  const { data: rules, error: rulesErr } = await supabase
    .from("ig_keyword_rules")
    .select("id, keyword, match_mode, media_id, message_text, priority")
    .eq("active", true);
  if (rulesErr) return new Response("db error", { status: 500 });

  const rows: Record<string, unknown>[] = [];

  for (const entry of body.entry ?? []) {
    const accountId = String(entry.id ?? "");
    const createdAt = eventDate(entry.time);

    for (const change of entry.changes ?? []) {
      if (change.field !== "comments") continue;
      const v = change.value ?? {};
      const commentId = v.id ? String(v.id) : "";
      const fromId = String(v.from?.id ?? "");
      if (!commentId || !fromId) continue;
      if (fromId === accountId || fromId === OWN_IG_USER_ID) continue;

      const mediaId = v.media?.id ? String(v.media.id) : null;
      const rule = pickRule((rules ?? []) as Rule[], normalize(String(v.text ?? "")), mediaId);
      if (!rule) continue;

      rows.push({
        comment_id: commentId,
        ig_account_id: accountId,
        commenter_id: fromId,
        username: v.from?.username ?? null,
        comment_text: v.text ?? null,
        media_id: mediaId,
        rule_id: rule.id,
        message_text: rule.message_text,
        comment_created_at: createdAt.toISOString(),
        send_after: new Date(Date.now() + Math.random() * JITTER_SECONDS * 1000).toISOString(),
      });
    }
  }

  if (rows.length > 0) {
    const { error } = await supabase
      .from("ig_comment_queue")
      .upsert(rows, { onConflict: "comment_id", ignoreDuplicates: true });
    if (error) return new Response("db error", { status: 500 });
  }

  return new Response("ok", { status: 200 });
});

npx supabase secrets set META_VERIFY_TOKEN="valor" META_APP_SECRET="valor" OWN_IG_USER_ID="valor" SEND_JITTER_SECONDS="20"
npx supabase secrets list
npx supabase functions deploy ig-webhook --no-verify-jwt

curl.exe "https://PROJECT_REF.supabase.co/functions/v1/ig-webhook?hub.mode=subscribe&hub.verify_token=META_VERIFY_TOKEN&hub.challenge=12345"

services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_ENCRYPTION_KEY=N8N_ENCRYPTION_KEY
      - GENERIC_TIMEZONE=America/Fortaleza
      - TZ=America/Fortaleza
      - N8N_SECURE_COOKIE=false
      - EXECUTIONS_DATA_SAVE_ON_SUCCESS=none
      - EXECUTIONS_DATA_PRUNE=true
      - EXECUTIONS_DATA_MAX_AGE=72
    volumes:
      - n8n_data:/home/node/.n8n

volumes:
  n8n_data:

docker compose up -d

{ "headers": { "apikey": "SUPABASE_SECRET_KEY" } }

{ "headers": { "apikey": "SUPABASE_SECRET_KEY", "Authorization": "Bearer SUPABASE_SECRET_KEY" } }

Schedule Trigger → Config → Manutenção → Buscar token → Reservar lote → Enviar Private Reply → Classificar resultado
                                                                                                 ├→ Atualizar fila
                                                                                                 └→ IF (sent) → Gerar resposta → Responder comentário

{{ $('Config').first().json.supabase_url }}/rest/v1/rpc/maintain_ig_queue

{{ $('Config').first().json.supabase_url }}/rest/v1/ig_settings?key=eq.ig_access_token&select=value

{{ $('Config').first().json.supabase_url }}/rest/v1/rpc/claim_ig_comments

{{ $('Config').first().json.graph_base }}/{{ $('Config').first().json.graph_version }}/{{ $('Config').first().json.ig_user_id }}/messages

{{ JSON.stringify({ recipient: { comment_id: $json.comment_id }, message: { text: $json.message_text } }) }}

const job = $('Reservar lote').item.json;
const res = $json;
const status = Number(res.statusCode ?? 0);
const body = res.body ?? {};
const now = new Date().toISOString();

const TRANSIENT = [1, 2, 4, 17, 32, 341, 613];
const AUTH = [102, 190];

if (status >= 200 && status < 300) {
  return { json: { id: job.id, comment_id: job.comment_id, username: job.username, outcome: 'sent', patch: {
    status: 'sent', sent_message_id: body.message_id ?? null,
    processed_at: now, locked_at: null, last_error: null, updated_at: now,
  } } };
}

const err = body.error ?? {};
const code = Number(err.code);
const errText = JSON.stringify(err).slice(0, 1000);

if (AUTH.includes(code)) {
  return { json: { id: job.id, outcome: 'auth_error', patch: {
    status: 'pending', attempts: Math.max(job.attempts - 1, 0),
    locked_at: null, last_error: 'auth: ' + errText, updated_at: now,
  } } };
}

const transient = err.is_transient === true || TRANSIENT.includes(code) || status === 0 || status >= 500;
const exhausted = job.attempts >= job.max_attempts;

if (transient && !exhausted) {
  const backoffMin = Math.min(2 ** job.attempts, 30);
  return { json: { id: job.id, outcome: 'retry', patch: {
    status: 'pending', send_after: new Date(Date.now() + backoffMin * 60000).toISOString(),
    locked_at: null, last_error: errText, updated_at: now,
  } } };
}

return { json: { id: job.id, outcome: 'failed', patch: {
  status: 'failed', locked_at: null, last_error: errText, processed_at: now, updated_at: now,
} } };

{{ $('Config').first().json.supabase_url }}/rest/v1/ig_comment_queue?id=eq.{{ $json.id }}

const aberturas = ["", "Oi! ", "Opa! ", "Prontinho! ", "Feito! ", "Olá! ", "Show! ", "Perfeito! ", "Beleza! ", "Pronto! "];
const frases = [
  "te mandei na DM", "enviei no seu direct", "acabei de mandar no privado", "olha seu direct",
  "corre lá na DM", "mandei tudo no direct", "dá uma olhada na DM", "te chamei no privado",
  "já está no seu direct", "confere a DM",
];
const finais = ["", "!", " 😉", " 📩", " 🚀", " 🙌", "! Qualquer dúvida é só chamar", ". Se não aparecer, olha em Solicitações"];

const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];

let abertura = pick(aberturas);
let frase = pick(frases);
const final = pick(finais);

const username = $json.username;
if (username && Math.random() < 0.5) abertura = `@${username} `;
if (!abertura) frase = frase.charAt(0).toUpperCase() + frase.slice(1);

return { json: { ...$json, reply_text: `${abertura}${frase}${final}` } };

{{ $('Config').first().json.graph_base }}/{{ $('Config').first().json.graph_version }}/{{ $('Reservar lote').item.json.comment_id }}/replies

{{ $('Config').first().json.supabase_url }}/rest/v1/ig_settings?key=eq.ig_access_token&select=value

{{ $('Config').first().json.supabase_url }}/rest/v1/ig_settings?key=eq.ig_access_token

insert into public.ig_settings (key, value)
values ('ig_access_token', 'IG_ACCESS_TOKEN')
on conflict (key) do update set value = excluded.value, updated_at = now();

curl.exe "https://graph.instagram.com/v26.0/me?fields=user_id,username&access_token=IG_ACCESS_TOKEN"

import crypto from "node:crypto";

const APP_SECRET = "META_APP_SECRET";
const URL = "https://PROJECT_REF.supabase.co/functions/v1/ig-webhook";

const now = Math.floor(Date.now() / 1000);
const body = JSON.stringify({
  object: "instagram",
  entry: [{ id: "111", time: now, changes: [{ field: "comments", value: {
    id: `teste_${now}`, text: "Eu QUERO!", from: { id: "999", username: "teste" }, media: { id: "media_1" },
  } }] }],
});

const sig = crypto.createHmac("sha256", APP_SECRET).update(body).digest("hex");
const res = await fetch(URL, {
  method: "POST",
  headers: { "Content-Type": "application/json", "X-Hub-Signature-256": `sha256=${sig}` },
  body,
});
console.log(res.status, await res.text());

node teste-webhook.mjs

select comment_id, status, send_after from public.ig_comment_queue order by id desc limit 5;

-- Situação da fila
select status, count(*) from public.ig_comment_queue group by status;

-- Pendentes atrasados. n8n parado ou token quebrado.
select count(*) from public.ig_comment_queue
 where status = 'pending' and send_after < now() - interval '10 minutes';

-- Falhas
select comment_id, username, last_error, updated_at
  from public.ig_comment_queue where status = 'failed'
 order by updated_at desc limit 20;

-- Pular um comentário que você respondeu à mão
select public.skip_ig_comment('ID_DO_COMENTARIO');

-- Desativar regra
update public.ig_keyword_rules set active = false where id = 1;