@agentunion/kite 1.4.0 → 1.6.0

package/extensions/services/backup/module.md

@@ -4,6 +4,7 @@ display_name: Backup
 version: '1.0'
 type: service
 state: enabled
+max_connections: 3
 runtime: python
 entry: entry.py
 events:
@@ -12,9 +13,10 @@ subscriptions:
 - module.started
 - module.stopped
 - module.shutdown
-preferred_port: 20000
-advertise_ip: 127.0.0.1
 monitor: true
+connection_elastic: false
+max_instances: 1
+instance_elastic: false
 ---
 # Backup（备份模块）
 

package/extensions/services/dataclaw/api/admin.py

@@ -0,0 +1,367 @@
+"""
+管理后台 API
+"""
+import uuid
+import random
+import string
+import hashlib
+from datetime import datetime, timedelta
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from core.auth import require_auth
+from core.database import get_session
+
+router = APIRouter()
+DISC = {"entry": "/.well-known/agent-data-exchange.json"}
+
+
+@router.get("/stats")
+async def get_platform_stats(
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """平台总体统计"""
+    total_agents = (await session.execute(text("SELECT COUNT(*) FROM agents WHERE status='active'"))).scalar()
+    total_feeds = (await session.execute(text("SELECT COUNT(*) FROM feeds WHERE status='active'"))).scalar()
+    total_subs = (await session.execute(text("SELECT COUNT(*) FROM subscriptions"))).scalar()
+    total_versions = (await session.execute(text("SELECT COUNT(*) FROM feed_versions"))).scalar()
+    total_credits = (await session.execute(
+        text("SELECT COALESCE(SUM(amount),0) FROM credit_transactions WHERE type='deposit'")
+    )).scalar()
+    pending_reports = (await session.execute(
+        text("SELECT COUNT(*) FROM reports WHERE status='pending'")
+    )).scalar()
+    pending_complaints = (await session.execute(
+        text("SELECT COUNT(*) FROM copyright_complaints WHERE status='pending'")
+    )).scalar()
+    total_queries = (await session.execute(
+        text("SELECT COUNT(*) FROM feed_versions")
+    )).scalar()
+    total_credit_volume = (await session.execute(
+        text("SELECT COALESCE(SUM(ABS(amount)),0) FROM credit_transactions")
+    )).scalar()
+    return {"ok": True, "data": {
+        "total_agents": total_agents, "active_feeds": total_feeds,
+        "total_subscriptions": total_subs, "total_versions": total_versions,
+        "total_queries": total_queries or 0,
+        "total_credit_volume": float(total_credit_volume or 0),
+        "total_deposits": float(total_credits or 0),
+        "pending_reports": pending_reports,
+        "pending_complaints": pending_complaints
+    }, "_discovery": DISC}
+
+
+@router.get("/agents")
+async def list_agents(
+    status: Optional[str] = Query(None),
+    q: Optional[str] = Query(None),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    conditions = ["1=1"]
+    params = {"lim": limit, "off": offset}
+    if status:
+        conditions.append("status=:status")
+        params["status"] = status
+    if q:
+        conditions.append("name LIKE :q")
+        params["q"] = f"%{q}%"
+    where = " AND ".join(conditions)
+    rows = (await session.execute(
+        text(f"SELECT id, name, type, verified, credits, status, created_at "
+             f"FROM agents WHERE {where} ORDER BY created_at DESC LIMIT :lim OFFSET :off"),
+        params
+    )).fetchall()
+    total = (await session.execute(
+        text(f"SELECT COUNT(*) FROM agents WHERE {where}"),
+        {k: v for k, v in params.items() if k not in ('lim', 'off')}
+    )).scalar()
+    agents = [
+        {"id": r.id, "name": r.name, "type": r.type,
+         "verified": bool(r.verified), "credits": float(r.credits),
+         "status": r.status,
+         "created_at": r.created_at.isoformat() if r.created_at else None}
+        for r in rows
+    ]
+    return {"ok": True, "data": {"agents": agents, "total": total}, "_discovery": DISC}
+
+
+@router.post("/agents/{target_id}/suspend")
+async def suspend_agent(
+    target_id: str,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    await session.execute(
+        text("UPDATE agents SET status='suspended' WHERE id=:tid"), {"tid": target_id}
+    )
+    await session.commit()
+    return {"ok": True, "data": {"agent_id": target_id, "status": "suspended"}, "_discovery": DISC}
+
+
+@router.post("/agents/{target_id}/activate")
+async def activate_agent(
+    target_id: str,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    await session.execute(
+        text("UPDATE agents SET status='active' WHERE id=:tid"), {"tid": target_id}
+    )
+    await session.commit()
+    return {"ok": True, "data": {"agent_id": target_id, "status": "active"}, "_discovery": DISC}
+
+
+@router.get("/feeds")
+async def admin_list_feeds(
+    status: Optional[str] = Query(None),
+    q: Optional[str] = Query(None),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    conditions = ["1=1"]
+    params = {"lim": limit, "off": offset}
+    if status:
+        conditions.append("f.status=:status")
+        params["status"] = status
+    if q:
+        conditions.append("f.name LIKE :q")
+        params["q"] = f"%{q}%"
+    where = " AND ".join(conditions)
+    rows = (await session.execute(
+        text(f"SELECT f.id, f.name, f.status, f.subscriber_count, f.reputation_score, "
+             f"f.created_at, a.name AS owner_name "
+             f"FROM feeds f LEFT JOIN agents a ON a.id=f.owner_id "
+             f"WHERE {where} ORDER BY f.created_at DESC LIMIT :lim OFFSET :off"),
+        params
+    )).fetchall()
+    total = (await session.execute(
+        text(f"SELECT COUNT(*) FROM feeds f WHERE {where}"),
+        {k: v for k, v in params.items() if k not in ('lim', 'off')}
+    )).scalar()
+    feeds = [
+        {"id": r.id, "name": r.name, "status": r.status,
+         "subscriber_count": r.subscriber_count,
+         "reputation_score": float(r.reputation_score),
+         "owner_name": r.owner_name,
+         "created_at": r.created_at.isoformat() if r.created_at else None}
+        for r in rows
+    ]
+    return {"ok": True, "data": {"feeds": feeds, "total": total}, "_discovery": DISC}
+
+
+@router.get("/reports")
+async def list_reports(
+    status: Optional[str] = Query("pending"),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    params = {"status": status, "lim": limit, "off": offset}
+    rows = (await session.execute(
+        text("SELECT id, feed_id, reason, description, status, created_at "
+             "FROM reports WHERE status=:status ORDER BY created_at DESC LIMIT :lim OFFSET :off"),
+        params
+    )).fetchall()
+    total = (await session.execute(
+        text("SELECT COUNT(*) FROM reports WHERE status=:status"), {"status": status}
+    )).scalar()
+    reports = [
+        {"id": r.id, "feed_id": r.feed_id, "reason": r.reason,
+         "description": r.description, "status": r.status,
+         "created_at": r.created_at.isoformat() if r.created_at else None}
+        for r in rows
+    ]
+    return {"ok": True, "data": {"reports": reports, "total": total}, "_discovery": DISC}
+
+
+@router.post("/reports/{report_id}/resolve")
+async def resolve_report(
+    report_id: int,
+    action: str = Query(..., description="resolve/reject"),
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    status = "resolved" if action == "resolve" else "rejected"
+    await session.execute(
+        text("UPDATE reports SET status=:s, resolved_at=NOW() WHERE id=:rid"),
+        {"s": status, "rid": report_id}
+    )
+    await session.commit()
+    return {"ok": True, "data": {"report_id": report_id, "status": status}, "_discovery": DISC}
+
+
+# ── 辅助函数 ──────────────────────────────────────────────
+
+def _uid(prefix="", length=16):
+    return prefix + uuid.uuid4().hex[:length]
+
+
+def _hash(raw: str) -> str:
+    return hashlib.sha256(raw.encode()).hexdigest()
+
+
+_SEED_NAMES = [
+    "GitHub Trending 日报", "Hacker News 摘要", "Reddit 热帖",
+    "Product Hunt 新品", "V2EX 热议", "知乎热榜", "微博热搜",
+    "ArXiv 论文速递", "NPM 新包监控", "Docker Hub 趋势",
+    "Stack Overflow 热问", "DEV.to 精选",
+]
+
+_AGENT_NAMES = [
+    "lobster-bot", "data-miner", "news-crawler", "feed-master",
+    "info-scout", "web-spider", "api-watcher", "trend-tracker",
+]
+
+
+# ── Seed ──────────────────────────────────────────────────
+
+@router.post("/seed")
+async def seed_data(
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """追加一批模拟数据"""
+    now = datetime.utcnow()
+    agents_created = 0
+    feeds_created = 0
+    subs_created = 0
+    versions_created = 0
+    demands_created = 0
+    txns_created = 0
+
+    # 1) 生成 agents
+    agent_ids = []
+    for name in _AGENT_NAMES:
+        aid = _uid("ag_")
+        agent_ids.append(aid)
+        suffix = ''.join(random.choices(string.digits, k=4))
+        await session.execute(text(
+            "INSERT INTO agents (id, name, type, description, verified, credits, status, created_at, updated_at) "
+            "VALUES (:id, :name, :type, :desc, :verified, :credits, 'active', :now, :now)"
+        ), {
+            "id": aid, "name": f"{name}-{suffix}", "type": random.choice(["custom", "openclaw", "autogpt"]),
+            "desc": f"Seed agent {name}", "verified": random.randint(0, 1),
+            "credits": round(random.uniform(10, 5000), 2), "now": now,
+        })
+        agents_created += 1
+
+        # api_key
+        raw_key = f"dc_live_seed_{aid}"
+        await session.execute(text(
+            "INSERT INTO api_keys (id, agent_id, key_hash, key_prefix, name, status, created_at) "
+            "VALUES (:id, :aid, :hash, :prefix, 'default', 'active', :now)"
+        ), {"id": _uid("ak_"), "aid": aid, "hash": _hash(raw_key), "prefix": raw_key[:12], "now": now})
+
+    # 2) 生成 feeds
+    feed_ids = []
+    for i, fname in enumerate(_SEED_NAMES):
+        fid = _uid("fd_")
+        feed_ids.append(fid)
+        owner = random.choice(agent_ids)
+        suffix = ''.join(random.choices(string.digits, k=3))
+        await session.execute(text(
+            "INSERT INTO feeds (id, owner_id, name, description, schema_def, update_cycle, "
+            "reputation_score, subscriber_count, total_queries, status, created_at, updated_at) "
+            "VALUES (:id, :owner, :name, :desc, :schema, :cycle, :rep, :subs, :queries, 'active', :now, :now)"
+        ), {
+            "id": fid, "owner": owner, "name": f"{fname}-{suffix}",
+            "desc": f"Seed feed: {fname}", "schema": '{"type":"object"}',
+            "cycle": random.choice(["5m", "1h", "24h", "realtime"]),
+            "rep": round(random.uniform(3.0, 5.0), 2),
+            "subs": random.randint(0, 200),
+            "queries": random.randint(0, 10000), "now": now,
+        })
+        feeds_created += 1
+
+        # feed_versions (2 per feed)
+        for v in range(1, 3):
+            await session.execute(text(
+                "INSERT INTO feed_versions (feed_id, version_num, data, summary, size_bytes, created_at) "
+                "VALUES (:fid, :ver, :data, :summary, :size, :ts)"
+            ), {
+                "fid": fid, "ver": v,
+                "data": '{"sample": true}',
+                "summary": f"v{v} seed data",
+                "size": random.randint(100, 50000),
+                "ts": now - timedelta(hours=random.randint(0, 48)),
+            })
+            versions_created += 1
+
+    # 3) 生成 subscriptions
+    for _ in range(min(len(agent_ids) * 2, len(feed_ids))):
+        await session.execute(text(
+            "INSERT IGNORE INTO subscriptions (id, agent_id, feed_id, subscribed_at) "
+            "VALUES (:id, :aid, :fid, :now)"
+        ), {"id": _uid("sub_"), "aid": random.choice(agent_ids), "fid": random.choice(feed_ids), "now": now})
+        subs_created += 1
+
+    # 4) 生成 demands
+    demand_titles = ["实时汇率数据", "每日天气预报", "电商价格监控", "社交媒体舆情"]
+    for title in demand_titles:
+        did = _uid("dm_")
+        await session.execute(text(
+            "INSERT INTO demands (id, created_by, title, description, desired_update_cycle, "
+            "upvotes, subscriber_count, status, created_at, updated_at) "
+            "VALUES (:id, :by, :title, :desc, :cycle, :up, :sub, 'open', :now, :now)"
+        ), {
+            "id": did, "by": random.choice(agent_ids), "title": title,
+            "desc": f"Seed demand: {title}", "cycle": random.choice(["daily", "realtime"]),
+            "up": random.randint(0, 50), "sub": random.randint(0, 20), "now": now,
+        })
+        demands_created += 1
+
+    # 5) 生成 credit_transactions
+    for aid in agent_ids:
+        for _ in range(random.randint(1, 3)):
+            await session.execute(text(
+                "INSERT INTO credit_transactions (id, agent_id, type, amount, balance_after, description, created_at) "
+                "VALUES (:id, :aid, :type, :amt, :bal, :desc, :now)"
+            ), {
+                "id": _uid("tx_"), "aid": aid,
+                "type": random.choice(["deposit", "earn", "spend", "bonus"]),
+                "amt": round(random.uniform(-100, 500), 2),
+                "bal": round(random.uniform(0, 5000), 2),
+                "desc": "seed transaction", "now": now,
+            })
+            txns_created += 1
+
+    await session.commit()
+    return {"ok": True, "data": {
+        "agents": agents_created, "feeds": feeds_created,
+        "versions": versions_created, "subscriptions": subs_created,
+        "demands": demands_created, "transactions": txns_created,
+    }, "_discovery": DISC}
+
+
+# ── Clear ─────────────────────────────────────────────────
+
+@router.post("/seed/clear")
+async def clear_seed_data(
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """按外键顺序清空所有表"""
+    tables = [
+        "demand_upvotes", "demand_subscriptions",
+        "subscriptions", "reviews", "reports", "copyright_complaints",
+        "notifications", "credit_transactions", "feed_versions",
+        "feeds", "verification_codes", "api_keys", "agent_contacts",
+        "demands", "agents",
+    ]
+    deleted = {}
+    for tbl in tables:
+        r = await session.execute(text(f"DELETE FROM {tbl}"))
+        deleted[tbl] = r.rowcount
+    await session.commit()
+    return {"ok": True, "data": {"deleted": deleted}, "_discovery": DISC}

package/extensions/services/dataclaw/api/copyright.py

@@ -0,0 +1,175 @@
+"""
+版权保护 API — 投诉下架 + 分润
+"""
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from core.auth import require_auth
+from core.database import get_session
+from utils.id_generator import gen_complaint_id
+
+router = APIRouter()
+DISC = {"entry": "/.well-known/agent-data-exchange.json"}
+
+
+class ComplaintRequest(BaseModel):
+    feed_id: str
+    complainant_name: str
+    complainant_contact: str
+    evidence: str
+    preferred_resolution: str = "takedown"  # takedown / revenue_share
+    revenue_share_ratio: Optional[float] = None  # 0.10 - 0.50
+
+
+class ResolveRequest(BaseModel):
+    resolution: str  # takedown / revenue_share / rejected
+    revenue_share_ratio: Optional[float] = None
+    note: str = ""
+
+
+@router.post("/complaints")
+async def create_complaint(
+    body: ComplaintRequest,
+    session: AsyncSession = Depends(get_session)
+):
+    """提交版权投诉（无需登录）"""
+    feed = (await session.execute(
+        text("SELECT id FROM feeds WHERE id=:fid AND status!='deleted'"),
+        {"fid": body.feed_id}
+    )).fetchone()
+    if not feed:
+        raise HTTPException(404, detail={"ok": False, "error": "FEED_NOT_FOUND", "_discovery": DISC})
+    if body.preferred_resolution == "revenue_share":
+        ratio = body.revenue_share_ratio or 0.10
+        if not 0.10 <= ratio <= 0.50:
+            raise HTTPException(400, detail={"ok": False, "error": "INVALID_RATIO",
+                                              "message": "分润比例必须在 10%-50% 之间", "_discovery": DISC})
+    complaint_id = gen_complaint_id()
+    await session.execute(
+        text("""
+            INSERT INTO copyright_complaints
+                (id, feed_id, complainant_name, complainant_contact, evidence, status)
+            VALUES (:id, :fid, :name, :contact, :evidence, 'pending')
+        """),
+        {"id": complaint_id, "fid": body.feed_id,
+         "name": body.complainant_name, "contact": body.complainant_contact,
+         "evidence": body.evidence}
+    )
+    await session.commit()
+    return {"ok": True, "data": {
+        "complaint_id": complaint_id,
+        "status": "pending",
+        "message": "投诉已提交，平台将在 24 小时内完成初审"
+    }, "_discovery": DISC}
+
+
+@router.get("/complaints")
+async def list_complaints(
+    status: Optional[str] = Query(None),
+    limit: int = Query(20, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """管理员查看投诉列表"""
+    conditions = ["1=1"]
+    params = {"lim": limit, "off": offset}
+    if status:
+        conditions.append("status=:status")
+        params["status"] = status
+    where = " AND ".join(conditions)
+    rows = (await session.execute(
+        text(f"SELECT id, feed_id, complainant_name, complainant_contact, status, "
+             f"resolution, revenue_share_ratio, created_at, resolved_at "
+             f"FROM copyright_complaints WHERE {where} "
+             f"ORDER BY created_at DESC LIMIT :lim OFFSET :off"),
+        params
+    )).fetchall()
+    total = (await session.execute(
+        text(f"SELECT COUNT(*) FROM copyright_complaints WHERE {where}"),
+        {k: v for k, v in params.items() if k not in ('lim', 'off')}
+    )).scalar()
+    complaints = []
+    for r in rows:
+        complaints.append({
+            "id": r.id, "feed_id": r.feed_id,
+            "complainant_name": r.complainant_name,
+            "complainant_contact": r.complainant_contact,
+            "status": r.status, "resolution": r.resolution,
+            "revenue_share_ratio": float(r.revenue_share_ratio) if r.revenue_share_ratio else None,
+            "created_at": r.created_at.isoformat() if r.created_at else None,
+            "resolved_at": r.resolved_at.isoformat() if r.resolved_at else None
+        })
+    return {"ok": True, "data": {"complaints": complaints, "total": total}, "_discovery": DISC}
+
+
+@router.get("/complaints/{complaint_id}")
+async def get_complaint(
+    complaint_id: str,
+    session: AsyncSession = Depends(get_session)
+):
+    row = (await session.execute(
+        text("SELECT id, feed_id, complainant_name, evidence, status, resolution, "
+             "revenue_share_ratio, created_at, resolved_at "
+             "FROM copyright_complaints WHERE id=:cid"),
+        {"cid": complaint_id}
+    )).fetchone()
+    if not row:
+        raise HTTPException(404, detail={"ok": False, "error": "NOT_FOUND", "_discovery": DISC})
+    return {"ok": True, "data": {
+        "id": row.id, "feed_id": row.feed_id,
+        "complainant_name": row.complainant_name,
+        "evidence": row.evidence, "status": row.status,
+        "resolution": row.resolution,
+        "revenue_share_ratio": float(row.revenue_share_ratio) if row.revenue_share_ratio else None,
+        "created_at": row.created_at.isoformat() if row.created_at else None,
+        "resolved_at": row.resolved_at.isoformat() if row.resolved_at else None
+    }, "_discovery": DISC}
+
+
+@router.post("/complaints/{complaint_id}/resolve")
+async def resolve_complaint(
+    complaint_id: str,
+    body: ResolveRequest,
+    agent_id: str = Depends(require_auth),
+    session: AsyncSession = Depends(get_session)
+):
+    """管理员处理投诉"""
+    row = (await session.execute(
+        text("SELECT id, feed_id, status FROM copyright_complaints WHERE id=:cid"),
+        {"cid": complaint_id}
+    )).fetchone()
+    if not row:
+        raise HTTPException(404, detail={"ok": False, "error": "NOT_FOUND", "_discovery": DISC})
+    if row.status not in ("pending", "reviewing"):
+        raise HTTPException(400, detail={"ok": False, "error": "ALREADY_RESOLVED",
+                                          "message": "该投诉已处理", "_discovery": DISC})
+    valid = {"takedown", "revenue_share", "rejected"}
+    if body.resolution not in valid:
+        raise HTTPException(400, detail={"ok": False, "error": "INVALID_RESOLUTION", "_discovery": DISC})
+    if body.resolution == "takedown":
+        await session.execute(
+            text("UPDATE feeds SET status='archived' WHERE id=:fid"), {"fid": row.feed_id}
+        )
+    await session.execute(
+        text("""
+            UPDATE copyright_complaints
+            SET status='upheld', resolution=:res, revenue_share_ratio=:ratio, resolved_at=NOW()
+            WHERE id=:cid
+        """),
+        {"res": body.resolution,
+         "ratio": body.revenue_share_ratio if body.resolution == "revenue_share" else None,
+         "cid": complaint_id}
+    )
+    await session.commit()
+    msg_map = {
+        "takedown": "接口已下架",
+        "revenue_share": f"分润协议已生效，比例 {body.revenue_share_ratio or 0.1:.0%}",
+        "rejected": "投诉已驳回"
+    }
+    return {"ok": True, "data": {"complaint_id": complaint_id, "resolution": body.resolution,
+                                  "message": msg_map[body.resolution]}, "_discovery": DISC}