Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
// ignore_for_file: avoid_print
import 'dart:convert';
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:integration_test/integration_test.dart';
import 'package:path_provider/path_provider.dart';
import 'package:sam_agent/agentmesh_ffi.dart';
void main() {
IntegrationTestWidgetsFlutterBinding.ensureInitialized();
testWidgets('E2E Mesh Communication Test', (WidgetTester tester) async {
final samLib = SamNodeLib();
// 1. Get local app directories
final appDir = await getApplicationDocumentsDirectory();
final dataDir = '${appDir.path}/sam_e2e_data';
// Cleanup old data
final dir = Directory(dataDir);
if (dir.existsSync()) {
dir.deleteSync(recursive: true);
}
// 2. Fetch OIDC JWT from the mock OIDC server running on host
// Use loopback with adb reverse
const oidcIssuer = 'http://127.0.0.1:18080';
const tokenURL = '$oidcIssuer/token';
final response = await http.post(
Uri.parse(tokenURL),
headers: {'Content-Type': 'application/x-www-form-urlencoded'},
body: {
'grant_type': 'client_credentials',
'client_id': 'test-client',
'client_secret': 'test-secret',
},
);
expect(response.statusCode, equals(200));
final tokenData = jsonDecode(response.body);
final jwt = tokenData['access_token'] as String;
expect(jwt, isNotEmpty);
// 3. Enroll Node against the host control plane
const controlPlaneURL = 'http://127.0.0.1:37001';
final enrollErr = samLib.enroll(dataDir, controlPlaneURL, jwt, true, '', '');
expect(enrollErr, isNull);
// Start local Mock MCP Server inside the Android emulator. It must be
// listening before the node starts: the service it backs is declared in
// the start configuration below and probed at startup; there is no
// runtime registration.
final mockMcpServer = await HttpServer.bind(InternetAddress.loopbackIPv4, 9090);
mockMcpServer.listen((HttpRequest request) async {
if (request.method == 'GET') {
request.response
..statusCode = HttpStatus.notImplemented
..write('501 Unsupported method GET');
await request.response.close();
return;
}
try {
final content = await utf8.decoder.bind(request).join();
final body = jsonDecode(content);
final method = body['method'] as String?;
final id = body['id'];
dynamic result;
if (method == 'initialize') {
result = {
'protocolVersion': '2024-11-05',
'capabilities': {},
'serverInfo': {'name': 'mock-emulator-mcp', 'version': '1.0.0'}
};
} else if (method == 'tools/list') {
result = {
'tools': [
{
'name': 'emulator-tool',
'description': 'test tool on emulator',
'inputSchema': {'type': 'object', 'properties': {}}
}
]
};
} else if (method == 'tools/call') {
result = {
'content': [
{'type': 'text', 'text': 'Hello from Android!'}
]
};
}
request.response
..headers.contentType = ContentType.json
..statusCode = HttpStatus.ok
..write(jsonEncode({
'jsonrpc': '2.0',
'id': id,
'result': result,
}));
} catch (e) {
request.response
..statusCode = HttpStatus.internalServerError
..write(e.toString());
} finally {
await request.response.close();
}
});
// 4. Start Node, declaring the emulator's MCP service in the start
// configuration.
final startErr = samLib.start({
'dataDir': dataDir,
'controlPlaneURL': controlPlaneURL,
'meshID': 'public-mesh',
'bindAddr': '0.0.0.0:8080', // sidecar HTTP server inside phone
'apiToken': 'test-token',
'allowLoopback': true,
'enableRelay': true,
'logLevel': 'debug',
'services': [
{
'type': 'mcp',
'name': 'emulator-tool',
'description': 'test tool inside emulator',
'targetUrl': 'http://127.0.0.1:9090' // point to local Dart mock server
}
],
});
expect(startErr, isNull);
// Wait for node to initialize host connection
await Future.delayed(const Duration(seconds: 5));
final nodeID = samLib.getNodeID();
expect(nodeID, isNotNull);
expect(nodeID, isNotEmpty);
expect(nodeID, isNot('unauthenticated'));
// Discover host-tool from inside the emulator via its local MCP API using McpClient
final client = McpClient('http://127.0.0.1:8080/mcp', 'test-token');
var initialized = false;
for (var i = 0; i < 10; i++) {
try {
await client.initialize();
initialized = true;
break;
} catch (e) {
print('E2E McpClient initialization attempt failed: $e');
}
await Future.delayed(const Duration(seconds: 1));
}
expect(initialized, isTrue, reason: 'Emulator failed to initialize McpClient session');
var discovered = false;
String hostToolName = 'host-tool';
String hostPeerId = '';
for (var i = 0; i < 30; i++) {
try {
final callResult = await client.post('tools/call', {
'name': 'find_remote_tools',
'arguments': {}
});
print('E2E Discovered Tools Result: $callResult');
if (callResult != null && callResult['content'] != null) {
final contentList = callResult['content'] as List;
if (contentList.isNotEmpty) {
final text = contentList[0]['text'] as String;
final tools = jsonDecode(text) as List;
final matched = tools.firstWhere(
(t) => (t['tool_name'] as String).contains('host-tool'),
orElse: () => null,
);
if (matched != null) {
hostToolName = matched['tool_name'] as String;
hostPeerId = matched['peer_id'] as String;
discovered = true;
break;
}
}
}
} catch (e) {
print('E2E Discovery attempt failed: $e');
}
await Future.delayed(const Duration(seconds: 1));
}
expect(discovered, isTrue, reason: 'Emulator failed to discover host-tool');
// Call host-tool from inside the emulator via its local MCP API using McpClient
var called = false;
for (var i = 0; i < 10; i++) {
try {
final callResult = await client.post('tools/call', {
'name': 'call_remote_tool',
'arguments': {
'peer_id': hostPeerId,
'tool_name': hostToolName,
}
});
print('E2E Call Result: $callResult');
if (callResult != null && callResult['content'] != null) {
final content = callResult['content'] as List;
if (content.any((c) => c['text'].contains('Hello from Host!'))) {
called = true;
break;
}
}
} catch (e) {
print('E2E Call attempt failed: $e');
}
await Future.delayed(const Duration(seconds: 1));
}
expect(called, isTrue, reason: 'Emulator failed to execute host-tool');
// Wait some time to let the host verify connection and discover emulator-tool
await Future.delayed(const Duration(seconds: 10));
// Cleanup & Stop
await mockMcpServer.close();
final stopErr = samLib.stop();
expect(stopErr, isNull);
});
tearDownAll(() async {
try {
final appDir = await getApplicationDocumentsDirectory();
final file = File('${appDir.path}/sam_e2e_data/node.log');
if (file.existsSync()) {
print('=== MOBILE GO NODE LOGS ===');
print(file.readAsStringSync());
print('===========================');
} else {
print('No node.log file found at ${file.path}');
}
} catch (e) {
print('Failed to print node.log: $e');
}
});
}
class McpClient {
final String url;
final String token;
String? sessionId;
McpClient(this.url, this.token);
Future<dynamic> post(String method, Map<String, dynamic> params) async {
final Map<String, String> headers = {
'Content-Type': 'application/json',
'Accept': 'application/json, text/event-stream',
'Authorization': 'Bearer $token',
};
if (sessionId != null) {
headers['Mcp-Session-Id'] = sessionId!;
}
final Map<String, dynamic> bodyMap = {
'jsonrpc': '2.0',
'method': method,
'params': params,
};
if (!method.startsWith('notifications/')) {
bodyMap['id'] = 1;
}
final response = await http.post(
Uri.parse(url),
headers: headers,
body: jsonEncode(bodyMap),
);
// Save session ID if returned in headers
final returnedSessionId = response.headers['mcp-session-id'] ?? response.headers['Mcp-Session-Id'];
if (returnedSessionId != null) {
sessionId = returnedSessionId;
}
if (response.statusCode < 200 || response.statusCode >= 300) {
throw Exception('HTTP error ${response.statusCode}: ${response.body}');
}
// Parse the SSE body
final body = response.body;
String jsonData = '';
for (var line in body.split('\n')) {
if (line.startsWith('data: ')) {
jsonData = line.substring(6);
break;
}
}
if (jsonData.isEmpty) {
if (method.startsWith('notifications/')) {
return null;
}
throw Exception('No data block found in SSE response: $body');
}
final dataObj = jsonDecode(jsonData);
if (dataObj['error'] != null) {
throw Exception('JSON-RPC error: ${dataObj['error']}');
}
return dataObj['result'];
}
Future<void> initialize() async {
await post('initialize', {
'protocolVersion': '2024-11-05',
'capabilities': {},
'clientInfo': {
'name': 'e2e-dart-client',
'version': '1.0.0'
}
});
await post('notifications/initialized', {});
}
}