579 lines
19 KiB
Python
579 lines
19 KiB
Python
#!/usr/bin/env python3
|
|
"""socialmag — MCP stdio server.
|
|
|
|
Three tools:
|
|
create_post post to one or more platforms through abang's logged-in Brave
|
|
check_login which platforms are currently signed in
|
|
get_status the last create_post run's results
|
|
|
|
Transport is the standard MCP stdio pattern: one JSON-RPC message per line on
|
|
stdin, one per line on stdout. Nothing but protocol goes to stdout — logs go
|
|
to stderr.
|
|
|
|
Run: python3 -m socialmag (from the parent dir; expects Brave on :9222)
|
|
NOT `python3 server.py` — selectors.py/queue.py shadow stdlib modules
|
|
unless this runs as a package. See __init__.py.
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import os
|
|
import sys
|
|
import time
|
|
import urllib.parse
|
|
|
|
from .cdp import CDPClient, CDPError, DEFAULT_HTTP_ENDPOINT
|
|
from .platforms import facebook, instagram, threads, tiktok, twitter, youtube
|
|
from .queue import PostQueue
|
|
from .selectors import PLATFORMS as PLATFORM_SELECTORS
|
|
|
|
PROTOCOL_VERSION = "2025-06-18"
|
|
SERVER_NAME = "socialmag"
|
|
SERVER_VERSION = "0.1.0"
|
|
|
|
STATE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "state.json")
|
|
|
|
MODULES = {
|
|
"threads": threads,
|
|
"fb": facebook,
|
|
"ig": instagram,
|
|
"yt": youtube,
|
|
"tiktok": tiktok,
|
|
"twitter": twitter,
|
|
}
|
|
|
|
|
|
def _domain_of(platform):
|
|
"""The tab-match string for a platform, derived from its selectors URL —
|
|
'https://www.threads.com/' -> 'threads.com'. One source of truth: change a
|
|
platform's URL in selectors.py and tab matching follows it."""
|
|
host = urllib.parse.urlsplit(PLATFORM_SELECTORS[platform]["url"]).hostname
|
|
if not host:
|
|
raise RuntimeError(
|
|
f"selectors.PLATFORMS[{platform!r}]['url'] has no hostname: "
|
|
f"{PLATFORM_SELECTORS[platform]['url']!r}"
|
|
)
|
|
return host[4:] if host.startswith("www.") else host
|
|
|
|
|
|
# threads.com · facebook.com · instagram.com · youtube.com · tiktok.com · x.com
|
|
PLATFORM_DOMAINS = {p: _domain_of(p) for p in MODULES}
|
|
|
|
|
|
# The endpoint is a spec constant, not a fallback for missing config. Override
|
|
# with SOCIALMAG_CDP_ENDPOINT if Brave listens elsewhere.
|
|
CDP_ENDPOINT = os.environ.get("SOCIALMAG_CDP_ENDPOINT", DEFAULT_HTTP_ENDPOINT)
|
|
|
|
|
|
def log(*args):
|
|
print(f"[socialmag {time.strftime('%H:%M:%S')}]", *args, file=sys.stderr, flush=True)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tool schemas
|
|
# ---------------------------------------------------------------------------
|
|
|
|
TOOLS = [
|
|
{
|
|
"name": "create_post",
|
|
"description": (
|
|
"Post to one or more social platforms through the logged-in Brave "
|
|
"browser (CDP). Platforms run sequentially, one tab at a time. "
|
|
"Returns a per-platform status map."
|
|
),
|
|
"inputSchema": {
|
|
"type": "object",
|
|
"properties": {
|
|
"platforms": {
|
|
"type": "array",
|
|
"items": {"enum": sorted(MODULES)},
|
|
"description": "Any combination of threads, fb, ig, yt, tiktok.",
|
|
},
|
|
"text": {
|
|
"type": "string",
|
|
"description": (
|
|
"Post body. Required for threads/fb/yt; used as the "
|
|
"caption for ig/tiktok."
|
|
),
|
|
},
|
|
"media": {
|
|
"type": "string",
|
|
"description": (
|
|
"Absolute path to an image/video. Optional for "
|
|
"threads/fb; REQUIRED for ig/tiktok; not supported "
|
|
"for yt community posts."
|
|
),
|
|
},
|
|
"visibility": {
|
|
"enum": ["public", "friends"],
|
|
"description": "Facebook audience. Not implemented yet — see detail.",
|
|
},
|
|
},
|
|
"required": ["platforms"],
|
|
},
|
|
},
|
|
{
|
|
"name": "check_login",
|
|
"description": (
|
|
"Check which platforms the browser is signed in to. Opens and "
|
|
"closes one tab per platform; no posting."
|
|
),
|
|
"inputSchema": {
|
|
"type": "object",
|
|
"properties": {
|
|
"platforms": {
|
|
"type": "array",
|
|
"items": {"enum": sorted(MODULES)},
|
|
"description": "Defaults to all five when omitted.",
|
|
}
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"name": "get_status",
|
|
"description": "Results of the last create_post run, plus queue history.",
|
|
"inputSchema": {"type": "object", "properties": {}},
|
|
},
|
|
{
|
|
"name": "get_feed",
|
|
"description": (
|
|
"Read tweets from Twitter/X. Two modes: 'following' reads the "
|
|
"home timeline (Following tab), 'search' scrapes live results "
|
|
"for a query. Supports X search operators (from:, since:, "
|
|
"min_faves:, lang:). Returns up to 20 tweets with author, "
|
|
"text, time, and engagement counts."
|
|
),
|
|
"inputSchema": {
|
|
"type": "object",
|
|
"properties": {
|
|
"mode": {
|
|
"enum": ["following", "search"],
|
|
"description": "following = home timeline, search = keyword search.",
|
|
"default": "following",
|
|
},
|
|
"query": {
|
|
"type": "string",
|
|
"description": (
|
|
"Search query (required for search mode). Supports "
|
|
"X operators: from:user, since:2026-01-01, "
|
|
"min_faves:100, lang:en, etc."
|
|
),
|
|
},
|
|
"count": {
|
|
"type": "integer",
|
|
"description": "Max tweets to return (1-20, default 10).",
|
|
"default": 10,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"name": "reply_tweet",
|
|
"description": (
|
|
"Reply to a tweet found by search query. Finds the first "
|
|
"matching tweet and posts a reply to it."
|
|
),
|
|
"inputSchema": {
|
|
"type": "object",
|
|
"properties": {
|
|
"search_query": {
|
|
"type": "string",
|
|
"description": (
|
|
"Search query to find the tweet to reply to. Use "
|
|
"from:user + keywords for precision."
|
|
),
|
|
},
|
|
"text": {
|
|
"type": "string",
|
|
"description": "Reply text.",
|
|
},
|
|
},
|
|
"required": ["search_query", "text"],
|
|
},
|
|
},
|
|
{
|
|
"name": "get_notifications",
|
|
"description": (
|
|
"Check notifications/activity from social platforms. Currently "
|
|
"supports Threads (Activity page). Returns a list of recent "
|
|
"notifications with text, time, and post links where available."
|
|
),
|
|
"inputSchema": {
|
|
"type": "object",
|
|
"properties": {
|
|
"platform": {
|
|
"enum": ["threads"],
|
|
"description": "Platform to check. Currently only threads.",
|
|
},
|
|
"count": {
|
|
"type": "integer",
|
|
"description": "Max notifications to return (1-20, default 10).",
|
|
"default": 10,
|
|
},
|
|
},
|
|
"required": ["platform"],
|
|
},
|
|
},
|
|
{
|
|
"name": "open_link",
|
|
"description": (
|
|
"Open a URL in the platform's existing browser tab (reuses warm "
|
|
"tabs). Falls back to opening a new tab if none exists. The tab is "
|
|
"left open — that's what makes it reusable next time."
|
|
),
|
|
"inputSchema": {
|
|
"type": "object",
|
|
"properties": {
|
|
"platform": {
|
|
"enum": sorted(MODULES),
|
|
"description": (
|
|
"Which platform's tab to reuse. Matched by domain: "
|
|
+ ", ".join(f"{k} → {v}" for k, v in sorted(PLATFORM_DOMAINS.items()))
|
|
),
|
|
},
|
|
"url": {
|
|
"type": "string",
|
|
"description": "Full http(s) URL to navigate to.",
|
|
},
|
|
},
|
|
"required": ["platform", "url"],
|
|
},
|
|
},
|
|
]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# State
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def save_state(state):
|
|
tmp = STATE_PATH + ".tmp"
|
|
with open(tmp, "w") as fh:
|
|
json.dump(state, fh, indent=2)
|
|
os.replace(tmp, STATE_PATH)
|
|
|
|
|
|
def load_state():
|
|
if not os.path.exists(STATE_PATH):
|
|
return {"last_post": None, "results": {}}
|
|
with open(STATE_PATH) as fh:
|
|
return json.load(fh)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tool implementations
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
async def tool_create_post(args, queue):
|
|
platforms = args.get("platforms")
|
|
if not platforms:
|
|
raise ValueError("create_post: 'platforms' is required and must be non-empty")
|
|
unknown = [p for p in platforms if p not in MODULES]
|
|
if unknown:
|
|
raise ValueError(
|
|
f"create_post: unknown platform(s) {unknown}; known: {sorted(MODULES)}"
|
|
)
|
|
|
|
text = args.get("text")
|
|
media = args.get("media")
|
|
options = {}
|
|
if "visibility" in args:
|
|
options["visibility"] = args["visibility"]
|
|
|
|
results = {}
|
|
cdp = CDPClient(CDP_ENDPOINT)
|
|
await cdp.connect()
|
|
log(f"connected to {cdp.browser_version} at {CDP_ENDPOINT}")
|
|
try:
|
|
for name in platforms:
|
|
module = MODULES[name]
|
|
|
|
def factory(module=module):
|
|
return module.post(cdp, text, media, options)
|
|
|
|
try:
|
|
results[name] = await queue.submit(name, factory)
|
|
except CDPError as exc:
|
|
# Raised before the flow reached its guard (bad args, bad media).
|
|
results[name] = {"status": "error", "detail": f"{name}: {exc}"}
|
|
except Exception as exc: # noqa: BLE001
|
|
results[name] = {
|
|
"status": "error",
|
|
"detail": f"{name}: unexpected {type(exc).__name__}: {exc}",
|
|
}
|
|
log(f"{name} -> {results[name]['status']}")
|
|
finally:
|
|
await cdp.close()
|
|
|
|
state = {
|
|
"last_post": time.strftime("%Y-%m-%dT%H:%M:%S"),
|
|
"results": results,
|
|
"text": text,
|
|
"media": media,
|
|
}
|
|
save_state(state)
|
|
return results
|
|
|
|
|
|
async def tool_check_login(args, queue):
|
|
platforms = args.get("platforms") or sorted(MODULES)
|
|
unknown = [p for p in platforms if p not in MODULES]
|
|
if unknown:
|
|
raise ValueError(
|
|
f"check_login: unknown platform(s) {unknown}; known: {sorted(MODULES)}"
|
|
)
|
|
|
|
out = {}
|
|
cdp = CDPClient(CDP_ENDPOINT)
|
|
await cdp.connect()
|
|
try:
|
|
for name in platforms:
|
|
module = MODULES[name]
|
|
|
|
def factory(module=module):
|
|
return module.check_login(cdp)
|
|
|
|
try:
|
|
out[name] = bool(await queue.submit(f"check:{name}", factory))
|
|
except Exception as exc: # noqa: BLE001 — a failed check is not a False
|
|
out[name] = f"error: {type(exc).__name__}: {exc}"
|
|
finally:
|
|
await cdp.close()
|
|
return out
|
|
|
|
|
|
async def tool_get_status(args, queue):
|
|
state = load_state()
|
|
state["queue_history"] = queue.history[-20:]
|
|
state["queue_depth"] = queue.depth
|
|
# Show open browser tabs so the caller can see what's reusable
|
|
try:
|
|
cdp = CDPClient(CDP_ENDPOINT)
|
|
await cdp.connect()
|
|
targets = await cdp.list_targets()
|
|
state["open_tabs"] = [
|
|
{"id": t["targetId"], "url": t.get("url", ""), "title": t.get("title", "")}
|
|
for t in targets
|
|
]
|
|
await cdp.close()
|
|
except Exception:
|
|
state["open_tabs"] = "could not connect to browser"
|
|
return state
|
|
|
|
|
|
async def tool_get_feed(args, queue):
|
|
mode = args.get("mode", "following")
|
|
query = args.get("query")
|
|
count = min(args.get("count", 10), 20)
|
|
|
|
cdp = CDPClient(CDP_ENDPOINT)
|
|
await cdp.connect()
|
|
try:
|
|
result = await twitter.get_feed(cdp, mode=mode, query=query, count=count)
|
|
finally:
|
|
await cdp.close()
|
|
return result
|
|
|
|
|
|
async def tool_reply_tweet(args, queue):
|
|
search_query = args.get("search_query")
|
|
text = args.get("text")
|
|
if not search_query or not text:
|
|
raise ValueError("reply_tweet: both 'search_query' and 'text' are required")
|
|
|
|
cdp = CDPClient(CDP_ENDPOINT)
|
|
await cdp.connect()
|
|
try:
|
|
result = await twitter.reply(cdp, search_query, text)
|
|
finally:
|
|
await cdp.close()
|
|
return result
|
|
|
|
|
|
async def tool_get_notifications(args, queue):
|
|
platform = args.get("platform")
|
|
count = min(args.get("count", 10), 20)
|
|
|
|
notif_modules = {
|
|
"threads": threads,
|
|
}
|
|
if platform not in notif_modules:
|
|
raise ValueError(
|
|
f"get_notifications: unsupported platform {platform!r}; "
|
|
f"supported: {sorted(notif_modules)}"
|
|
)
|
|
|
|
cdp = CDPClient(CDP_ENDPOINT)
|
|
await cdp.connect()
|
|
try:
|
|
result = await notif_modules[platform].get_notifications(cdp, count=count)
|
|
finally:
|
|
await cdp.close()
|
|
return result
|
|
|
|
|
|
async def tool_open_link(args, queue):
|
|
platform = args.get("platform")
|
|
url = args.get("url")
|
|
|
|
# Validate before touching the browser: a bad call should cost nothing.
|
|
if platform not in PLATFORM_DOMAINS:
|
|
raise ValueError(
|
|
f"open_link: unknown platform {platform!r}; "
|
|
f"known: {sorted(PLATFORM_DOMAINS)}"
|
|
)
|
|
if not url or not isinstance(url, str):
|
|
raise ValueError("open_link: 'url' is required and must be a string")
|
|
scheme = urllib.parse.urlsplit(url).scheme.lower()
|
|
if scheme not in ("http", "https"):
|
|
raise ValueError(
|
|
f"open_link: url must be http(s), got {scheme or 'no'} scheme: {url!r}"
|
|
)
|
|
|
|
domain = PLATFORM_DOMAINS[platform]
|
|
|
|
async def go():
|
|
cdp = CDPClient(CDP_ENDPOINT)
|
|
await cdp.connect()
|
|
try:
|
|
tab, reused = await cdp.get_or_open_tab(url, domain)
|
|
if reused:
|
|
# A warm tab may hold an unload prompt (a half-written composer);
|
|
# clear it, then send the tab to the requested URL.
|
|
await tab.eval("window.onbeforeunload = null")
|
|
await tab.navigate(url)
|
|
# Deliberately NOT closed — leaving it open is what makes the next
|
|
# open_link on this platform a reuse.
|
|
return {
|
|
"status": "ok",
|
|
"tab_reused": reused,
|
|
"platform": platform,
|
|
"matched_domain": domain,
|
|
"url": url,
|
|
}
|
|
finally:
|
|
await cdp.close()
|
|
|
|
# Through the queue like every other browser job: one tab at a time.
|
|
return await queue.submit(f"open:{platform}", go)
|
|
|
|
|
|
HANDLERS = {
|
|
"create_post": tool_create_post,
|
|
"check_login": tool_check_login,
|
|
"get_status": tool_get_status,
|
|
"get_feed": tool_get_feed,
|
|
"reply_tweet": tool_reply_tweet,
|
|
"get_notifications": tool_get_notifications,
|
|
"open_link": tool_open_link,
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# JSON-RPC / MCP plumbing
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class Server:
|
|
def __init__(self):
|
|
self.queue = PostQueue()
|
|
|
|
async def handle(self, msg):
|
|
"""Return a response dict, or None for notifications."""
|
|
method = msg.get("method")
|
|
mid = msg.get("id")
|
|
params = msg.get("params") or {}
|
|
|
|
if method == "initialize":
|
|
return self._ok(
|
|
mid,
|
|
{
|
|
"protocolVersion": PROTOCOL_VERSION,
|
|
"capabilities": {"tools": {}},
|
|
"serverInfo": {"name": SERVER_NAME, "version": SERVER_VERSION},
|
|
},
|
|
)
|
|
if method in ("notifications/initialized", "initialized"):
|
|
return None
|
|
if method == "ping":
|
|
return self._ok(mid, {})
|
|
if method == "tools/list":
|
|
return self._ok(mid, {"tools": TOOLS})
|
|
if method == "tools/call":
|
|
return await self._call_tool(mid, params)
|
|
if mid is None:
|
|
return None # unknown notification — ignore, don't answer
|
|
return self._err(mid, -32601, f"method not found: {method}")
|
|
|
|
async def _call_tool(self, mid, params):
|
|
name = params.get("name")
|
|
args = params.get("arguments") or {}
|
|
handler = HANDLERS.get(name)
|
|
if handler is None:
|
|
return self._err(mid, -32602, f"unknown tool: {name}")
|
|
try:
|
|
result = await handler(args, self.queue)
|
|
except Exception as exc: # noqa: BLE001 — report as a tool error, loudly
|
|
log(f"tool {name} failed: {type(exc).__name__}: {exc}")
|
|
return self._ok(
|
|
mid,
|
|
{
|
|
"content": [
|
|
{"type": "text", "text": f"{type(exc).__name__}: {exc}"}
|
|
],
|
|
"isError": True,
|
|
},
|
|
)
|
|
return self._ok(
|
|
mid,
|
|
{"content": [{"type": "text", "text": json.dumps(result, indent=2)}]},
|
|
)
|
|
|
|
@staticmethod
|
|
def _ok(mid, result):
|
|
return {"jsonrpc": "2.0", "id": mid, "result": result}
|
|
|
|
@staticmethod
|
|
def _err(mid, code, message):
|
|
return {"jsonrpc": "2.0", "id": mid, "error": {"code": code, "message": message}}
|
|
|
|
|
|
async def main():
|
|
server = Server()
|
|
await server.queue.start()
|
|
|
|
reader = asyncio.StreamReader()
|
|
await asyncio.get_running_loop().connect_read_pipe(
|
|
lambda: asyncio.StreamReaderProtocol(reader), sys.stdin
|
|
)
|
|
log(f"listening on stdio · CDP endpoint {CDP_ENDPOINT}")
|
|
|
|
while True:
|
|
line = await reader.readline()
|
|
if not line:
|
|
break
|
|
line = line.strip()
|
|
if not line:
|
|
continue
|
|
try:
|
|
msg = json.loads(line)
|
|
except json.JSONDecodeError as exc:
|
|
log(f"dropping unparseable line: {exc}")
|
|
continue
|
|
response = await server.handle(msg)
|
|
if response is not None:
|
|
sys.stdout.write(json.dumps(response) + "\n")
|
|
sys.stdout.flush()
|
|
|
|
await server.queue.stop()
|
|
log("stdin closed, exiting")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
asyncio.run(main())
|
|
except KeyboardInterrupt:
|
|
pass
|