bsv-mcp 0.0.36 → 0.2.7

package/tools/bap/getId.ts

@@ -0,0 +1,169 @@
+import { PrivateKey } from "@bsv/sdk";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type {
+	CallToolResult,
+	ServerNotification,
+	ServerRequest,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { BSOCIAL_API_URL } from "../constants";
+import type { IdentityData, SigmaIdentityProfile } from "./types";
+
+// Schema for bap_getId arguments
+export const bapGetIdArgsSchema = z.object({
+	idKey: z
+		.string()
+		.optional()
+		.describe(
+			"Optional Identity Key (Paymail or public key). If not provided, attempts to use the server's configured identity key.",
+		),
+});
+export type BapGetIdArgs = z.infer<typeof bapGetIdArgsSchema>;
+
+/**
+ * Fetches the identity profile from Sigma API.
+ * @param idKey The identity key (Paymail or public key) to fetch the profile for.
+ * @returns The identity data, or null if not found.
+ */
+export const fetchProfile = async (
+	idKey: string,
+): Promise<IdentityData | null> => {
+	const response = await fetch(`${BSOCIAL_API_URL}/identity/get`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify({ idKey }),
+	});
+
+	if (!response.ok) {
+		// For 404, Sigma API might return a specific body, but generally, we treat it as profile not found.
+		if (response.status === 404) {
+			return null; // Explicitly return null for 404
+		}
+		const errorBody = await response.text();
+		throw new Error(
+			`Sigma API request failed with status ${response.status}: ${errorBody}`,
+		);
+	}
+
+	try {
+		const profileData = (await response.json()) as SigmaIdentityProfile;
+		// Ensure result exists, even if it's null (which means not found)
+		if (typeof profileData.result === "undefined") {
+			throw new Error("Sigma API response is missing the 'result' field.");
+		}
+		return profileData.result; // This can be IdentityData or null
+	} catch (jsonError) {
+		// Handle cases where response is not JSON or structure is unexpected
+		throw new Error(
+			`Failed to parse Sigma API response: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`,
+		);
+	}
+};
+
+/**
+ * Registers the bap_getId tool for fetching a BAP identity.
+ */
+export function registerBapGetIdTool(
+	server: McpServer,
+	identityPk?: PrivateKey, // Accept the global identityPk
+) {
+	server.tool(
+		"bap_getId",
+		"Retrieves a Bitcoin Attestation Protocol (BAP) identity profile using an idKey (Paymail or public key). If no idKey is provided, it attempts to use the server's configured identity key.",
+		{ ...bapGetIdArgsSchema.shape },
+		async (
+			{ idKey },
+			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+		): Promise<CallToolResult> => {
+			let targetIdKey = idKey;
+
+			if (!targetIdKey) {
+				// First priority: Use authenticated user's BAP ID from OAuth session
+				const authInfo = (extra as any).authInfo;
+				if (authInfo?.metadata?.bapId) {
+					targetIdKey = authInfo.metadata.bapId;
+					console.error(`Using authenticated user's BAP ID: ${targetIdKey}`);
+				}
+				// Second priority: Use authenticated user's pubkey
+				else if (authInfo?.metadata?.pubkey) {
+					targetIdKey = authInfo.metadata.pubkey;
+					console.error(`Using authenticated user's pubkey: ${targetIdKey}`);
+				}
+				// Fallback: Attempt to get idKey from the passed identityPk or environment variable
+				else {
+					let pkToUse = identityPk;
+
+					if (!pkToUse) {
+						const identityKeyWifEnv = process.env.IDENTITY_KEY_WIF;
+						if (identityKeyWifEnv) {
+							try {
+								pkToUse = PrivateKey.fromWif(identityKeyWifEnv);
+							} catch (e) {
+								// Don't error here, let it be handled by the final check
+							}
+						}
+					}
+
+					if (pkToUse) {
+						// Sigma typically uses the public key string as the idKey
+						targetIdKey = pkToUse.toPublicKey().toString();
+					} else {
+						return {
+							content: [
+								{
+									type: "text",
+									text: "idKey not provided and could not be derived from authenticated session or server configuration.",
+								},
+							],
+							isError: true,
+						};
+					}
+				}
+			}
+
+			if (!targetIdKey) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "Critical error: targetIdKey is unexpectedly undefined after derivation attempts.",
+						},
+					],
+					isError: true,
+				};
+			}
+
+			try {
+				const identityDataResult = await fetchProfile(targetIdKey);
+				if (identityDataResult === null) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: `No BAP identity found for idKey: ${targetIdKey}`,
+							},
+						],
+						isError: false, // Not an error, just no data found for the given key
+					};
+				}
+				return {
+					content: [
+						{ type: "text", text: JSON.stringify(identityDataResult, null, 2) },
+					],
+				};
+			} catch (error) {
+				const errorMessage =
+					error instanceof Error ? error.message : String(error);
+				return {
+					content: [
+						{ type: "text", text: `Error fetching BAP ID: ${errorMessage}` },
+					],
+					isError: true,
+				};
+			}
+		},
+	);
+}

package/tools/bap/index.ts

@@ -0,0 +1,111 @@
+import type { PrivateKey } from "@bsv/sdk";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Wallet } from "../wallet/wallet";
+import { registerBapFriendTool } from "./friend";
+import { registerBapGenerateTool } from "./generate";
+import { registerBapGetCurrentAddressTool } from "./getCurrentAddress";
+import { registerBapGetIdTool } from "./getId";
+
+const logFunc = console.error;
+
+/**
+ * Configuration for BAP tools registration.
+ */
+export interface BapToolsConfig {
+	disableBroadcasting?: boolean;
+	identityPk?: PrivateKey;
+	masterXprv?: string;
+	wallet?: Wallet;
+}
+
+/**
+ * Register all BAP tools with the MCP server
+ * @param server The MCP server instance
+ * @param identityPk The optional identity private key for operations requiring it
+ * @param masterXprv The BAP HD Master Key (xprv string) if available.
+ * @param config Configuration options for BAP tools.
+ */
+export function registerBapTools(
+	server: McpServer,
+	config?: BapToolsConfig,
+): void {
+	const {
+		identityPk, // Server's main configured identity (from keys.json or IDENTITY_KEY_WIF)
+		masterXprv, // Server's master BAP key (from keys.json)
+		wallet,
+		disableBroadcasting = false,
+	} = config || {};
+
+	const envIdentityKeyWif = process.env.IDENTITY_KEY_WIF;
+
+	// --- Register bap_generate ONLY if no identity exists ---
+	const canGenerateBapIdentity = !envIdentityKeyWif && !masterXprv;
+	if (canGenerateBapIdentity) {
+		logFunc(
+			"INFO: Registering bap_generate tool. No master identity (xprv) or direct identity WIF found.",
+		);
+		registerBapGenerateTool(server, { disableBroadcasting });
+	} else {
+		logFunc(
+			"INFO: bap_generate tool not registered. Master identity (xprv) or direct identity WIF already exists.",
+		);
+	}
+
+	// --- Register tools requiring an established identity ---
+	// Established identity means either an identityPk was loaded/configured, OR an env var was set.
+	const hasEstablishedIdentity = !!identityPk || !!envIdentityKeyWif;
+
+	if (hasEstablishedIdentity) {
+		logFunc(
+			"INFO: Registering BAP tools that require an established identity (bap_getId, bap_getCurrentAddress).",
+		);
+		// registerBapGetIdTool can use server's identityPk if available
+
+		// registerBapGetCurrentAddressTool strictly requires the server's identityPk (not just env var)
+		if (identityPk) {
+			registerBapGetCurrentAddressTool(server, identityPk);
+		} else {
+			logFunc(
+				"WARN: bap_getCurrentAddress tool not registered. Server identityPk not available (might be using env var directly).",
+			);
+		}
+	} else {
+		logFunc(
+			"INFO: BAP tools requiring established identity not registered (no identityPk or IDENTITY_KEY_WIF).",
+		);
+		// We might still want bap_getId available even without server identity,
+		// as it can take an idKey argument. Let's register it outside the check.
+		// Moved registerBapGetIdTool outside this block - see below.
+	}
+
+	// Always register bap_getId as it can operate on user-provided idKey too.
+	// If server identityPk is available, it can use it as default.
+	registerBapGetIdTool(server, identityPk);
+
+	// --- Register tools requiring the master HD key (xprv) ---
+	if (masterXprv) {
+		try {
+			// No need to parse HD key here if tools don't need the HD object itself
+			// const masterHdKey = HD.fromString(masterXprv);
+
+			// Register bap_friend if wallet is also available
+			if (wallet) {
+				logFunc(
+					"INFO: Registering bap_friend tool (requires wallet & masterXprv).",
+				);
+				registerBapFriendTool(server, wallet, masterXprv, {
+					disableBroadcasting,
+				});
+			} else {
+				logFunc("WARN: Wallet not available, bap_friend tool not registered.");
+			}
+
+			// Add other tools that specifically require masterXprv here...
+		} catch (e) {
+			// Catch potential HD.fromString errors if parsing is done here
+			console.error(
+				`ERROR: Failed during masterXprv tool registration: ${e instanceof Error ? e.message : String(e)}`,
+			);
+		}
+	}
+}

package/tools/bap/types.ts

@@ -0,0 +1,66 @@
+import type { Place, PostalAddress } from "schema-dts";
+
+export interface BapPublicKey {
+	id: string;
+	controller: string;
+	type: "EcdsaSecp256k1VerificationKey2019";
+	bitcoinAddress: string;
+}
+
+export enum SchemaType {
+	Person = "Person",
+	Organization = "Organization",
+}
+
+// Define our base Identity interface including common fields + custom ones
+export interface Identity {
+	// Common Schema.org fields we use
+	"@context"?: string;
+	"@type": SchemaType;
+	alternateName?: string;
+	description?: string;
+	image?: string; // Used for Person
+	logo?: string; // Used for Organization
+	address?: string | PostalAddress;
+	location?: Place; // Use Place from schema-dts
+	homeLocation?: Place; // Use Place from schema-dts
+	url?: string;
+	email?: string;
+
+	// Person specific (optional)
+	givenName?: string;
+	familyName?: string;
+
+	// Organization specific (optional)
+	legalName?: string;
+
+	// Custom properties
+	_id?: string;
+	paymail?: string;
+	bitcoinAddress?: string;
+	banner?: string;
+}
+
+// Address related to BAP/blockchain context, not Schema.org PostalAddress
+export type BapAddress = {
+	address: string;
+	txId: string;
+	block: number;
+};
+
+export type IdentityData = {
+	addresses?: BapAddress[]; // Use BapAddress type
+	block: number;
+	currentAddress: string;
+	firstSeen: number;
+	idKey: string; // BAP ID format
+	identity: Identity;
+	rootAddress: string;
+	timestamp: number;
+	valid: boolean;
+};
+
+// The API response structure for fetching a profile
+export interface SigmaIdentityProfile {
+	result: IdentityData;
+}

package/tools/bap/utils.ts

@@ -0,0 +1,33 @@
+import type { Identity, IdentityData, SchemaType } from "./types";
+
+type AllFields = {
+	schemaType: SchemaType;
+	alternateName: string;
+	description: string;
+	bitcoinAddress: string;
+};
+
+export const buildIdentity = ({
+	schemaType,
+	alternateName,
+	description,
+	bitcoinAddress,
+}: AllFields): string => {
+	const identity: Identity = {
+		"@context": "https://schema.org",
+		"@type": schemaType as SchemaType,
+		alternateName,
+		description,
+		bitcoinAddress,
+	};
+
+	if (description) {
+		identity.description = description;
+	}
+
+	if (bitcoinAddress) {
+		identity.bitcoinAddress = bitcoinAddress;
+	}
+
+	return JSON.stringify(identity);
+};

package/tools/bsocial/bmapFollow.ts

@@ -0,0 +1,121 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { BMAP_URL } from "../constants";
+
+// Schema for reading follows from BMAP API
+const bmapReadFollowsArgsSchema = z.object({
+	bapId: z
+		.string()
+		.describe("BAP identity key to get follow relationships for"),
+	type: z
+		.enum(["followers", "following"])
+		.default("following")
+		.describe("Type of relationship to query"),
+	limit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(20)
+		.describe("Maximum number of follows to return"),
+	page: z
+		.number()
+		.min(1)
+		.default(1)
+		.describe("Page number for pagination (1-based)"),
+});
+
+type BmapReadFollowsArgs = z.infer<typeof bmapReadFollowsArgsSchema>;
+
+/**
+ * Read follow relationships from BMAP API
+ */
+export async function readBmapFollows(args: BmapReadFollowsArgs): Promise<{
+	success: boolean;
+	data?: unknown;
+	error?: string;
+}> {
+	try {
+		const { bapId, type, limit, page } = args;
+
+		const params = new URLSearchParams();
+		params.append("limit", limit.toString());
+		params.append("page", page.toString());
+
+		const endpoint = type === "followers" ? "followers" : "following";
+		const response = await fetch(
+			`${BMAP_URL}/bap/${bapId}/${endpoint}?${params}`,
+			{
+				method: "GET",
+				headers: {
+					"Content-Type": "application/json",
+				},
+			},
+		);
+
+		if (!response.ok) {
+			const errorText = await response.text();
+			return {
+				success: false,
+				error: `BMAP API request failed: ${response.status} ${errorText}`,
+			};
+		}
+
+		const data = await response.json();
+		return {
+			success: true,
+			data,
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.error("Error reading BMAP follows:", errorMessage);
+		return {
+			success: false,
+			error: errorMessage,
+		};
+	}
+}
+
+/**
+ * Register the BMAP read follows tool with the MCP server
+ */
+export function registerBmapReadFollowsTool(server: McpServer) {
+	server.tool(
+		"bmap_readFollows",
+		"Read follow relationships from the BMAP API. Shows who a user is following or who follows them.",
+		{ ...bmapReadFollowsArgsSchema.shape },
+		async ({ bapId, type, limit, page }): Promise<CallToolResult> => {
+			try {
+				const result = await readBmapFollows({ bapId, type, limit, page });
+
+				if (result.success) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(result.data, null, 2),
+							},
+						],
+						isError: false,
+					};
+				}
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: result.error || "Unknown error occurred",
+						},
+					],
+					isError: true,
+				};
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `Error: ${msg}` }],
+					isError: true,
+				};
+			}
+		},
+	);
+}

package/tools/bsocial/bmapLikes.ts

@@ -0,0 +1,111 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { BMAP_URL } from "../constants";
+
+// Schema for reading likes from BMAP API
+const bmapReadLikesArgsSchema = z.object({
+	txid: z.string().describe("Transaction ID of the post to get likes for"),
+	limit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(20)
+		.describe("Maximum number of likes to return"),
+	page: z
+		.number()
+		.min(1)
+		.default(1)
+		.describe("Page number for pagination (1-based)"),
+});
+
+type BmapReadLikesArgs = z.infer<typeof bmapReadLikesArgsSchema>;
+
+/**
+ * Read likes and reactions for a specific post from BMAP API
+ */
+export async function readBmapLikes(args: BmapReadLikesArgs): Promise<{
+	success: boolean;
+	data?: unknown;
+	error?: string;
+}> {
+	try {
+		const { txid, limit, page } = args;
+
+		const params = new URLSearchParams();
+		params.append("limit", limit.toString());
+		params.append("page", page.toString());
+
+		const response = await fetch(`${BMAP_URL}/post/${txid}/like?${params}`, {
+			method: "GET",
+			headers: {
+				"Content-Type": "application/json",
+			},
+		});
+
+		if (!response.ok) {
+			const errorText = await response.text();
+			return {
+				success: false,
+				error: `BMAP API request failed: ${response.status} ${errorText}`,
+			};
+		}
+
+		const data = await response.json();
+		return {
+			success: true,
+			data,
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.error("Error reading BMAP likes:", errorMessage);
+		return {
+			success: false,
+			error: errorMessage,
+		};
+	}
+}
+
+/**
+ * Register the BMAP read likes tool with the MCP server
+ */
+export function registerBmapReadLikesTool(server: McpServer) {
+	server.tool(
+		"bmap_readLikes",
+		"Read likes and reactions for a specific post from the BMAP API. Shows who liked the post and what emoji reactions were used.",
+		{ ...bmapReadLikesArgsSchema.shape },
+		async ({ txid, limit, page }): Promise<CallToolResult> => {
+			try {
+				const result = await readBmapLikes({ txid, limit, page });
+
+				if (result.success) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(result.data, null, 2),
+							},
+						],
+						isError: false,
+					};
+				}
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: result.error || "Unknown error occurred",
+						},
+					],
+					isError: true,
+				};
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `Error: ${msg}` }],
+					isError: true,
+				};
+			}
+		},
+	);
+}