@ggoldani/agent-passport-mcp 0.1.0

package/build/generated/src/lib/stellarClient.d.ts

@@ -0,0 +1,10 @@
+import { Horizon, rpc } from "@stellar/stellar-sdk";
+import type { AppConfig } from "../config.js";
+export interface StellarClients {
+    horizon: Horizon.Server;
+    rpc: rpc.Server;
+    networkPassphrase: string;
+    runHorizon<T>(operation: Promise<T>, operationName: string): Promise<T>;
+    runRpc<T>(operation: Promise<T>, operationName: string): Promise<T>;
+}
+export declare function createStellarClients(config: AppConfig): StellarClients;

package/build/generated/src/lib/stellarClient.js

@@ -0,0 +1,61 @@
+import { Horizon, Networks, rpc } from "@stellar/stellar-sdk";
+import { NetworkError, StellarProtocolError, normalizeStellarError } from "./errors.js";
+const DEFAULT_ENDPOINTS = {
+    testnet: {
+        horizon: "https://horizon-testnet.stellar.org",
+        rpc: "https://soroban-testnet.stellar.org",
+        passphrase: Networks.TESTNET
+    },
+    mainnet: {
+        horizon: "https://horizon.stellar.org",
+        rpc: "https://soroban.stellar.org",
+        passphrase: Networks.PUBLIC
+    }
+};
+export function createStellarClients(config) {
+    const defaults = DEFAULT_ENDPOINTS[config.network];
+    const horizonUrl = config.horizonUrl ?? defaults.horizon;
+    const rpcUrl = config.rpcUrl ?? defaults.rpc;
+    return {
+        horizon: new Horizon.Server(horizonUrl),
+        rpc: new rpc.Server(rpcUrl),
+        networkPassphrase: config.networkPassphrase ?? defaults.passphrase,
+        async runHorizon(operation, operationName) {
+            try {
+                return await withTimeout(operation, `horizon:${operationName}`, config.requestTimeoutMs);
+            }
+            catch (error) {
+                const normalized = normalizeStellarError(error);
+                if (normalized instanceof StellarProtocolError || normalized instanceof NetworkError) {
+                    throw normalized;
+                }
+                throw new NetworkError(`Horizon request failed: ${normalized.message}`);
+            }
+        },
+        async runRpc(operation, operationName) {
+            try {
+                return await withTimeout(operation, `rpc:${operationName}`, config.requestTimeoutMs);
+            }
+            catch (error) {
+                const normalized = normalizeStellarError(error);
+                if (normalized instanceof StellarProtocolError || normalized instanceof NetworkError) {
+                    throw normalized;
+                }
+                throw new NetworkError(`Soroban RPC request failed: ${normalized.message}`);
+            }
+        }
+    };
+}
+function withTimeout(operation, operationName, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new NetworkError(`${operationName} timed out after ${timeoutMs}ms.`));
+        }, timeoutMs);
+    });
+    return Promise.race([operation, timeoutPromise]).finally(() => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    });
+}

package/build/generated/src/registerContractTools.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { AppConfig } from "./config.js";
+export declare function registerContractTools(server: McpServer, config: AppConfig): void;

package/build/generated/src/registerContractTools.js

@@ -0,0 +1,160 @@
+import { Spec } from "@stellar/stellar-sdk/contract";
+import { invokeContractMethod } from "./lib/contractInvoke.js";
+import { SPEC_ENTRIES } from "./generated/specEntries.js";
+import * as G from "./generated/schemas.js";
+const spec = new Spec([...SPEC_ENTRIES]);
+export function registerContractTools(server, config) {
+    server.tool("ap_init", "Soroban contract method `init` (generated).", G.initInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "init",
+            args: { admin: input.admin, authorized_relayer: input.authorized_relayer }
+        });
+    });
+    server.tool("ap_get_agent", "Soroban contract method `get_agent` (generated).", G.get_agentInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "get_agent",
+            args: { owner_address: input.owner_address }
+        });
+    });
+    server.tool("ap_get_config", "Soroban contract method `get_config` (generated).", G.get_configInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "get_config",
+            args: {}
+        });
+    });
+    server.tool("ap_get_rating", "Soroban contract method `get_rating` (generated).", G.get_ratingInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "get_rating",
+            args: { interaction_tx_hash: input.interaction_tx_hash }
+        });
+    });
+    server.tool("ap_add_relayer", "Soroban contract method `add_relayer` (generated).", G.add_relayerInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "add_relayer",
+            args: { admin: input.admin, relayer: input.relayer }
+        });
+    });
+    server.tool("ap_list_agents", "Soroban contract method `list_agents` (generated).", G.list_agentsInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "list_agents",
+            args: { from: input.from, limit: input.limit }
+        });
+    });
+    server.tool("ap_accept_admin", "Soroban contract method `accept_admin` (generated).", G.accept_adminInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "accept_admin",
+            args: { new_admin: input.new_admin }
+        });
+    });
+    server.tool("ap_get_relayers", "Soroban contract method `get_relayers` (generated).", G.get_relayersInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "get_relayers",
+            args: {}
+        });
+    });
+    server.tool("ap_submit_rating", "Soroban contract method `submit_rating` (generated).", G.submit_ratingInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "submit_rating",
+            args: { rating: input.rating }
+        });
+    });
+    server.tool("ap_register_agent", "Soroban contract method `register_agent` (generated).", G.register_agentInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "register_agent",
+            args: { owner_address: input.owner_address, input: input.input }
+        });
+    });
+    server.tool("ap_remove_relayer", "Soroban contract method `remove_relayer` (generated).", G.remove_relayerInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "remove_relayer",
+            args: { admin: input.admin, relayer: input.relayer }
+        });
+    });
+    server.tool("ap_transfer_admin", "Soroban contract method `transfer_admin` (generated).", G.transfer_adminInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "transfer_admin",
+            args: { admin: input.admin, new_admin: input.new_admin }
+        });
+    });
+    server.tool("ap_update_profile", "Soroban contract method `update_profile` (generated).", G.update_profileInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "update_profile",
+            args: { owner_address: input.owner_address, input: input.input }
+        });
+    });
+    server.tool("ap_deregister_agent", "Soroban contract method `deregister_agent` (generated).", G.deregister_agentInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "deregister_agent",
+            args: { owner_address: input.owner_address }
+        });
+    });
+    server.tool("ap_register_interaction", "Soroban contract method `register_interaction` (generated).", G.register_interactionInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "register_interaction",
+            args: { relayer: input.relayer, interaction: input.interaction }
+        });
+    });
+    server.tool("ap_cancel_admin_transfer", "Soroban contract method `cancel_admin_transfer` (generated).", G.cancel_admin_transferInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "cancel_admin_transfer",
+            args: { admin: input.admin }
+        });
+    });
+    server.tool("ap_list_agent_interactions", "Soroban contract method `list_agent_interactions` (generated).", G.list_agent_interactionsInputSchema, async (input) => {
+        const contractId = input.contractId ?? config.contractId;
+        return invokeContractMethod(config, spec, {
+            contractId,
+            sourceAccount: input.sourceAccount,
+            method: "list_agent_interactions",
+            args: { provider_address: input.provider_address, from_seq: input.from_seq, limit: input.limit }
+        });
+    });
+}

package/build/generated/src/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { AppConfig } from "./config.js";
+export declare function createServer(config: AppConfig): McpServer;

package/build/generated/src/server.js

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerContractTools } from "./registerContractTools.js";
+export function createServer(config) {
+    const server = new McpServer({
+        name: "agent-passport-contract",
+        version: "0.0.0"
+    });
+    registerContractTools(server, config);
+    return server;
+}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "./generated/src/config.js";
+import { registerContractTools } from "./generated/src/registerContractTools.js";
+import { registerApiBridgeTools } from "./api-bridge/index.js";
+const server = new McpServer({
+    name: "agent-passport",
+    version: "0.1.0",
+});
+server.tool("health", "Check MCP server status", {}, async () => ({
+    content: [{ type: "text", text: "AgentPassport MCP server is running" }],
+}));
+async function main() {
+    const config = loadConfig();
+    registerContractTools(server, config);
+    registerApiBridgeTools(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@ggoldani/agent-passport-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for AgentPassport trust registry — 18 contract tools + 4 REST API bridge tools",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "agent-passport-mcp": "build/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./build/index.js"
+    }
+  },
+  "files": [
+    "build",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@stellar/stellar-sdk": "^14.6.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@ggoldani/stellarmcp": "^0.1.7",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "stellar",
+    "soroban",
+    "agent",
+    "trust",
+    "reputation",
+    "agent-passport",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ggoldani/agent-passport.git",
+    "directory": "tools/agent-passport-mcp"
+  }
+}