agent-social-mcp 0.2.0

package/README.md

@@ -0,0 +1,29 @@
+# Agent Social MCP Client
+
+Agent Social installs anonymous social discovery, realtime conversation, and Agent-assisted reply analysis into compatible Agent hosts.
+
+Node.js 22 or newer is required. For Codex, add:
+
+```toml
+[mcp_servers.agent_social]
+command = "npx"
+args = ["-y", "agent-social-mcp@0.2.0"]
+
+[mcp_servers.agent_social.env]
+AGENT_SOCIAL_RELAY_URL = "https://agent-social.shenglongai.top"
+```
+
+Restart Codex, then ask the Agent to confirm that `dating_onboard`, `dating_request_match`, and `dating_open_chat` are available. Installation and version checks must not onboard, consume an invite, create a match, or send a message.
+
+The localhost fallback is:
+
+```bash
+AGENT_SOCIAL_RELAY_URL=https://agent-social.shenglongai.top \
+npx -y -p agent-social-mcp@0.2.0 agent-social-chat
+```
+
+Open `http://127.0.0.1:8787` on that computer. The default owner-only identity and chat state remain under `$HOME/.agent-social-mcp`; an existing `AGENT_SOCIAL_STORE_PATH` remains compatible.
+
+This public package contains the local client only. It does not contain the central relay, database adapters, deployment code, test harness, operator keys, invites, user credentials, or production data.
+
+See `USAGE.md` for the preview usage status and safety boundaries.

package/USAGE.md

@@ -0,0 +1,7 @@
+# Preview Usage Notice
+
+This `0.2.0` package is an `UNLICENSED` public preview. Public registry availability permits installation and evaluation of the Agent Social client but is not an open-source license grant.
+
+Do not redistribute credentials, copy another user's local state, bypass invite onboarding, automate social message sending, or use the client to access a relay without authorization.
+
+The client does not verify identity, age, gender, devices, photos, or real-world safety. Users control outbound messages and should use report, block, and close controls when appropriate.

package/dist/client/cli.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createRemoteDatingMcpServer } from "./remoteMcpServer.js";
+const relayUrl = process.env.AGENT_SOCIAL_RELAY_URL?.trim();
+if (!relayUrl) {
+    throw new Error("AGENT_SOCIAL_RELAY_URL is required for the public Agent Social client");
+}
+const storePath = process.env.AGENT_SOCIAL_STORE_PATH
+    ?? join(homedir(), ".agent-social-mcp", "state.json");
+const server = createRemoteDatingMcpServer({ relayUrl, storePath });
+await server.connect(new StdioServerTransport());

package/dist/client/relayAuth.js

@@ -0,0 +1,20 @@
+const actorFields = {
+    dating_onboard: "existingToken",
+    dating_request_match: "userToken",
+    dating_get_match_status: "userToken",
+    dating_send_message: "senderToken",
+    dating_receive_messages: "recipientToken",
+    dating_mark_read: "readerToken",
+    dating_report_session: "reporterToken",
+    dating_block_user: "blockerToken",
+    dating_close_session: "requesterToken"
+};
+export function actorTokenForClientCall(tool, input) {
+    const field = actorFields[tool];
+    const value = field ? input[field] : undefined;
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+export function authorizationForClientRelayCall(tool, input) {
+    const token = actorTokenForClientCall(tool, input);
+    return token ? `Bearer ${token}` : undefined;
+}

package/dist/client/remoteMcpServer.js

@@ -0,0 +1,142 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { registerCompanionMcpUi } from "../companion/mcpUi.js";
+import { syncCompanionState } from "../companion/syncState.js";
+import { CompanionStateStore, defaultCompanionStatePath } from "../companion/state.js";
+import { MCP_TOOLS } from "../contracts.js";
+import { authorizationForClientRelayCall } from "./relayAuth.js";
+const optionalDateString = z.string().datetime().optional();
+const datingIntentSchema = z.enum(["light_chat", "flirt", "relationship"]);
+const genderPreferenceSchema = z.enum(["men", "women", "any"]);
+export function createRemoteDatingMcpServer(options) {
+    const relayUrl = normalizedRelayUrl(options.relayUrl);
+    const server = new McpServer({
+        name: "agent-social-mcp",
+        version: "0.2.0"
+    });
+    registerRemoteTool(server, options, relayUrl, MCP_TOOLS.onboard, "Dating Onboard", "Create or reuse a persistent anonymous dating relay token.", {
+        existingToken: z.string().optional(),
+        inviteCode: z.string(),
+        declaredAdult: z.boolean(),
+        now: optionalDateString
+    });
+    registerRemoteTool(server, options, relayUrl, MCP_TOOLS.requestMatch, "Dating Request Match", "Submit a temporary match capsule and try to create one compatible match session.", {
+        userToken: z.string(),
+        datingIntent: datingIntentSchema,
+        genderPreference: genderPreferenceSchema,
+        desiredTone: z.string(),
+        topics: z.array(z.string()).min(1),
+        boundaries: z.array(z.string()).default([]),
+        shareableIntro: z.string(),
+        ttlMinutes: z.number().int().min(1).max(1440),
+        createdAt: optionalDateString
+    });
+    registerRemoteTool(server, options, relayUrl, MCP_TOOLS.getMatchStatus, "Dating Get Match Status", "Read active or historical match sessions for an authenticated anonymous user.", {
+        userToken: z.string()
+    });
+    registerRemoteTool(server, options, relayUrl, MCP_TOOLS.sendMessage, "Dating Send Message", "Relay an outbound dating message only after explicit user confirmation.", {
+        id: z.string().optional(),
+        sessionId: z.string(),
+        senderToken: z.string(),
+        body: z.string(),
+        userConfirmed: z.boolean(),
+        createdAt: optionalDateString
+    });
+    registerRemoteTool(server, options, relayUrl, MCP_TOOLS.receiveMessages, "Dating Receive Messages", "Fetch inbound messages for a session with structured reply context for the user's Agent.", {
+        sessionId: z.string(),
+        recipientToken: z.string(),
+        cursor: z.string().optional()
+    });
+    registerRemoteTool(server, options, relayUrl, MCP_TOOLS.markRead, "Dating Mark Read", "Mark peer messages in an active session as read by the authenticated user.", {
+        sessionId: z.string(),
+        readerToken: z.string(),
+        readAt: optionalDateString
+    });
+    registerRemoteTool(server, options, relayUrl, MCP_TOOLS.reportSession, "Dating Report Session", "Report a match session and retain available message context for safety review.", {
+        id: z.string().optional(),
+        sessionId: z.string(),
+        reporterToken: z.string(),
+        reason: z.string(),
+        createdAt: optionalDateString
+    });
+    registerRemoteTool(server, options, relayUrl, MCP_TOOLS.blockUser, "Dating Block User", "Block the peer in a match session without exposing their credential.", {
+        sessionId: z.string(),
+        blockerToken: z.string(),
+        createdAt: optionalDateString
+    });
+    registerRemoteTool(server, options, relayUrl, MCP_TOOLS.closeSession, "Dating Close Session", "Close an active match session for one of its participants.", {
+        sessionId: z.string(),
+        requesterToken: z.string()
+    });
+    const stateStore = new CompanionStateStore(defaultCompanionStatePath({
+        ...process.env,
+        AGENT_SOCIAL_STORE_PATH: options.storePath
+    }));
+    registerCompanionMcpUi(server, {
+        stateStore,
+        relay: {
+            call: (tool, input) => postRemoteRelayTool(options, relayUrl, tool, input)
+        }
+    });
+    return server;
+}
+function registerRemoteTool(server, options, relayUrl, name, title, description, inputSchema) {
+    const registerTool = server.registerTool.bind(server);
+    registerTool(name, { title, description, inputSchema }, async (input) => {
+        const rawInput = input;
+        const payload = await postRemoteRelayTool(options, relayUrl, name, rawInput);
+        if (payload.ok !== false) {
+            syncCompanionState(options.storePath, name, payload, rawInput);
+        }
+        return payload.ok === false
+            ? toolError(String(payload.error ?? "relay error"), payload)
+            : toolSuccess(payload);
+    });
+}
+async function postRemoteRelayTool(options, relayUrl, tool, input) {
+    const authorization = authorizationForClientRelayCall(tool, input);
+    try {
+        const response = await (options.fetchImpl ?? fetch)(new URL("/api/relay", relayUrl), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                ...(authorization ? { authorization } : {})
+            },
+            body: JSON.stringify({ tool, input })
+        });
+        const payload = (await response.json());
+        if (!response.ok) {
+            return {
+                ok: false,
+                error: typeof payload.error === "string" ? payload.error : `relay http ${response.status}`
+            };
+        }
+        return payload;
+    }
+    catch {
+        return { ok: false, error: "relay request failed" };
+    }
+}
+function normalizedRelayUrl(value) {
+    if (!value.trim()) {
+        throw new Error("AGENT_SOCIAL_RELAY_URL is required");
+    }
+    const url = new URL(value);
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+        throw new Error("AGENT_SOCIAL_RELAY_URL must use http or https");
+    }
+    return url;
+}
+function toolSuccess(payload) {
+    return {
+        content: [{ type: "text", text: "OK" }],
+        structuredContent: JSON.parse(JSON.stringify(payload))
+    };
+}
+function toolError(message, payload) {
+    return {
+        content: [{ type: "text", text: message }],
+        structuredContent: JSON.parse(JSON.stringify(payload)),
+        isError: true
+    };
+}

package/dist/companion/chatServer.js

@@ -0,0 +1,369 @@
+import { createServer } from "node:http";
+import { MCP_TOOLS } from "../contracts.js";
+import { RelayClient } from "./relayClient.js";
+import { buildReplyAnalysisContext, shouldAutoAnalyzeReply } from "./replyAssistance.js";
+import { chatHtml as sharedChatHtml } from "./chatUi.js";
+export function createChatServer(options) {
+    const events = new CompanionEventHub(options);
+    return createServer(async (request, response) => {
+        if (request.method === "GET" && new URL(request.url ?? "/", "http://localhost").pathname === "/api/events") {
+            events.attach(request, response);
+            return;
+        }
+        try {
+            const result = await handleChatHttpRequest(options, {
+                method: request.method,
+                url: request.url,
+                body: await readRawBody(request)
+            });
+            writeResponse(response, result);
+            if (request.method === "POST" && result.statusCode < 400) {
+                events.publishState();
+            }
+        }
+        catch (error) {
+            writeResponse(response, jsonResponse(500, {
+                ok: false,
+                error: error instanceof Error ? error.message : "chat internal error"
+            }));
+        }
+    });
+}
+class CompanionEventHub {
+    options;
+    clients = new Set();
+    timer;
+    syncing = false;
+    retryMs = 1000;
+    constructor(options) {
+        this.options = options;
+    }
+    attach(request, response) {
+        response.writeHead(200, {
+            "content-type": "text/event-stream; charset=utf-8",
+            "cache-control": "no-cache, no-transform",
+            connection: "keep-alive"
+        });
+        response.write("retry: 1000\n\n");
+        this.clients.add(response);
+        this.publishState();
+        this.schedule(0);
+        request.on("close", () => {
+            this.clients.delete(response);
+            if (this.clients.size === 0 && this.timer) {
+                clearTimeout(this.timer);
+                this.timer = undefined;
+            }
+        });
+    }
+    publishState() {
+        this.broadcast("state", summarizeState(this.options.stateStore.read()));
+    }
+    schedule(delay) {
+        if (this.clients.size === 0 || this.timer) {
+            return;
+        }
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            void this.tick();
+        }, delay);
+        this.timer.unref();
+    }
+    async tick() {
+        if (this.syncing || this.clients.size === 0) {
+            this.schedule(this.retryMs);
+            return;
+        }
+        this.syncing = true;
+        try {
+            const relay = new RelayClient({ relayUrl: this.options.relayUrl });
+            await syncMessages(this.options.stateStore, relay);
+            this.retryMs = 1000;
+            this.broadcast("status", { online: true, syncedAt: new Date().toISOString() });
+            this.publishState();
+        }
+        catch (error) {
+            this.retryMs = Math.min(this.retryMs * 2, 15000);
+            this.broadcast("status", {
+                online: false,
+                error: error instanceof Error ? error.message : "sync failed",
+                retryMs: this.retryMs
+            });
+        }
+        finally {
+            this.syncing = false;
+            this.schedule(this.retryMs);
+        }
+    }
+    broadcast(event, payload) {
+        const frame = `event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`;
+        for (const client of this.clients) {
+            client.write(frame);
+        }
+    }
+}
+export async function handleChatHttpRequest(options, request) {
+    const url = new URL(request.url ?? "/", "http://localhost");
+    const method = request.method ?? "GET";
+    const relay = new RelayClient({ relayUrl: options.relayUrl });
+    if (method === "GET" && url.pathname === "/") {
+        return htmlResponse(sharedChatHtml);
+    }
+    if (method === "GET" && url.pathname === "/api/state") {
+        return jsonResponse(200, summarizeState(options.stateStore.read()));
+    }
+    if (method === "POST" && url.pathname === "/api/state") {
+        const body = parseJsonBody(request.body);
+        const userToken = stringValue(body.userToken);
+        if (!userToken) {
+            return jsonResponse(400, { ok: false, error: "userToken is required" });
+        }
+        return jsonResponse(200, summarizeState(options.stateStore.setUserToken(userToken)));
+    }
+    if (method === "POST" && url.pathname === "/api/sessions/sync") {
+        const state = await syncSessions(options.stateStore, relay);
+        return jsonResponse(200, summarizeState(state));
+    }
+    if (method === "POST" && url.pathname === "/api/messages/sync") {
+        const body = parseJsonBody(request.body);
+        const state = await syncMessages(options.stateStore, relay, stringOrUndefined(body.sessionId));
+        return jsonResponse(200, summarizeState(state));
+    }
+    if (method === "POST" && url.pathname === "/api/messages/send") {
+        const body = parseJsonBody(request.body);
+        const result = await sendMessage(options.stateStore, relay, body);
+        return jsonResponse(200, result);
+    }
+    if (method === "POST" && url.pathname === "/api/preferences") {
+        const body = parseJsonBody(request.body);
+        if (typeof body.autoAnalyze !== "boolean") {
+            return jsonResponse(400, { ok: false, error: "autoAnalyze must be boolean" });
+        }
+        return jsonResponse(200, summarizeState(options.stateStore.setAutoAnalyze(body.autoAnalyze)));
+    }
+    if (method === "POST" && url.pathname === "/api/sessions/read") {
+        const body = parseJsonBody(request.body);
+        const sessionId = stringValue(body.sessionId);
+        if (!sessionId) {
+            return jsonResponse(400, { ok: false, error: "sessionId is required" });
+        }
+        return jsonResponse(200, await markSessionRead(options.stateStore, relay, sessionId));
+    }
+    if (method === "POST" && url.pathname === "/api/sessions/report") {
+        const body = parseJsonBody(request.body);
+        return jsonResponse(200, await runSessionAction(options.stateStore, relay, "report", body));
+    }
+    if (method === "POST" && url.pathname === "/api/sessions/block") {
+        const body = parseJsonBody(request.body);
+        return jsonResponse(200, await runSessionAction(options.stateStore, relay, "block", body));
+    }
+    if (method === "POST" && url.pathname === "/api/sessions/close") {
+        const body = parseJsonBody(request.body);
+        return jsonResponse(200, await runSessionAction(options.stateStore, relay, "close", body));
+    }
+    return jsonResponse(404, { ok: false, error: "not found" });
+}
+export async function syncSessions(stateStore, relay) {
+    const state = stateStore.read();
+    if (!state.userToken) {
+        return state;
+    }
+    const payload = await relay.call(MCP_TOOLS.getMatchStatus, { userToken: state.userToken });
+    if (payload.ok === false) {
+        throw new Error(String(payload.error ?? "failed to sync sessions"));
+    }
+    return stateStore.upsertSessions((payload.sessions ?? []));
+}
+export async function syncMessages(stateStore, relay, sessionId) {
+    let state = await syncSessions(stateStore, relay);
+    if (!state.userToken) {
+        return state;
+    }
+    const sessions = state.sessions.filter((session) => session.status === "active" && (!sessionId || session.id === sessionId));
+    for (const session of sessions) {
+        const payload = await relay.call(MCP_TOOLS.receiveMessages, {
+            sessionId: session.id,
+            recipientToken: state.userToken,
+            ...(session.cursor ? { cursor: session.cursor } : {})
+        });
+        if (payload.ok === false) {
+            if (sessionId) {
+                throw new Error(String(payload.error ?? "failed to sync messages"));
+            }
+            continue;
+        }
+        const messages = (payload.messages ?? []);
+        state = stateStore.upsertMessages(messages);
+        state = stateStore.setSessionCursor(session.id, typeof payload.cursor === "string" ? payload.cursor : undefined);
+    }
+    return state;
+}
+export async function sendMessage(stateStore, relay, body) {
+    const state = stateStore.read();
+    if (!state.userToken) {
+        return { ok: false, error: "userToken is required" };
+    }
+    const sessionId = stringValue(body.sessionId);
+    const text = stringValue(body.body);
+    if (!sessionId) {
+        return { ok: false, error: "sessionId is required" };
+    }
+    if (!text.trim()) {
+        return { ok: false, error: "body is required" };
+    }
+    const payload = await relay.call(MCP_TOOLS.sendMessage, {
+        sessionId,
+        senderToken: state.userToken,
+        body: text,
+        userConfirmed: true
+    });
+    if (payload.ok === false) {
+        return payload;
+    }
+    stateStore.upsertMessages([payload.message], "sent");
+    return {
+        ok: true,
+        state: summarizeState(stateStore.read())
+    };
+}
+export function summarizeState(state) {
+    const analysisTargets = state.sessions.flatMap((session) => {
+        const context = buildReplyAnalysisContext({
+            sessionId: session.id,
+            peerIntro: session.peerIntro,
+            matchContext: state.matchContext,
+            messages: state.messages.filter((message) => message.sessionId === session.id)
+        });
+        if (!context) {
+            return [];
+        }
+        const assistance = state.replyAssistance.find((candidate) => candidate.sessionId === session.id);
+        const request = state.replyAssistanceRequests.find((candidate) => candidate.sessionId === session.id);
+        const status = request?.contextHash === context.contextHash
+            ? "analyzing"
+            : assistance?.contextHash === context.contextHash
+                ? "ready"
+                : assistance
+                    ? "stale"
+                    : "idle";
+        return [{
+                sessionId: session.id,
+                sourceMessageId: context.sourceMessageId,
+                contextHash: context.contextHash,
+                autoEligible: shouldAutoAnalyzeReply(context),
+                status,
+                ...(request ? { requestCreatedAt: request.createdAt } : {})
+            }];
+    });
+    return {
+        ok: true,
+        connected: Boolean(state.userToken),
+        preferences: state.preferences,
+        sessions: state.sessions.map((session) => {
+            const messages = state.messages.filter((message) => message.sessionId === session.id);
+            const lastMessage = messages.at(-1);
+            const unreadCount = messages.filter((message) => message.direction === "received" && !message.readAt).length;
+            return {
+                ...session,
+                createdAt: session.createdAt,
+                unreadCount,
+                lastMessageAt: lastMessage?.createdAt,
+                lastMessagePreview: lastMessage?.body
+            };
+        }),
+        messages: state.messages,
+        analysisTargets,
+        replyAssistance: state.replyAssistance
+    };
+}
+export async function markSessionRead(stateStore, relay, sessionId) {
+    const state = stateStore.read();
+    if (!state.userToken) {
+        return { ok: false, error: "userToken is required" };
+    }
+    const payload = await relay.call(MCP_TOOLS.markRead, {
+        sessionId,
+        readerToken: state.userToken,
+        readAt: new Date().toISOString()
+    });
+    if (payload.ok === false) {
+        return payload;
+    }
+    stateStore.markSessionOpened(sessionId);
+    await syncMessages(stateStore, relay, sessionId);
+    return summarizeState(stateStore.read());
+}
+export async function runSessionAction(stateStore, relay, action, body) {
+    const state = stateStore.read();
+    const sessionId = stringValue(body.sessionId);
+    if (!state.userToken) {
+        return { ok: false, error: "userToken is required" };
+    }
+    if (!sessionId) {
+        return { ok: false, error: "sessionId is required" };
+    }
+    const calls = {
+        report: {
+            tool: MCP_TOOLS.reportSession,
+            input: {
+                sessionId,
+                reporterToken: state.userToken,
+                reason: stringValue(body.reason) || "User reported this session from the live chat UI.",
+                createdAt: new Date().toISOString()
+            }
+        },
+        block: {
+            tool: MCP_TOOLS.blockUser,
+            input: { sessionId, blockerToken: state.userToken, createdAt: new Date().toISOString() }
+        },
+        close: {
+            tool: MCP_TOOLS.closeSession,
+            input: { sessionId, requesterToken: state.userToken }
+        }
+    };
+    const call = calls[action];
+    const payload = await relay.call(call.tool, call.input);
+    if (payload.ok === false) {
+        return payload;
+    }
+    await syncSessions(stateStore, relay);
+    return { ...summarizeState(stateStore.read()), action };
+}
+async function readRawBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+function parseJsonBody(body) {
+    if (!body) {
+        return {};
+    }
+    const text = Buffer.isBuffer(body) ? body.toString("utf8") : body;
+    return text ? JSON.parse(text) : {};
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function stringOrUndefined(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function jsonResponse(statusCode, body) {
+    return {
+        statusCode,
+        headers: { "content-type": "application/json; charset=utf-8" },
+        body: JSON.stringify(body)
+    };
+}
+function htmlResponse(body) {
+    return {
+        statusCode: 200,
+        headers: { "content-type": "text/html; charset=utf-8" },
+        body
+    };
+}
+function writeResponse(response, result) {
+    response.writeHead(result.statusCode, result.headers ?? {});
+    response.end(result.body);
+}