agent-social-mcp 0.2.0

package/dist/companion/state.js

@@ -0,0 +1,344 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join } from "node:path";
+import { publicIdForToken, publicSessionIdForInternal } from "../publicViews.js";
+export function defaultCompanionStatePath(env = process.env) {
+    if (env.AGENT_SOCIAL_CHAT_STATE_PATH) {
+        return env.AGENT_SOCIAL_CHAT_STATE_PATH;
+    }
+    if (env.AGENT_SOCIAL_STORE_PATH) {
+        const storeName = basename(env.AGENT_SOCIAL_STORE_PATH, extname(env.AGENT_SOCIAL_STORE_PATH));
+        return join(dirname(env.AGENT_SOCIAL_STORE_PATH), `${storeName}-chat-state.json`);
+    }
+    return join(homedir(), ".agent-social-mcp", "chat-state.json");
+}
+export class CompanionStateStore {
+    filePath;
+    constructor(filePath = defaultCompanionStatePath()) {
+        this.filePath = filePath;
+    }
+    read(at = new Date()) {
+        if (!existsSync(this.filePath)) {
+            return emptyState();
+        }
+        const parsed = JSON.parse(readFileSync(this.filePath, "utf8"));
+        const sourceSessions = Array.isArray(parsed.sessions) ? parsed.sessions : [];
+        const sourceMessages = Array.isArray(parsed.messages) ? parsed.messages : [];
+        const sourceAssistance = Array.isArray(parsed.replyAssistance) ? parsed.replyAssistance : [];
+        const sourceRequests = Array.isArray(parsed.replyAssistanceRequests)
+            ? parsed.replyAssistanceRequests
+            : [];
+        const state = {
+            version: 3,
+            userToken: typeof parsed.userToken === "string" ? parsed.userToken : undefined,
+            preferences: {
+                autoAnalyze: parsed.preferences?.autoAnalyze !== false
+            },
+            ...(normalizeMatchContext(parsed.matchContext) ? {
+                matchContext: normalizeMatchContext(parsed.matchContext)
+            } : {}),
+            sessions: sourceSessions.map((session) => normalizeSession(session, parsed.userToken)),
+            messages: sourceMessages.map((message) => normalizeMessage(message)),
+            replyAssistance: sourceAssistance
+                .map(normalizeReplyAssistance)
+                .filter((value) => Boolean(value)),
+            replyAssistanceRequests: sourceRequests
+                .map(normalizeReplyAssistanceRequest)
+                .filter((value) => Boolean(value))
+        };
+        const identifiersChanged = sourceSessions.some((session, index) => typeof session === "object" && session !== null && "id" in session
+            && state.sessions[index]?.id !== session.id) || sourceMessages.some((message, index) => typeof message === "object" && message !== null && "sessionId" in message
+            && state.messages[index]?.sessionId !== message.sessionId) || sourceAssistance.some((assistance, index) => typeof assistance === "object" && assistance !== null && "sessionId" in assistance
+            && state.replyAssistance[index]?.sessionId !== assistance.sessionId) || sourceRequests.some((request, index) => typeof request === "object" && request !== null && "sessionId" in request
+            && state.replyAssistanceRequests[index]?.sessionId !== request.sessionId);
+        const purged = purgeExpiredState(state, at);
+        if (parsed.version !== 3 || identifiersChanged || purged.changed) {
+            this.write(purged.state);
+        }
+        return purged.state;
+    }
+    write(state) {
+        mkdirSync(dirname(this.filePath), { recursive: true, mode: 0o700 });
+        const temporaryPath = `${this.filePath}.tmp-${process.pid}`;
+        writeFileSync(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+        renameSync(temporaryPath, this.filePath);
+        chmodSync(this.filePath, 0o600);
+    }
+    setUserToken(userToken) {
+        const state = this.read();
+        state.userToken = userToken;
+        this.write(state);
+        return state;
+    }
+    setAutoAnalyze(autoAnalyze) {
+        const state = this.read();
+        state.preferences.autoAnalyze = autoAnalyze;
+        this.write(state);
+        return state;
+    }
+    setMatchContext(matchContext) {
+        const state = this.read();
+        state.matchContext = normalizeMatchContext(matchContext);
+        this.write(state);
+        return state;
+    }
+    upsertSessions(sessions) {
+        const state = this.read();
+        for (const session of sessions) {
+            const normalized = normalizeSession(session, state.userToken);
+            const index = state.sessions.findIndex((candidate) => candidate.id === normalized.id);
+            if (index >= 0) {
+                state.sessions[index] = {
+                    ...state.sessions[index],
+                    ...normalized,
+                    cursor: normalized.cursor ?? state.sessions[index]?.cursor,
+                    lastOpenedAt: normalized.lastOpenedAt ?? state.sessions[index]?.lastOpenedAt
+                };
+            }
+            else {
+                state.sessions.push(normalized);
+            }
+        }
+        state.sessions.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+        this.write(state);
+        return state;
+    }
+    upsertMessages(messages, fallbackDirection) {
+        const state = this.read();
+        for (const value of messages) {
+            const message = normalizeMessage(value, fallbackDirection);
+            const index = state.messages.findIndex((candidate) => candidate.id === message.id);
+            if (index >= 0) {
+                state.messages[index] = { ...state.messages[index], ...message };
+            }
+            else {
+                state.messages.push(message);
+            }
+        }
+        state.messages.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt) || a.id.localeCompare(b.id));
+        this.write(state);
+        return state;
+    }
+    setSessionCursor(sessionId, cursor) {
+        const state = this.read();
+        if (cursor) {
+            state.sessions = state.sessions.map((session) => session.id === sessionId ? { ...session, cursor } : session);
+            this.write(state);
+        }
+        return state;
+    }
+    markSessionOpened(sessionId) {
+        const state = this.read();
+        const openedAt = new Date().toISOString();
+        state.sessions = state.sessions.map((session) => session.id === sessionId ? { ...session, lastOpenedAt: openedAt } : session);
+        this.write(state);
+        return state;
+    }
+    markSessionRead(sessionId) {
+        const state = this.markSessionOpened(sessionId);
+        const readAt = new Date().toISOString();
+        state.messages = state.messages.map((message) => message.sessionId === sessionId && message.direction === "received" && !message.readAt
+            ? { ...message, readAt, deliveredAt: message.deliveredAt ?? readAt, deliveryState: "read" }
+            : message);
+        this.write(state);
+        return state;
+    }
+    beginReplyAssistance(request) {
+        const state = this.read();
+        const normalized = normalizeReplyAssistanceRequest(request);
+        if (!normalized) {
+            throw new Error("invalid reply assistance request");
+        }
+        state.replyAssistanceRequests = state.replyAssistanceRequests.filter((candidate) => candidate.sessionId !== normalized.sessionId);
+        state.replyAssistanceRequests.push(normalized);
+        this.write(state);
+        return state;
+    }
+    completeReplyAssistance(assistance) {
+        const state = this.read();
+        const normalized = normalizeReplyAssistance(assistance);
+        if (!normalized) {
+            throw new Error("invalid reply assistance");
+        }
+        state.replyAssistance = state.replyAssistance.filter((candidate) => candidate.sessionId !== normalized.sessionId);
+        state.replyAssistance.push(normalized);
+        state.replyAssistanceRequests = state.replyAssistanceRequests.filter((candidate) => candidate.sessionId !== normalized.sessionId);
+        this.write(state);
+        return state;
+    }
+    clearReplyAssistanceRequest(sessionId, requestId) {
+        const state = this.read();
+        state.replyAssistanceRequests = state.replyAssistanceRequests.filter((candidate) => candidate.sessionId !== sessionId || (requestId && candidate.requestId !== requestId));
+        this.write(state);
+        return state;
+    }
+}
+export function sentMessageFromRelay(message) {
+    return normalizeMessage(message, "sent");
+}
+export function receivedMessageFromRelay(message) {
+    return normalizeMessage(message, "received");
+}
+function emptyState() {
+    return {
+        version: 3,
+        preferences: { autoAnalyze: true },
+        sessions: [],
+        messages: [],
+        replyAssistance: [],
+        replyAssistanceRequests: []
+    };
+}
+function normalizeSession(session, userToken) {
+    if ("peerId" in session) {
+        return {
+            id: publicSessionIdForInternal(session.id),
+            peerId: session.peerId,
+            ...(session.peerIntro ? { peerIntro: session.peerIntro } : {}),
+            createdAt: toIso(session.createdAt),
+            status: session.status,
+            label: "label" in session && session.label ? session.label : sessionLabel(session.peerId),
+            ...("cursor" in session && session.cursor ? { cursor: session.cursor } : {}),
+            ...("lastOpenedAt" in session && session.lastOpenedAt ? { lastOpenedAt: session.lastOpenedAt } : {})
+        };
+    }
+    const peerToken = userToken === session.userA ? session.userB : session.userA;
+    const peerId = publicIdForToken(peerToken);
+    return {
+        id: publicSessionIdForInternal(session.id),
+        peerId,
+        createdAt: toIso(session.createdAt),
+        status: session.status,
+        label: sessionLabel(peerId)
+    };
+}
+function normalizeMessage(message, fallbackDirection) {
+    const createdAt = toIso(message.createdAt);
+    const direction = "direction" in message
+        ? message.direction === "self" || message.direction === "sent" ? "sent" : "received"
+        : fallbackDirection ?? "received";
+    const retentionUntil = "expiresAt" in message
+        ? message.expiresAt
+        : "retentionUntil" in message
+            ? message.retentionUntil
+            : new Date(Date.parse(createdAt) + 7 * 24 * 60 * 60 * 1000);
+    return {
+        id: message.id,
+        sessionId: publicSessionIdForInternal(message.sessionId),
+        body: message.body,
+        createdAt,
+        updatedAt: "updatedAt" in message ? toIso(message.updatedAt) : createdAt,
+        expiresAt: toIso(retentionUntil),
+        deliveredAt: "deliveredAt" in message ? nullableIso(message.deliveredAt) : null,
+        readAt: "readAt" in message ? nullableIso(message.readAt) : null,
+        deliveryState: "deliveryState" in message ? message.deliveryState : "queued",
+        direction,
+        ...(message.replyContext ? { replyContext: message.replyContext } : {})
+    };
+}
+function purgeExpiredState(state, at) {
+    let changed = false;
+    const messages = state.messages.map((message) => {
+        if (Date.parse(message.expiresAt) <= at.getTime()
+            && (message.body !== null || message.replyContext !== undefined)) {
+            changed = true;
+            return { ...message, body: null, replyContext: undefined };
+        }
+        return message;
+    });
+    const retainedMessageIds = new Set(messages.filter((message) => message.body !== null).map((message) => message.id));
+    const replyAssistance = state.replyAssistance.filter((assistance) => retainedMessageIds.has(assistance.sourceMessageId));
+    const replyAssistanceRequests = state.replyAssistanceRequests.filter((request) => retainedMessageIds.has(request.sourceMessageId));
+    if (replyAssistance.length !== state.replyAssistance.length
+        || replyAssistanceRequests.length !== state.replyAssistanceRequests.length) {
+        changed = true;
+    }
+    return {
+        changed,
+        state: {
+            ...state,
+            messages,
+            replyAssistance,
+            replyAssistanceRequests
+        }
+    };
+}
+function normalizeMatchContext(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const candidate = value;
+    if (typeof candidate.desiredTone !== "string"
+        || typeof candidate.shareableIntro !== "string"
+        || !Array.isArray(candidate.topics)
+        || !candidate.topics.every((item) => typeof item === "string")
+        || !Array.isArray(candidate.boundaries)
+        || !candidate.boundaries.every((item) => typeof item === "string")) {
+        return undefined;
+    }
+    return {
+        desiredTone: candidate.desiredTone,
+        topics: [...candidate.topics],
+        boundaries: [...candidate.boundaries],
+        shareableIntro: candidate.shareableIntro
+    };
+}
+function normalizeReplyAssistance(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const candidate = value;
+    if (typeof candidate.requestId !== "string"
+        || typeof candidate.sessionId !== "string"
+        || typeof candidate.sourceMessageId !== "string"
+        || typeof candidate.contextHash !== "string"
+        || typeof candidate.analysis !== "string"
+        || !isRecommendedAction(candidate.recommendedAction)
+        || !Array.isArray(candidate.suggestions)
+        || !candidate.suggestions.every((item) => typeof item === "string")
+        || typeof candidate.createdAt !== "string") {
+        return undefined;
+    }
+    return {
+        requestId: candidate.requestId,
+        sessionId: publicSessionIdForInternal(candidate.sessionId),
+        sourceMessageId: candidate.sourceMessageId,
+        contextHash: candidate.contextHash,
+        analysis: candidate.analysis,
+        recommendedAction: candidate.recommendedAction,
+        suggestions: [...candidate.suggestions],
+        createdAt: candidate.createdAt
+    };
+}
+function normalizeReplyAssistanceRequest(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const candidate = value;
+    if (typeof candidate.requestId !== "string"
+        || typeof candidate.sessionId !== "string"
+        || typeof candidate.sourceMessageId !== "string"
+        || typeof candidate.contextHash !== "string"
+        || typeof candidate.createdAt !== "string") {
+        return undefined;
+    }
+    return {
+        requestId: candidate.requestId,
+        sessionId: publicSessionIdForInternal(candidate.sessionId),
+        sourceMessageId: candidate.sourceMessageId,
+        contextHash: candidate.contextHash,
+        createdAt: candidate.createdAt
+    };
+}
+function isRecommendedAction(value) {
+    return value === "reply" || value === "wait" || value === "close" || value === "block" || value === "report";
+}
+function sessionLabel(peerId) {
+    return `Match ${peerId.replace(/^anon_/, "").slice(0, 6)}`;
+}
+function toIso(value) {
+    return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}
+function nullableIso(value) {
+    return value ? toIso(value) : null;
+}

package/dist/companion/syncState.js

@@ -0,0 +1,50 @@
+import { MCP_TOOLS } from "../contracts.js";
+import { CompanionStateStore, defaultCompanionStatePath, receivedMessageFromRelay, sentMessageFromRelay } from "./state.js";
+export function syncCompanionState(storePath, tool, payload, input) {
+    const state = new CompanionStateStore(defaultCompanionStatePath({
+        ...process.env,
+        AGENT_SOCIAL_STORE_PATH: storePath
+    }));
+    if (tool === MCP_TOOLS.onboard) {
+        const user = payload.user;
+        if (user?.token) {
+            state.setUserToken(user.token);
+        }
+    }
+    if (tool === MCP_TOOLS.requestMatch) {
+        if (typeof input.userToken === "string") {
+            state.setUserToken(input.userToken);
+        }
+        if (typeof input.desiredTone === "string"
+            && Array.isArray(input.topics)
+            && input.topics.every((item) => typeof item === "string")
+            && Array.isArray(input.boundaries)
+            && input.boundaries.every((item) => typeof item === "string")
+            && typeof input.shareableIntro === "string") {
+            state.setMatchContext({
+                desiredTone: input.desiredTone,
+                topics: input.topics,
+                boundaries: input.boundaries,
+                shareableIntro: input.shareableIntro
+            });
+        }
+        if (payload.session) {
+            state.upsertSessions([payload.session]);
+        }
+    }
+    if (tool === MCP_TOOLS.getMatchStatus && Array.isArray(payload.sessions)) {
+        state.upsertSessions(payload.sessions);
+    }
+    if (tool === MCP_TOOLS.sendMessage && payload.message) {
+        state.upsertMessages([sentMessageFromRelay(payload.message)]);
+    }
+    if (tool === MCP_TOOLS.receiveMessages && Array.isArray(payload.messages)) {
+        state.upsertMessages(payload.messages.map(receivedMessageFromRelay));
+        if (typeof input.sessionId === "string" && typeof payload.cursor === "string") {
+            state.setSessionCursor(input.sessionId, payload.cursor);
+        }
+    }
+    if (tool === MCP_TOOLS.markRead && typeof input.sessionId === "string") {
+        state.markSessionRead(input.sessionId);
+    }
+}

package/dist/contracts.js

@@ -0,0 +1,111 @@
+export const MCP_TOOLS = {
+    onboard: "dating_onboard",
+    requestMatch: "dating_request_match",
+    getMatchStatus: "dating_get_match_status",
+    sendMessage: "dating_send_message",
+    receiveMessages: "dating_receive_messages",
+    markRead: "dating_mark_read",
+    reportSession: "dating_report_session",
+    blockUser: "dating_block_user",
+    closeSession: "dating_close_session"
+};
+const dayInMs = 24 * 60 * 60 * 1000;
+export function createAnonymousUser(input) {
+    return {
+        ...input,
+        status: "active",
+        reportCount: 0,
+        blockCount: 0
+    };
+}
+export function validateMatchCapsuleInput(input) {
+    if (!input.userToken.trim()) {
+        return { ok: false, error: "userToken is required" };
+    }
+    if (!input.desiredTone.trim()) {
+        return { ok: false, error: "desiredTone is required" };
+    }
+    if (input.topics.length === 0) {
+        return { ok: false, error: "topics must include at least one topic" };
+    }
+    if (!input.shareableIntro.trim()) {
+        return { ok: false, error: "shareableIntro is required" };
+    }
+    if (!Number.isInteger(input.ttlMinutes) || input.ttlMinutes < 1 || input.ttlMinutes > 1440) {
+        return { ok: false, error: "ttlMinutes must be between 1 and 1440" };
+    }
+    return { ok: true };
+}
+export function createMatchCapsule(input) {
+    const validation = validateMatchCapsuleInput(input);
+    if (!validation.ok) {
+        throw new Error(validation.error);
+    }
+    return {
+        ...input,
+        id: `capsule_${input.userToken}_${input.createdAt.getTime()}`,
+        expiresAt: new Date(input.createdAt.getTime() + input.ttlMinutes * 60 * 1000)
+    };
+}
+export function isCapsuleExpired(capsule, at) {
+    return at.getTime() >= capsule.expiresAt.getTime();
+}
+export function createMatchSession(input) {
+    return {
+        ...input,
+        status: "active"
+    };
+}
+export function validateMessageInput(input) {
+    if (!input.sessionId.trim()) {
+        return { ok: false, error: "sessionId is required" };
+    }
+    if (!input.senderToken.trim()) {
+        return { ok: false, error: "senderToken is required" };
+    }
+    if (!input.body.trim()) {
+        return { ok: false, error: "body is required" };
+    }
+    if (input.userConfirmed !== true) {
+        return { ok: false, error: "userConfirmed must be true before sending" };
+    }
+    return { ok: true };
+}
+export function createMessage(input) {
+    const validation = validateMessageInput(input);
+    if (!validation.ok) {
+        throw new Error(validation.error);
+    }
+    return {
+        ...input,
+        retentionUntil: new Date(input.createdAt.getTime() + 7 * dayInMs),
+        updatedAt: input.createdAt,
+        deliveredAt: null,
+        readAt: null,
+        deliveryState: "queued"
+    };
+}
+export function createReport(input) {
+    return {
+        ...input,
+        status: "open",
+        contextMessageIds: [],
+        retainedMessageBodies: []
+    };
+}
+export function createBlock(input) {
+    return {
+        ...input
+    };
+}
+export function createRateLimitState(input) {
+    return {
+        ...input,
+        onboardingAttempts: 0,
+        matchRequests: 0,
+        messagesSent: 0,
+        activeSessions: 0,
+        rejectedMessages: 0,
+        cooldownUntil: null
+    };
+}

package/dist/datingContracts.js

@@ -0,0 +1 @@
+export {};

package/dist/publicViews.js

@@ -0,0 +1,115 @@
+import { createHash } from "node:crypto";
+export function publicIdForToken(token) {
+    return `anon_${createHash("sha256").update(token).digest("hex").slice(0, 12)}`;
+}
+export function publicSessionIdForInternal(sessionId) {
+    if (/^social_session_[a-f0-9]{20}$/.test(sessionId)) {
+        return sessionId;
+    }
+    const digest = createHash("sha256")
+        .update(`agent-social-session:${sessionId}`)
+        .digest("hex")
+        .slice(0, 20);
+    return `social_session_${digest}`;
+}
+export function sessionMatchesPublicOrInternalId(session, sessionId) {
+    return session.id === sessionId || publicSessionIdForInternal(session.id) === sessionId;
+}
+export function toPublicSession(session, viewerToken, peerCapsule) {
+    const peerToken = peerTokenForSession(session, viewerToken);
+    return {
+        id: publicSessionIdForInternal(session.id),
+        peerId: publicIdForToken(peerToken),
+        createdAt: toIso(session.createdAt),
+        status: session.status,
+        ...(peerCapsule?.userToken === peerToken
+            ? { peerIntro: redactCredentials(peerCapsule.shareableIntro, [peerCapsule.userToken]) }
+            : {})
+    };
+}
+export function toPublicCandidate(capsule) {
+    return {
+        datingIntent: capsule.datingIntent,
+        genderPreference: capsule.genderPreference,
+        desiredTone: redactCredentials(capsule.desiredTone, [capsule.userToken]),
+        topics: capsule.topics.map((value) => redactCredentials(value, [capsule.userToken])),
+        boundaries: capsule.boundaries.map((value) => redactCredentials(value, [capsule.userToken])),
+        shareableIntro: redactCredentials(capsule.shareableIntro, [capsule.userToken])
+    };
+}
+export function toPublicMessage(message, viewerToken) {
+    return {
+        id: message.id,
+        sessionId: publicSessionIdForInternal(message.sessionId),
+        direction: message.senderToken === viewerToken ? "self" : "peer",
+        body: message.body === null ? null : redactCredentials(message.body),
+        createdAt: toIso(message.createdAt),
+        updatedAt: toIso(message.updatedAt),
+        deliveredAt: nullableIso(message.deliveredAt),
+        readAt: nullableIso(message.readAt),
+        expiresAt: toIso(message.retentionUntil),
+        deliveryState: message.deliveryState,
+        ...(message.replyContext ? { replyContext: copyReplyContext(message.replyContext) } : {})
+    };
+}
+export function redactCredentials(value, knownTokens = []) {
+    let redacted = value;
+    for (const token of knownTokens) {
+        if (token) {
+            redacted = redacted.replaceAll(token, "[redacted credential]");
+        }
+    }
+    return redacted.replace(/\buser_[a-zA-Z0-9_-]+\b/g, "[redacted credential]");
+}
+export function encodeEventCursor(updatedAt, id) {
+    return Buffer.from(JSON.stringify([updatedAt.toISOString(), id]), "utf8").toString("base64url");
+}
+export function decodeEventCursor(cursor) {
+    if (!cursor) {
+        return undefined;
+    }
+    try {
+        const value = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+        if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || typeof value[1] !== "string") {
+            return undefined;
+        }
+        const updatedAt = new Date(value[0]);
+        if (Number.isNaN(updatedAt.getTime()) || !value[1]) {
+            return undefined;
+        }
+        return { updatedAt, id: value[1] };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isAfterCursor(message, cursor) {
+    if (!cursor) {
+        return true;
+    }
+    const timeDelta = message.updatedAt.getTime() - cursor.updatedAt.getTime();
+    return timeDelta > 0 || (timeDelta === 0 && message.id > cursor.id);
+}
+function peerTokenForSession(session, viewerToken) {
+    if (session.userA === viewerToken) {
+        return session.userB;
+    }
+    if (session.userB === viewerToken) {
+        return session.userA;
+    }
+    throw new Error("viewer is not in session");
+}
+function copyReplyContext(context) {
+    return {
+        tone: context.tone,
+        inferredSignal: context.inferredSignal,
+        suggestedAngles: [...context.suggestedAngles],
+        safetyReminders: [...context.safetyReminders]
+    };
+}
+function toIso(value) {
+    return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}
+function nullableIso(value) {
+    return value ? toIso(value) : null;
+}

package/dist/socialContracts.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "agent-social-mcp",
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "description": "Public client for Agent Social discovery, realtime conversation, and Agent-assisted replies.",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "USAGE.md"
+  ],
+  "bin": {
+    "agent-social-mcp": "dist/client/cli.js",
+    "agent-social-chat": "dist/companion/cli.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  }
+}