bps-kit 1.0.1 → 1.0.2

package/templates/vault/instagram/scripts/run_all.py

@@ -0,0 +1,189 @@
+"""
+Sync completo: busca perfil, mídia, insights e comentários do Instagram.
+
+Uso:
+    python scripts/run_all.py                    # Sync completo
+    python scripts/run_all.py --only media       # Só mídia
+    python scripts/run_all.py --only insights    # Só insights
+    python scripts/run_all.py --only comments    # Só comentários
+    python scripts/run_all.py --dry-run          # Mostra o que seria feito
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import logging
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from api_client import InstagramAPI
+from auth import auto_refresh_if_needed
+from db import Database
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+db = Database()
+db.init()
+
+
+async def sync_profile(api: InstagramAPI) -> dict:
+    """Sync perfil."""
+    logger.info("Buscando perfil...")
+    profile = await api.get_user_profile()
+    logger.info("Perfil: @%s (%s)", profile.get("username"), profile.get("account_type"))
+    return {"status": "ok", "username": profile.get("username")}
+
+
+async def sync_media(api: InstagramAPI, limit: int = 50) -> dict:
+    """Sync mídia recente."""
+    logger.info("Buscando %d mídias recentes...", limit)
+    result = await api.get_user_media(limit=limit)
+    media_list = result.get("data", [])
+
+    # Salvar como posts publicados
+    count = 0
+    for m in media_list:
+        existing = db.get_posts(account_id=api.account_id, limit=1000)
+        existing_ig_ids = {p["ig_media_id"] for p in existing if p.get("ig_media_id")}
+
+        if m["id"] not in existing_ig_ids:
+            db.insert_post({
+                "account_id": api.account_id,
+                "media_type": m.get("media_type", "IMAGE"),
+                "media_url": m.get("media_url", ""),
+                "caption": m.get("caption", ""),
+                "status": "published",
+                "published_at": m.get("timestamp", ""),
+                "ig_media_id": m["id"],
+                "permalink": m.get("permalink", ""),
+            })
+            count += 1
+
+    logger.info("Mídia: %d encontradas, %d novas salvas", len(media_list), count)
+    return {"status": "ok", "found": len(media_list), "new": count}
+
+
+async def sync_insights(api: InstagramAPI, limit: int = 20) -> dict:
+    """Sync insights dos posts recentes."""
+    logger.info("Buscando insights de %d posts...", limit)
+    media_result = await api.get_user_media(limit=limit)
+    media_list = media_result.get("data", [])
+
+    success = 0
+    errors = 0
+    for m in media_list:
+        try:
+            metrics = ["impressions", "reach", "engagement", "saved"]
+            if m.get("media_type") == "VIDEO":
+                metrics.append("video_views")
+            insights = await api.get_media_insights(m["id"], metrics=metrics)
+
+            raw = json.dumps(insights, ensure_ascii=False)
+            for item in insights.get("data", []):
+                values = item.get("values", [{}])
+                value = values[0].get("value", 0) if values else 0
+                db.insert_insights([{
+                    "account_id": api.account_id,
+                    "ig_media_id": m["id"],
+                    "metric_name": item.get("name", ""),
+                    "metric_value": float(value) if isinstance(value, (int, float)) else 0,
+                    "period": item.get("period", ""),
+                    "raw_json": raw,
+                }])
+            success += 1
+        except Exception as e:
+            errors += 1
+            logger.warning("Insights para %s: %s", m["id"], e)
+
+    logger.info("Insights: %d OK, %d erros", success, errors)
+    return {"status": "ok", "success": success, "errors": errors}
+
+
+async def sync_comments(api: InstagramAPI, limit: int = 10) -> dict:
+    """Sync comentários dos posts recentes."""
+    logger.info("Buscando comentários dos últimos %d posts...", limit)
+    media_result = await api.get_user_media(limit=limit)
+    media_list = media_result.get("data", [])
+
+    total_comments = 0
+    for m in media_list:
+        try:
+            comments_result = await api.get_comments(m["id"], limit=50)
+            comments = comments_result.get("data", [])
+
+            for c in comments:
+                db.upsert_comments([{
+                    "account_id": api.account_id,
+                    "ig_comment_id": c["id"],
+                    "ig_media_id": m["id"],
+                    "username": c.get("username", ""),
+                    "text": c.get("text", ""),
+                    "timestamp": c.get("timestamp", ""),
+                }])
+            total_comments += len(comments)
+        except Exception as e:
+            logger.warning("Comentários para %s: %s", m["id"], e)
+
+    logger.info("Comentários: %d salvos", total_comments)
+    return {"status": "ok", "total": total_comments}
+
+
+async def run(only: list = None, dry_run: bool = False, limit: int = 50) -> None:
+    tasks = only or ["profile", "media", "insights", "comments"]
+
+    if dry_run:
+        print(f"\n[DRY-RUN] Sync que seria executado: {', '.join(tasks)}")
+        return
+
+    await auto_refresh_if_needed()
+    api = InstagramAPI()
+
+    logger.info("Iniciando sync: %s", ", ".join(tasks))
+    results = {}
+
+    try:
+        if "profile" in tasks:
+            results["profile"] = await sync_profile(api)
+        if "media" in tasks:
+            results["media"] = await sync_media(api, limit=limit)
+        if "insights" in tasks:
+            results["insights"] = await sync_insights(api, limit=min(limit, 20))
+        if "comments" in tasks:
+            results["comments"] = await sync_comments(api, limit=min(limit, 10))
+    finally:
+        await api.close()
+
+    # Resumo
+    print("\n" + "=" * 60)
+    print("SYNC COMPLETO")
+    print("=" * 60)
+    for task, result in results.items():
+        print(f"  {task}: {json.dumps(result, ensure_ascii=False)}")
+    print("=" * 60)
+
+    stats = db.get_stats()
+    print(f"\nBanco: {json.dumps(stats, indent=2, ensure_ascii=False)}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Sync completo do Instagram")
+    parser.add_argument("--only", nargs="+", choices=["profile", "media", "insights", "comments"],
+                        help="Executar apenas tarefas específicas")
+    parser.add_argument("--limit", type=int, default=50, help="Limite de mídia a buscar")
+    parser.add_argument("--dry-run", action="store_true", help="Mostra o que seria feito")
+    args = parser.parse_args()
+
+    asyncio.run(run(only=args.only, dry_run=args.dry_run, limit=args.limit))
+
+
+if __name__ == "__main__":
+    main()

package/templates/vault/instagram/scripts/schedule.py

@@ -0,0 +1,189 @@
+"""
+Orquestrador de publicação: processa posts approved/scheduled.
+
+Uso:
+    python scripts/schedule.py --process           # Publica posts prontos
+    python scripts/schedule.py --list              # Lista posts pendentes
+    python scripts/schedule.py --cancel --id 5     # Cancela agendamento
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from api_client import InstagramAPI
+from auth import auto_refresh_if_needed
+from db import Database
+from governance import GovernanceManager, RateLimitExceeded
+
+db = Database()
+db.init()
+gov = GovernanceManager(db)
+
+
+async def process_pending() -> None:
+    """Processa todos os posts approved/scheduled prontos para publicar."""
+    await auto_refresh_if_needed()
+    api = InstagramAPI()
+    account = db.get_active_account()
+    if not account:
+        print(json.dumps({"error": "Nenhuma conta configurada"}, indent=2))
+        return
+
+    posts = db.get_posts_for_publishing(account["id"])
+    if not posts:
+        print(json.dumps({"message": "Nenhum post pendente para publicar", "count": 0}, indent=2))
+        return
+
+    print(f"Processando {len(posts)} posts...")
+    results = []
+
+    for post in posts:
+        post_id = post["id"]
+        try:
+            gov.check_rate_limit(f"publish_{post['media_type'].lower()}", account["id"])
+        except RateLimitExceeded as e:
+            results.append({"post_id": post_id, "status": "rate_limited", "error": str(e)})
+            break
+
+        try:
+            # Recovery: se já tem container criado, tenta publicar direto
+            if post["status"] == "container_created" and post.get("ig_container_id"):
+                result = await api.publish_media(post["ig_container_id"])
+                ig_media_id = result.get("id")
+                details = await api.get_media_details(ig_media_id)
+                db.update_post_status(
+                    post_id, "published",
+                    ig_media_id=ig_media_id,
+                    permalink=details.get("permalink", ""),
+                    published_at=details.get("timestamp", ""),
+                )
+                results.append({"post_id": post_id, "status": "published", "ig_media_id": ig_media_id})
+                continue
+
+            # Publicação normal
+            media_url = post.get("media_url", "")
+            if not media_url and post.get("local_path"):
+                media_url = await api.upload_to_imgur(post["local_path"])
+                db.update_post_status(post_id, post["status"], media_url=media_url)
+
+            media_type = post["media_type"].upper()
+            ig_type_map = {"PHOTO": "IMAGE", "VIDEO": "VIDEO", "REEL": "REELS", "STORY": "STORIES"}
+            ig_type = ig_type_map.get(media_type, "IMAGE")
+
+            if media_type == "CAROUSEL":
+                results.append({"post_id": post_id, "status": "skipped", "reason": "Carrosséis precisam ser publicados via publish.py"})
+                continue
+
+            # Step 1: Container
+            container_params = {"caption": post.get("caption")}
+            if ig_type == "IMAGE":
+                container_params["media_type"] = "IMAGE"
+                container_params["image_url"] = media_url
+            else:
+                container_params["media_type"] = ig_type
+                container_params["video_url"] = media_url
+
+            container = await api.create_media_container(**container_params)
+            container_id = container["id"]
+            db.update_post_status(post_id, "container_created", ig_container_id=container_id)
+
+            # Para vídeos, aguardar processamento
+            if media_type in ("VIDEO", "REEL"):
+                for _ in range(60):
+                    status = await api.check_container_status(container_id)
+                    if status.get("status_code") == "FINISHED":
+                        break
+                    if status.get("status_code") == "ERROR":
+                        raise Exception(status.get("status", "Erro no processamento"))
+                    await asyncio.sleep(5)
+
+            # Step 2: Publicar
+            result = await api.publish_media(container_id)
+            ig_media_id = result.get("id")
+            details = await api.get_media_details(ig_media_id)
+            permalink = details.get("permalink", "")
+
+            db.update_post_status(
+                post_id, "published",
+                ig_media_id=ig_media_id,
+                permalink=permalink,
+                published_at=details.get("timestamp", ""),
+            )
+
+            gov.log_action(
+                f"publish_{media_type.lower()}",
+                params={"post_id": post_id},
+                result={"ig_media_id": ig_media_id, "permalink": permalink},
+                account_id=account["id"],
+            )
+
+            results.append({"post_id": post_id, "status": "published", "ig_media_id": ig_media_id, "permalink": permalink})
+
+        except Exception as e:
+            db.update_post_status(post_id, "failed", error_msg=str(e))
+            results.append({"post_id": post_id, "status": "failed", "error": str(e)})
+
+    await api.close()
+    print(json.dumps({"processed": len(results), "results": results}, indent=2, ensure_ascii=False))
+
+
+async def list_pending() -> None:
+    """Lista posts pendentes."""
+    account = db.get_active_account()
+    if not account:
+        print(json.dumps({"error": "Nenhuma conta configurada"}, indent=2))
+        return
+
+    drafts = db.get_posts(account_id=account["id"], status="draft")
+    approved = db.get_posts(account_id=account["id"], status="approved")
+    scheduled = db.get_posts(account_id=account["id"], status="scheduled")
+    failed = db.get_posts(account_id=account["id"], status="failed")
+
+    print(json.dumps({
+        "draft": {"count": len(drafts), "posts": drafts},
+        "approved": {"count": len(approved), "posts": approved},
+        "scheduled": {"count": len(scheduled), "posts": scheduled},
+        "failed": {"count": len(failed), "posts": failed},
+    }, indent=2, ensure_ascii=False))
+
+
+async def cancel_post(post_id: int) -> None:
+    """Cancela um post (move para status cancelled)."""
+    post = db.get_post_by_id(post_id)
+    if not post:
+        print(json.dumps({"error": f"Post {post_id} não encontrado"}, indent=2))
+        return
+    if post["status"] == "published":
+        print(json.dumps({"error": "Não é possível cancelar post já publicado"}, indent=2))
+        return
+    db.update_post_status(post_id, "draft")
+    print(json.dumps({"status": "cancelled", "post_id": post_id}, indent=2))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Agendamento de posts Instagram")
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--process", action="store_true", help="Processar posts pendentes")
+    group.add_argument("--list", action="store_true", help="Listar posts pendentes")
+    group.add_argument("--cancel", action="store_true", help="Cancelar agendamento")
+    parser.add_argument("--id", type=int, help="ID do post (para --cancel)")
+    args = parser.parse_args()
+
+    if args.process:
+        asyncio.run(process_pending())
+    elif args.list:
+        asyncio.run(list_pending())
+    elif args.cancel:
+        if not args.id:
+            parser.error("--id é obrigatório com --cancel")
+        asyncio.run(cancel_post(args.id))
+
+
+if __name__ == "__main__":
+    main()

package/templates/vault/instagram/scripts/serve_api.py

@@ -0,0 +1,234 @@
+"""
+API REST e dashboard para dados do Instagram.
+
+Uso:
+    python scripts/serve_api.py
+    python scripts/serve_api.py --port 8080 --host 0.0.0.0
+
+Endpoints:
+    GET /                           → info da API
+    GET /api/posts                  → posts com filtros
+    GET /api/comments               → comentários
+    GET /api/insights/summary       → resumo de insights
+    GET /api/insights/best-times    → melhores horários
+    GET /api/stats                  → estatísticas gerais
+    GET /api/export/{format}        → exportação
+    GET /api/templates              → templates
+    GET /api/actions                → audit log
+    GET /dashboard                  → dashboard HTML
+    GET /webhook                    → stub para v2
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import io
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from config import STATIC_DIR
+from db import Database
+
+try:
+    from fastapi import FastAPI, Query
+    from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, PlainTextResponse, StreamingResponse
+    import uvicorn
+except ImportError:
+    print("FastAPI não instalado. Execute: pip install fastapi uvicorn")
+    sys.exit(1)
+
+app = FastAPI(
+    title="Instagram Dashboard API",
+    description="API REST para dados e analytics do Instagram",
+    version="1.0.0",
+)
+
+db = Database()
+db.init()
+
+
+@app.get("/", summary="Info da API")
+def root():
+    stats = db.get_stats()
+    return {
+        "name": "Instagram Dashboard API",
+        "version": "1.0.0",
+        "stats": stats,
+        "endpoints": {
+            "posts": "/api/posts",
+            "comments": "/api/comments",
+            "insights_summary": "/api/insights/summary",
+            "insights_best_times": "/api/insights/best-times",
+            "stats": "/api/stats",
+            "templates": "/api/templates",
+            "actions": "/api/actions",
+            "dashboard": "/dashboard",
+        },
+    }
+
+
+@app.get("/api/posts", summary="Lista posts")
+def list_posts(
+    status: str = Query(None, description="Filtrar por status"),
+    limit: int = Query(50, ge=1, le=500),
+    offset: int = Query(0, ge=0),
+):
+    account = db.get_active_account()
+    account_id = account["id"] if account else None
+    posts = db.get_posts(account_id=account_id, status=status, limit=limit, offset=offset)
+    return {"total": len(posts), "data": posts}
+
+
+@app.get("/api/comments", summary="Lista comentários")
+def list_comments(
+    media_id: str = Query(None),
+    unreplied: bool = Query(False),
+    limit: int = Query(50, ge=1, le=500),
+):
+    account = db.get_active_account()
+    account_id = account["id"] if account else None
+    comments = db.get_comments(
+        ig_media_id=media_id,
+        account_id=account_id,
+        unreplied_only=unreplied,
+        limit=limit,
+    )
+    return {"total": len(comments), "data": comments}
+
+
+@app.get("/api/insights/summary", summary="Resumo de insights")
+def insights_summary():
+    conn = db._connect()
+    # Engajamento médio por tipo de conteúdo
+    rows = conn.execute("""
+        SELECT p.media_type,
+               COUNT(DISTINCT p.id) as post_count,
+               AVG(CASE WHEN i.metric_name='engagement' THEN i.metric_value END) as avg_engagement,
+               AVG(CASE WHEN i.metric_name='reach' THEN i.metric_value END) as avg_reach,
+               AVG(CASE WHEN i.metric_name='impressions' THEN i.metric_value END) as avg_impressions
+        FROM posts p
+        LEFT JOIN insights i ON i.ig_media_id = p.ig_media_id
+        WHERE p.status = 'published'
+        GROUP BY p.media_type
+    """).fetchall()
+
+    return {"by_media_type": [dict(r) for r in rows]}
+
+
+@app.get("/api/insights/best-times", summary="Melhores horários para postar")
+def best_times():
+    conn = db._connect()
+    rows = conn.execute("""
+        SELECT
+            strftime('%H', p.published_at) as hour,
+            strftime('%w', p.published_at) as weekday,
+            COUNT(DISTINCT p.id) as post_count,
+            AVG(i.metric_value) as avg_engagement
+        FROM posts p
+        JOIN insights i ON i.ig_media_id = p.ig_media_id
+        WHERE p.status = 'published' AND p.published_at IS NOT NULL
+          AND i.metric_name IN ('engagement', 'reach')
+        GROUP BY hour, weekday
+        ORDER BY avg_engagement DESC
+    """).fetchall()
+
+    weekday_names = ["Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sáb"]
+    data = []
+    for r in rows:
+        data.append({
+            "hour": f"{r['hour']}:00" if r["hour"] else "?",
+            "weekday": weekday_names[int(r["weekday"])] if r["weekday"] else "?",
+            "posts": r["post_count"],
+            "avg_engagement": round(r["avg_engagement"], 1) if r["avg_engagement"] else 0,
+        })
+    return {"data": data}
+
+
+@app.get("/api/stats", summary="Estatísticas gerais")
+def stats():
+    return db.get_stats()
+
+
+@app.get("/api/templates", summary="Templates de conteúdo")
+def list_templates():
+    templates = db.get_templates()
+    return {"total": len(templates), "data": templates}
+
+
+@app.get("/api/actions", summary="Audit log recente")
+def recent_actions(limit: int = Query(50, ge=1, le=500)):
+    actions = db.get_recent_actions(limit=limit)
+    return {"total": len(actions), "data": actions}
+
+
+@app.get("/api/export/json", summary="Exportar posts em JSON")
+def export_json():
+    account = db.get_active_account()
+    posts = db.get_posts(account_id=account["id"] if account else None, limit=5000)
+    return JSONResponse(
+        content={"total": len(posts), "data": posts},
+        headers={"Content-Disposition": "attachment; filename=instagram_posts.json"},
+    )
+
+
+@app.get("/api/export/csv", summary="Exportar posts em CSV")
+def export_csv():
+    account = db.get_active_account()
+    posts = db.get_posts(account_id=account["id"] if account else None, limit=5000)
+    if not posts:
+        return PlainTextResponse("Sem dados.")
+    output = io.StringIO()
+    writer = csv.DictWriter(output, fieldnames=list(posts[0].keys()), extrasaction="ignore")
+    writer.writeheader()
+    writer.writerows(posts)
+    output.seek(0)
+    return StreamingResponse(
+        iter([output.getvalue()]),
+        media_type="text/csv",
+        headers={"Content-Disposition": "attachment; filename=instagram_posts.csv"},
+    )
+
+
+@app.get("/dashboard", summary="Dashboard visual")
+def dashboard():
+    dashboard_path = STATIC_DIR / "dashboard.html"
+    if dashboard_path.exists():
+        return FileResponse(dashboard_path, media_type="text/html")
+    return HTMLResponse("<h1>Dashboard não encontrado</h1><p>Crie static/dashboard.html</p>")
+
+
+@app.get("/webhook", summary="Webhook stub (v2)")
+def webhook_stub():
+    return {"status": "ok", "message": "Webhook endpoint ready (v2)"}
+
+
+@app.post("/webhook", summary="Webhook receiver (v2)")
+def webhook_receive():
+    return {"status": "ok"}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="API Instagram Dashboard")
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--reload", action="store_true")
+    args = parser.parse_args()
+
+    print(f"\nAPI: http://{args.host}:{args.port}")
+    print(f"Dashboard: http://{args.host}:{args.port}/dashboard")
+    print(f"Docs: http://{args.host}:{args.port}/docs\n")
+
+    uvicorn.run(
+        "serve_api:app",
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        app_dir=str(Path(__file__).parent),
+    )
+
+
+if __name__ == "__main__":
+    main()