juxtapo/socialmag
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a4f33f456ef11760a493526f12ef3edfe00679f0
socialmag/server.py
T

352 lines
11 KiB
Python
Raw Blame History

#!/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
from .cdp import CDPClient, CDPError, DEFAULT_HTTP_ENDPOINT
from .platforms import facebook, instagram, threads, tiktok, youtube
from .queue import PostQueue
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,
}
# 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": {}},
},
]
# ---------------------------------------------------------------------------
# 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
HANDLERS = {
"create_post": tool_create_post,
"check_login": tool_check_login,
"get_status": tool_get_status,
}
# ---------------------------------------------------------------------------
# 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
Reference in New Issue View Git Blame Copy Permalink