bsv-mcp 0.0.35 → 0.2.0

package/tools/utils/installAgentMaster.ts

@@ -0,0 +1,84 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { z } from "zod";
+
+const installAgentMasterSchema = z.object({
+	method: z
+		.enum(["go", "source", "auto"])
+		.optional()
+		.describe("Installation method"),
+});
+
+/**
+ * Install the Agent Master CLI tool for managing MCP server configurations
+ */
+export async function installAgentMaster(
+	args: z.infer<typeof installAgentMasterSchema>,
+) {
+	const method = args.method || "auto";
+
+	return new Promise((resolve, reject) => {
+		let command: string;
+		let commandArgs: string[] = [];
+
+		if (method === "auto" || method === "go") {
+			// Try go install first
+			command = "go";
+			commandArgs = ["install", "github.com/b-open-io/agent-master-cli@latest"];
+		} else if (method === "source") {
+			// Install from source
+			reject(
+				new Error(
+					"Source installation requires manual steps. Please run:\ngit clone https://github.com/b-open-io/agent-master-cli.git\ncd agent-master-cli\nmake deps && make build && make install",
+				),
+			);
+			return;
+		}
+
+		console.error(`🔧 Installing Agent Master CLI using ${method} method...`);
+
+		const install = spawn(command, commandArgs, {
+			stdio: "inherit",
+			shell: true,
+		});
+
+		install.on("error", (error) => {
+			if (method === "auto" && command === "go") {
+				// If go install fails in auto mode, provide instructions
+				reject(
+					new Error(
+						"Go installation failed. Please ensure Go is installed or try manual installation:\n\n1. Install Go from https://golang.org/dl/\n2. Run: go install github.com/b-open-io/agent-master-cli@latest\n\nOr install from source:\ngit clone https://github.com/b-open-io/agent-master-cli.git\ncd agent-master-cli\nmake deps && make build && make install",
+					),
+				);
+			} else {
+				reject(error);
+			}
+		});
+
+		install.on("close", (code) => {
+			if (code !== 0) {
+				reject(new Error(`Installation failed with code ${code}`));
+			} else {
+				resolve({
+					success: true,
+					message:
+						"✅ Agent Master CLI installed successfully!\n\nGet started with:\n  agent-master init --with-demo\n  agent-master list\n  agent-master sync --preset claude",
+					nextSteps: [
+						"Initialize configuration: agent-master init --with-demo",
+						"List servers: agent-master list",
+						'Add BSV MCP: agent-master add bsv-mcp --transport stdio --command "bunx" --args "bsv-mcp@latest"',
+						"Sync to Claude: agent-master sync --preset claude",
+					],
+				});
+			}
+		});
+	});
+}
+
+export const installAgentMasterTool = {
+	name: "utils_installAgentMaster",
+	description:
+		"Install the Agent Master CLI tool for managing MCP server configurations across multiple platforms (Claude, VS Code, Cursor, etc.)",
+	inputSchema: installAgentMasterSchema,
+	handler: installAgentMaster,
+};

package/tools/utils/logger.ts

@@ -0,0 +1,20 @@
+/**
+ * Simple logger utility for consistent output formatting
+ */
+export const logger = {
+	info: (message: string) => console.error(`ℹ️ ${message}`),
+	success: (message: string) => console.error(`✅ ${message}`),
+	warn: (message: string) => console.error(`⚠️ ${message}`),
+	error: (message: string, error?: unknown) => {
+		if (error) {
+			console.error(`❌ ${message}:`, error);
+		} else {
+			console.error(`❌ ${message}`);
+		}
+	},
+	debug: (message: string, ...args: unknown[]) => {
+		if (process.env.DEBUG === "true") {
+			console.error(`🐛 ${message}`, ...args);
+		}
+	},
+};

package/tools/utils/toolConfig.ts

@@ -0,0 +1,80 @@
+/**
+ * Tool category configuration
+ */
+export interface ToolCategory {
+	name: string;
+	envVar: string;
+	defaultEnabled: boolean;
+	register: (server: unknown, config?: unknown) => void;
+	dependencies?: string[]; // Other categories this depends on
+}
+
+/**
+ * Check if a tool category is enabled based on environment and config
+ */
+export function isToolEnabled(
+	category: ToolCategory,
+	config: Record<string, boolean | undefined> = {},
+): boolean {
+	const configKey = `enable${category.name}Tools`;
+
+	// Check config override first
+	if (configKey in config && config[configKey] !== undefined) {
+		return config[configKey] as boolean;
+	}
+
+	// Check environment variable
+	const envValue = process.env[category.envVar];
+	if (envValue !== undefined) {
+		// For ENABLE_* vars, check if === "true"
+		// For DISABLE_* vars, check if !== "true"
+		if (category.envVar.startsWith("ENABLE_")) {
+			return envValue === "true";
+		}
+		return envValue !== "true";
+	}
+
+	// Return default
+	return category.defaultEnabled;
+}
+
+/**
+ * Register multiple tool categories with their dependencies
+ */
+export function registerToolCategories(
+	server: unknown,
+	categories: ToolCategory[],
+	config: Record<string, boolean | undefined> = {},
+): void {
+	const enabled: Set<string> = new Set();
+
+	// First pass: determine what's enabled
+	for (const category of categories) {
+		if (isToolEnabled(category, config)) {
+			enabled.add(category.name);
+		}
+	}
+
+	// Second pass: register enabled categories
+	for (const category of categories) {
+		if (enabled.has(category.name)) {
+			// Check dependencies
+			const missingDeps =
+				category.dependencies?.filter((dep) => !enabled.has(dep)) || [];
+			if (missingDeps.length > 0) {
+				console.warn(
+					`⚠️ ${category.name} tools not registered (missing dependencies: ${missingDeps.join(", ")})`,
+				);
+				continue;
+			}
+
+			// Register the category
+			try {
+				category.register(server, config);
+				console.error(`✅ Registered ${category.name} tools`);
+			} catch (error) {
+				console.error(`❌ Failed to register ${category.name} tools:`, error);
+			}
+		}
+	}
+}

package/tools/utils/toolRegistration.ts

@@ -0,0 +1,66 @@
+/**
+ * Common tool registration utilities for the BSV MCP server
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { z } from "zod";
+
+export interface ToolConfig<TArgs = Record<string, unknown>> {
+	name: string;
+	description: string;
+	schema: z.ZodSchema<TArgs>;
+	handler: (args: TArgs) => Promise<ToolResponse>;
+}
+
+export interface ToolResponse {
+	content: Array<{
+		type: "text";
+		text: string;
+	}>;
+	isError?: boolean;
+}
+
+/**
+ * Register a tool with standard error handling and response formatting
+ */
+export function registerTool<TArgs = Record<string, unknown>>(
+	server: McpServer,
+	config: ToolConfig<TArgs>,
+): void {
+	server.tool(config.name, config.schema, async (args: TArgs) => {
+		try {
+			return await config.handler(args);
+		} catch (error) {
+			return {
+				content: [
+					{
+						type: "text" as const,
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+					},
+				],
+				isError: true,
+			};
+		}
+	});
+}
+
+/**
+ * Helper function to create a simple tool registration function
+ */
+export function createToolRegistration<TDeps = undefined>(
+	toolName: string,
+	description: string,
+	schema: z.ZodSchema<Record<string, unknown>>,
+	handler: (
+		args: Record<string, unknown>,
+		deps?: TDeps,
+	) => Promise<ToolResponse>,
+) {
+	return (server: McpServer, deps?: TDeps) => {
+		registerTool(server, {
+			name: toolName,
+			description,
+			schema,
+			handler: (args) => handler(args, deps),
+		});
+	};
+}

package/tools/utils/transactionBuilder.ts

@@ -0,0 +1,196 @@
+import {
+	isBroadcastFailure,
+	isBroadcastResponse,
+	P2PKH,
+	type PrivateKey,
+	Script,
+	Transaction,
+	Utils,
+} from "@bsv/sdk";
+import { V5Broadcaster } from "../../utils/broadcaster";
+import type { Utxo } from "../wallet/utxo";
+
+const DEFAULT_SAT_PER_BYTE = 0.05;
+const DUST_LIMIT = 546;
+
+interface TransactionBuilderConfig {
+	outputs: Array<{
+		script?: Script;
+		address?: string;
+		satoshis: number;
+	}>;
+	utxos: Utxo[];
+	changeAddress: string;
+	paymentKey: PrivateKey;
+	feePerByte?: number;
+}
+
+interface TransactionResult {
+	success: boolean;
+	txid?: string;
+	rawTx?: string;
+	error?: string;
+	fee?: number;
+}
+
+/**
+ * Build and optionally broadcast a transaction with automatic UTXO selection and fee calculation
+ */
+export async function buildAndSendTransaction(
+	config: TransactionBuilderConfig,
+	broadcast = true,
+): Promise<TransactionResult> {
+	const {
+		outputs,
+		utxos,
+		changeAddress,
+		paymentKey,
+		feePerByte = DEFAULT_SAT_PER_BYTE,
+	} = config;
+
+	if (!utxos || utxos.length === 0) {
+		return {
+			success: false,
+			error: "No UTXOs available to fund transaction",
+		};
+	}
+
+	const tx = new Transaction();
+	const p2pkh = new P2PKH();
+
+	// Add all outputs
+	for (const output of outputs) {
+		if (output.script) {
+			tx.addOutput({
+				lockingScript: output.script,
+				satoshis: output.satoshis,
+			});
+		} else if (output.address) {
+			tx.addOutput({
+				lockingScript: p2pkh.lock(output.address),
+				satoshis: output.satoshis,
+			});
+		}
+	}
+
+	// Calculate total output amount
+	const totalOutputSatoshis = outputs.reduce(
+		(sum, out) => sum + out.satoshis,
+		0,
+	);
+
+	// Select UTXOs and add inputs
+	let totalInputSatoshis = 0;
+	const selectedUtxos: Utxo[] = [];
+
+	// Sort UTXOs by value (ascending) to minimize the number of inputs
+	const sortedUtxos = [...utxos].sort((a, b) => a.satoshis - b.satoshis);
+
+	for (const utxo of sortedUtxos) {
+		selectedUtxos.push(utxo);
+		totalInputSatoshis += utxo.satoshis;
+
+		const input = {
+			sourceTransaction: utxo.tx,
+			sourceOutputIndex: utxo.vout,
+			unlockingScriptTemplate: p2pkh.unlock(paymentKey),
+		};
+		tx.addInput(input);
+
+		// Estimate fee with current inputs
+		const estimatedSize = tx.toHex().length / 2 + 150; // rough estimate for unsigned tx
+		const estimatedFee = Math.ceil(estimatedSize * feePerByte);
+
+		// Check if we have enough to cover outputs + fee + potential change
+		if (totalInputSatoshis >= totalOutputSatoshis + estimatedFee + DUST_LIMIT) {
+			break;
+		}
+	}
+
+	// Calculate final fee
+	const estimatedSize = tx.toHex().length / 2 + 35; // more accurate with all inputs
+	const fee = Math.ceil(estimatedSize * feePerByte);
+
+	// Check if we have enough funds
+	if (totalInputSatoshis < totalOutputSatoshis + fee) {
+		return {
+			success: false,
+			error: `Insufficient funds. Have ${totalInputSatoshis} sats, need ${totalOutputSatoshis + fee} sats`,
+		};
+	}
+
+	// Add change output if needed
+	const change = totalInputSatoshis - totalOutputSatoshis - fee;
+	if (change >= DUST_LIMIT) {
+		tx.addOutput({
+			lockingScript: p2pkh.lock(changeAddress),
+			satoshis: change,
+		});
+	}
+
+	// Sign the transaction
+	await tx.sign();
+
+	const rawTx = tx.toHex();
+	const txid = tx.id("hex") as string;
+
+	// Check if broadcasting is disabled
+	if (process.env.DISABLE_BROADCASTING === "true" || !broadcast) {
+		return {
+			success: true,
+			txid,
+			rawTx,
+			fee,
+		};
+	}
+
+	// Broadcast the transaction
+	try {
+		const broadcaster = new V5Broadcaster();
+		const broadcastResult = await tx.broadcast(broadcaster);
+
+		if (isBroadcastResponse(broadcastResult)) {
+			return {
+				success: true,
+				txid: broadcastResult.txid || txid,
+				rawTx,
+				fee,
+			};
+		}
+		if (isBroadcastFailure(broadcastResult)) {
+			return {
+				success: true,
+				txid,
+				rawTx,
+				fee,
+				error: `Transaction created but broadcast failed: ${broadcastResult.description}`,
+			};
+		}
+		return {
+			success: true,
+			txid,
+			rawTx,
+			fee,
+			error: "Transaction created but broadcast status uncertain",
+		};
+	} catch (error) {
+		return {
+			success: true,
+			txid,
+			rawTx,
+			fee,
+			error: `Transaction created but broadcast failed: ${error instanceof Error ? error.message : String(error)}`,
+		};
+	}
+}
+
+/**
+ * Build OP_RETURN script from data arrays
+ */
+export function buildOpReturnScript(dataArrays: Uint8Array[]): Script {
+	return new Script([
+		{ op: 0 }, // OP_0
+		{ op: 106 }, // OP_RETURN
+		...dataArrays.map((data) => ({ data })),
+	]);
+}

package/tools/wallet/a2bPublishAgent.ts

@@ -5,7 +5,6 @@ import type {
 	ServerNotification,
 	ServerRequest,
 } from "@modelcontextprotocol/sdk/types.js";
-import { createOrdinals } from "js-1sat-ord";
 import type {
 	ChangeResult,
 	CreateOrdinalsConfig,
@@ -14,9 +13,13 @@ import type {
 	LocalSigner,
 	PreMAP,
 } from "js-1sat-ord";
+import { createOrdinals } from "js-1sat-ord";
 import { Sigma } from "sigma-protocol";
 import { z } from "zod";
+import packageJson from "../../package.json";
+import { V5Broadcaster } from "../../utils/broadcaster";
 import type { Wallet } from "./wallet";
+
 const { toArray, toBase64 } = Utils;
 
 // https://raw.githubusercontent.com/google/A2A/refs/heads/main/specification/json/a2a.json
@@ -158,7 +161,7 @@ export function registerA2bPublishAgentTool(server: McpServer, wallet: Wallet) {
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
 			try {
-				const paymentPk = wallet.getPrivateKey();
+				const paymentPk = wallet.getPaymentKey();
 				if (!paymentPk) throw new Error("No private key available");
 				const { paymentUtxos } = await wallet.getUtxos();
 				if (!paymentUtxos?.length)
@@ -219,7 +222,7 @@ export function registerA2bPublishAgentTool(server: McpServer, wallet: Wallet) {
 									url: args.providerUrl,
 								}
 							: null,
-					version: args.version ?? "1.0.0",
+					version: args.version ?? packageJson.version,
 					documentationUrl: args.documentationUrl ?? null,
 					capabilities: {
 						streaming: args.streaming,
@@ -272,7 +275,8 @@ export function registerA2bPublishAgentTool(server: McpServer, wallet: Wallet) {
 
 				const disableBroadcasting = process.env.DISABLE_BROADCASTING === "true";
 				if (!disableBroadcasting) {
-					await changeResult.tx.broadcast();
+					const broadcaster = new V5Broadcaster();
+					await changeResult.tx.broadcast(broadcaster);
 
 					// Refresh UTXOs
 					try {

package/tools/wallet/a2bPublishMcp.ts

@@ -1,4 +1,5 @@
-import { PrivateKey, Utils } from "@bsv/sdk";
+import type { PrivateKey, WalletInterface } from "@bsv/sdk";
+import { Utils } from "@bsv/sdk";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -9,7 +10,6 @@ import type {
 	ServerNotification,
 	ServerRequest,
 } from "@modelcontextprotocol/sdk/types.js";
-import { createOrdinals } from "js-1sat-ord";
 import type {
 	ChangeResult,
 	CreateOrdinalsConfig,
@@ -18,9 +18,13 @@ import type {
 	LocalSigner,
 	PreMAP,
 } from "js-1sat-ord";
+import { createOrdinals } from "js-1sat-ord";
 import { Sigma } from "sigma-protocol";
 import { z } from "zod";
+import packageJson from "../../package.json";
+import { BsocialBroadcaster, V5Broadcaster } from "../../utils/broadcaster";
 import type { Wallet } from "./wallet";
+
 const { toArray, toBase64 } = Utils;
 
 // API endpoint for the A2B Overlay service
@@ -134,7 +138,7 @@ async function fetchMcpMetadata(
 		// Create and connect a client
 		client = new Client({
 			name: "metadata-fetcher",
-			version: "1.0.0",
+			version: packageJson.version,
 		});
 
 		await client.connect(transport);
@@ -186,6 +190,7 @@ async function fetchMcpMetadata(
 export function registerA2bPublishMcpTool(
 	server: McpServer,
 	wallet: Wallet,
+	identityPk: PrivateKey | undefined,
 	config: { disableBroadcasting: boolean },
 ) {
 	server.tool(
@@ -197,22 +202,14 @@ export function registerA2bPublishMcpTool(
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
 			try {
-				// Load optional identity key for sigma signing
-				const identityKeyWif = process.env.IDENTITY_KEY_WIF;
-				let identityPk: PrivateKey | undefined;
-				if (identityKeyWif) {
-					try {
-						identityPk = PrivateKey.fromWif(identityKeyWif);
-					} catch (e) {
-						console.warn(
-							"Warning: Invalid IDENTITY_KEY_WIF environment variable; sigma signing disabled",
-							e,
-						);
-					}
+				if (!identityPk) {
+					console.warn(
+						"Warning: No identity key provided; sigma signing disabled for A2B MCP publish",
+					);
 				}
 
-				const paymentPk = wallet.getPrivateKey();
-				if (!paymentPk) throw new Error("No private key available");
+				const paymentPk = wallet.getPaymentKey();
+				if (!paymentPk) throw new Error("No payment private key available");
 
 				const { paymentUtxos } = await wallet.getUtxos();
 				if (!paymentUtxos?.length)
@@ -284,20 +281,27 @@ export function registerA2bPublishMcpTool(
 					changeAddress: walletAddress,
 					metaData,
 				} as CreateOrdinalsConfig;
+
+				// Use the passed identityPk for signing if available
 				if (identityPk) {
 					createOrdinalsConfig.signer = {
 						idKey: identityPk,
 					} as LocalSigner;
 				}
-				// Inscribe the ordinal on-chain via js-1sat-ord
-				const result = await createOrdinals(createOrdinalsConfig);
 
-				const changeResult = result as ChangeResult;
+				// Inscribe the ordinal on-chain via js-1sat-ord
+				let result: ChangeResult | undefined;
+				if (!config.disableBroadcasting) {
+					result = await createOrdinals(createOrdinalsConfig);
+				} else {
+					console.warn("Broadcasting disabled. Transaction not created.");
+				}
 
 				// Broadcast the transaction
-				if (!config.disableBroadcasting) {
-					await changeResult.tx.broadcast();
-					const txid = changeResult.tx.id("hex");
+				if (!config.disableBroadcasting && result) {
+					const broadcaster = new V5Broadcaster();
+					await result.tx.broadcast(broadcaster);
+					const txid = result.tx.id("hex");
 
 					setTimeout(async () => {
 						// Call the ingest endpoint to process the transaction
@@ -350,7 +354,7 @@ export function registerA2bPublishMcpTool(
 					content: [
 						{
 							type: "text",
-							text: changeResult.tx.toHex(),
+							text: result?.tx.toHex() || "",
 						},
 					],
 				};

package/tools/wallet/createOrdinals.ts

@@ -6,7 +6,6 @@ import type {
 	ServerNotification,
 	ServerRequest,
 } from "@modelcontextprotocol/sdk/types.js";
-import { createOrdinals } from "js-1sat-ord";
 import type {
 	ChangeResult,
 	CreateOrdinalsCollectionItemMetadata,
@@ -17,8 +16,10 @@ import type {
 	LocalSigner,
 	PreMAP,
 } from "js-1sat-ord";
+import { createOrdinals, OneSatBroadcaster } from "js-1sat-ord";
 import { Sigma } from "sigma-protocol";
 import { z } from "zod";
+import { BsocialBroadcaster, V5Broadcaster } from "../../utils/broadcaster";
 import type { Wallet } from "./wallet";
 
 /**
@@ -129,7 +130,8 @@ export function registerCreateOrdinalsTool(server: McpServer, wallet: Wallet) {
 
 				const disableBroadcasting = process.env.DISABLE_BROADCASTING === "true";
 				if (!disableBroadcasting) {
-					await changeResult.tx.broadcast();
+					const broadcaster = new V5Broadcaster();
+					await changeResult.tx.broadcast(broadcaster);
 
 					// 8. Refresh the wallet's UTXOs after spending
 					try {