@tikomni/skills 1.0.6 → 1.0.7

package/skills/social-media-crawl/references/guides/generic-mcp-objects.md

@@ -1,40 +0,0 @@
-# Generic MCP Objects Guide
-
-The following objects do not freeze a fine-grained schema in the first release:
-
-- Comment threads
-- Search results
-- Ranking pages
-- Livestream rooms
-- Product pages
-
-In addition, every platform and object combination that does not match a fixed pipeline falls under this guide, for example:
-
-- A single X/Twitter post
-- An X/Twitter thread
-- An X/Twitter long-form post
-- An X/Twitter creator homepage
-- The top N comments from a comment section
-
-## Rules
-
-- Route these objects through the generic MCP workflow inside this skill.
-- The platform is not limited to the Douyin and Xiaohongshu cases covered by fixed pipelines. If the platform is discoverable in the MCP catalog, try this workflow first.
-- Detect the object first, then use `catalog.search` and `endpoint.describe` to choose the smallest toolchain.
-- Do not jump to browser/CDP only because the platform is not Douyin or Xiaohongshu.
-- Use browser/CDP only when the generic MCP path is unavailable, or when the task explicitly requires page-level interaction that the API cannot satisfy. Explain the reason in the output.
-- The output must satisfy the unified envelope.
-- No card write is required in the first release.
-- Do not fabricate fields only to satisfy schema completeness.
-
-## Minimum Deliverable
-
-- `object_type`
-- `platform`
-- `input`
-- `normalized`
-- `request_id`
-- `completeness`
-- `missing_fields`
-- `error_reason`
-- `extract_trace`

package/skills/social-media-crawl/references/mcp-usage-contract.md

@@ -1,40 +0,0 @@
-# MCP Usage Contract
-
-## Scope
-
-- This contract applies to every social-media object that does not match a fixed pipeline, not only Douyin and Xiaohongshu.
-- The currently supported platforms include Douyin, Xiaohongshu, Kuaishou, Bilibili, Weibo, TikTok, YouTube, Instagram, Threads, Twitter/X, Reddit, LinkedIn, WeChat Channels, Official Accounts, Toutiao, Xigua, Zhihu, Lemon8, and Pipixia.
-- Typical objects include X/Twitter posts, threads, long-form posts, creator homepages, comment sections, search results, ranking pages, livestream rooms, and product pages.
-- Fixed pipelines are frozen only for Douyin and Xiaohongshu single-work and creator-home cases. All other supported platform and object combinations should use the generic MCP path defined here.
-
-## Fixed Inputs
-
-- MCP URL: `https://mcp.tikomni.com/mcp`
-- Auth: `Authorization: Bearer <TIKOMNI_API_KEY>`
-- Do not repeat the API key inside tool parameters.
-
-## Required Tool Order
-
-1. Detect the platform and object type.
-2. Decide whether a fixed pipeline matches.
-3. If a fixed pipeline matches, run the fixed script directly and do not enter the generic MCP path.
-4. If no fixed pipeline matches:
-   - `tools/list`
-   - `catalog.search`
-   - `endpoint.describe`
-   - `api.call`
-5. If video text is required:
-   - `u2.submit`
-   - `u2.query`
-   - Enter the U3 fallback path if the task is still `pending` after 60 seconds.
-6. Use browser/CDP only when the generic MCP path is unavailable or clearly insufficient. Do not skip step 4 and jump straight to browser/CDP.
-
-## Output Rules
-
-- Keep factual fields separate from derived metadata.
-- The result must include `request_id`.
-- The result must include `completeness`.
-- The result must include `missing_fields`.
-- The result must include `error_reason`.
-- The result must include `extract_trace`.
-- If the flow ends in browser/CDP fallback, `extract_trace` must also include the earlier MCP attempts and the fallback reason.

package/skills/social-media-crawl/scripts/core/mcp_dispatch.py

@@ -1,161 +0,0 @@
-#!/usr/bin/env python3
-"""Minimal MCP HTTP client for social-media-crawl."""
-
-from __future__ import annotations
-
-import json
-import urllib.request
-from dataclasses import dataclass
-from typing import Any, Dict, Optional
-
-
-def _parse_response_body(body: bytes) -> Any:
-    text = body.decode("utf-8", errors="replace").strip()
-    if not text:
-        return {}
-    if text.startswith("data:"):
-        payloads = []
-        for line in text.splitlines():
-            if not line.startswith("data:"):
-                continue
-            payload = line.split("data:", 1)[1].strip()
-            if payload:
-                payloads.append(payload)
-        if payloads:
-            return json.loads(payloads[-1])
-    return json.loads(text)
-
-
-@dataclass
-class McpResponse:
-    ok: bool
-    status_code: int
-    data: Any
-    session_id: Optional[str]
-    error_reason: Optional[str] = None
-
-
-class McpHttpClient:
-    def __init__(self, *, url: str, api_key: str, timeout_ms: int = 60000) -> None:
-        self.url = url.rstrip("/")
-        self.api_key = api_key
-        self.timeout_ms = timeout_ms
-        self.session_id: Optional[str] = None
-        self._next_id = 1
-
-    def _headers(self) -> Dict[str, str]:
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "Accept": "application/json, text/event-stream",
-            "User-Agent": "OpenClaw-SocialMediaCrawl/0.1",
-            "X-Client-Name": "social-media-crawl",
-            "X-Client-Version": "0.1.0",
-        }
-        if self.session_id:
-            headers["mcp-session-id"] = self.session_id
-        return headers
-
-    def _request(self, payload: Dict[str, Any]) -> McpResponse:
-        req = urllib.request.Request(
-            self.url,
-            data=json.dumps(payload).encode("utf-8"),
-            headers=self._headers(),
-            method="POST",
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=max(self.timeout_ms / 1000.0, 1.0)) as response:
-                body = response.read()
-                data = _parse_response_body(body)
-                session_id = response.headers.get("mcp-session-id") or response.headers.get("Mcp-Session-Id")
-                if session_id:
-                    self.session_id = session_id
-                return McpResponse(ok=True, status_code=response.getcode(), data=data, session_id=self.session_id)
-        except urllib.error.HTTPError as error:
-            body = error.read()
-            try:
-                data = _parse_response_body(body)
-            except Exception:
-                data = {"raw": body.decode("utf-8", errors="replace")}
-            return McpResponse(
-                ok=False,
-                status_code=error.code,
-                data=data,
-                session_id=self.session_id,
-                error_reason=f"http_error:{error.code}",
-            )
-        except Exception as error:
-            return McpResponse(
-                ok=False,
-                status_code=0,
-                data={},
-                session_id=self.session_id,
-                error_reason=f"request_failed:{type(error).__name__}:{error}",
-            )
-
-    def _rpc(self, method: str, params: Optional[Dict[str, Any]] = None, notification: bool = False) -> McpResponse:
-        payload: Dict[str, Any] = {"jsonrpc": "2.0", "method": method}
-        if not notification:
-            payload["id"] = self._next_id
-            self._next_id += 1
-        if params is not None:
-            payload["params"] = params
-        return self._request(payload)
-
-    def initialize(self) -> McpResponse:
-        response = self._rpc(
-            "initialize",
-            {
-                "protocolVersion": "2025-03-26",
-                "capabilities": {},
-                "clientInfo": {"name": "social-media-crawl", "version": "0.1.0"},
-            },
-        )
-        if response.ok:
-            self._rpc("notifications/initialized", notification=True)
-        return response
-
-    def tools_list(self) -> McpResponse:
-        if not self.session_id:
-            init = self.initialize()
-            if not init.ok:
-                return init
-        return self._rpc("tools/list")
-
-    def tool_call(self, name: str, arguments: Optional[Dict[str, Any]] = None) -> McpResponse:
-        if not self.session_id:
-            init = self.initialize()
-            if not init.ok:
-                return init
-        return self._rpc("tools/call", {"name": name, "arguments": arguments or {}})
-
-    def catalog_search(self, query: str) -> McpResponse:
-        return self.tool_call("catalog.search", {"query": query})
-
-    def endpoint_describe(self, method: str, path: str) -> McpResponse:
-        return self.tool_call("endpoint.describe", {"method": method, "path": path})
-
-    def api_call(
-        self,
-        method: str,
-        path: str,
-        query: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, Any]] = None,
-        body: Optional[Any] = None,
-    ) -> McpResponse:
-        return self.tool_call(
-            "api.call",
-            {
-                "method": method,
-                "path": path,
-                "query": query or {},
-                "headers": headers or {},
-                "body": {} if body is None else body,
-            },
-        )
-
-    def u2_submit(self, file_url: str) -> McpResponse:
-        return self.tool_call("u2.submit", {"file_url": file_url})
-
-    def u2_query(self, task_id: str) -> McpResponse:
-        return self.tool_call("u2.query", {"task_id": task_id})