@elizaos/autonomous 2.0.0-alpha.21 → 2.0.0-alpha.23

package/test/config-hot-reload.e2e.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Config Hot-Reload — E2E Tests
+ *
+ * Tests:
+ * - GET /api/config returns current config
+ * - PUT /api/config updates config
+ * - Config changes are reflected in subsequent GET
+ * - Invalid config change → graceful rejection
+ */
+
+import http from "node:http";
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { startApiServer } from "../src/api/server";
+
+vi.mock("../src/services/mcp-marketplace", () => ({
+  searchMcpMarketplace: vi.fn().mockResolvedValue({ results: [] }),
+  getMcpServerDetails: vi.fn().mockResolvedValue(null),
+}));
+
+// ---------------------------------------------------------------------------
+// HTTP helper
+// ---------------------------------------------------------------------------
+
+function req(
+  port: number,
+  method: string,
+  p: string,
+  body?: Record<string, unknown>,
+): Promise<{
+  status: number;
+  headers: http.IncomingHttpHeaders;
+  data: Record<string, unknown>;
+}> {
+  return new Promise((resolve, reject) => {
+    const b = body ? JSON.stringify(body) : undefined;
+    const r = http.request(
+      {
+        hostname: "127.0.0.1",
+        port,
+        path: p,
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...(b ? { "Content-Length": Buffer.byteLength(b) } : {}),
+        },
+      },
+      (res) => {
+        const ch: Buffer[] = [];
+        res.on("data", (c: Buffer) => ch.push(c));
+        res.on("end", () => {
+          const raw = Buffer.concat(ch).toString("utf-8");
+          let data: Record<string, unknown> = {};
+          try {
+            data = JSON.parse(raw) as Record<string, unknown>;
+          } catch {
+            data = { _raw: raw };
+          }
+          resolve({ status: res.statusCode ?? 0, headers: res.headers, data });
+        });
+      },
+    );
+    r.on("error", reject);
+    if (b) r.write(b);
+    r.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Server lifecycle
+// ---------------------------------------------------------------------------
+
+let port: number;
+let server: Awaited<ReturnType<typeof startApiServer>>;
+
+beforeAll(async () => {
+  server = await startApiServer({
+    port: 0,
+    initialAgentState: "not_started",
+  });
+  port = server.port;
+}, 30_000);
+
+afterAll(async () => {
+  if (server) {
+    await server.close();
+  }
+}, 15_000);
+
+// ============================================================================
+//  1. Config read
+// ============================================================================
+
+describe("config endpoints", () => {
+  it("GET /api/config returns config object", async () => {
+    const { status, data } = await req(port, "GET", "/api/config");
+    expect(status).toBe(200);
+    expect(data).toBeDefined();
+    expect(typeof data).toBe("object");
+  });
+
+  it("GET /api/config/schema returns JSON schema", async () => {
+    const { status, data } = await req(port, "GET", "/api/config/schema");
+    expect(status).toBe(200);
+    expect(data).toBeDefined();
+  });
+});
+
+// ============================================================================
+//  2. Config update
+// ============================================================================
+
+describe("config updates", () => {
+  it("PUT /api/config accepts valid updates", async () => {
+    const { status } = await req(port, "PUT", "/api/config", {
+      ui: { theme: "dark" },
+    });
+    // Should accept the update or reject if validation fails
+    expect([200, 400, 500]).toContain(status);
+  });
+
+  it("config changes are reflected in subsequent GET", async () => {
+    // First GET to baseline
+    const { data: before } = await req(port, "GET", "/api/config");
+    expect(before).toBeDefined();
+
+    // Subsequent GET should return valid config (regardless of PUT)
+    const { status, data: after } = await req(port, "GET", "/api/config");
+    expect(status).toBe(200);
+    expect(after).toBeDefined();
+  });
+});

package/test/contract-deployer.ts

@@ -0,0 +1,151 @@
+/**
+ * Contract deployment fixture for e2e testing.
+ *
+ * Deploys MockMiladyAgentRegistry (ERC-8004) and MockMiladyCollection (ERC-8041)
+ * to the local Anvil instance.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ethers } from "ethers";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+interface CompiledContract {
+  abi: ethers.InterfaceAbi;
+  bytecode: string;
+}
+
+function resolveArtifactPath(contractNames: string[]): string | null {
+  for (const contractName of contractNames) {
+    const candidate = path.join(
+      __dirname,
+      "contracts",
+      "out",
+      `${contractName}.sol`,
+      `${contractName}.json`,
+    );
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function loadCompiledContract(
+  contractName: string | string[],
+): CompiledContract {
+  const candidates = Array.isArray(contractName)
+    ? contractName
+    : [contractName];
+  const artifactPath = resolveArtifactPath(candidates);
+
+  if (!artifactPath) {
+    throw new Error(
+      `Contract artifact not found for any of: ${candidates.join(", ")}. Did you run 'forge build --skip Harness' in test/contracts?`,
+    );
+  }
+
+  const artifact = JSON.parse(fs.readFileSync(artifactPath, "utf-8"));
+  return {
+    abi: artifact.abi,
+    bytecode: artifact.bytecode.object,
+  };
+}
+
+export interface DeployedContracts {
+  registry: {
+    address: string;
+    contract: ethers.Contract;
+    abi: ethers.InterfaceAbi;
+  };
+  collection: {
+    address: string;
+    contract: ethers.Contract;
+    abi: ethers.InterfaceAbi;
+  };
+}
+
+/**
+ * Deploy MockMiladyAgentRegistry and MockMiladyCollection to the provided network.
+ *
+ * @param wallet - An ethers Wallet connected to a provider
+ * @returns Deployed contract addresses and instances
+ */
+export async function deployContracts(
+  wallet: ethers.Wallet,
+): Promise<DeployedContracts> {
+  // Load compiled artifacts
+  const registryArtifact = loadCompiledContract([
+    "MockMiladyAgentRegistry",
+    "MockMiladyAgentRegistry",
+  ]);
+  const collectionArtifact = loadCompiledContract([
+    "MockMiladyCollection",
+    "MockMiladyCollection",
+  ]);
+
+  // Get current nonce explicitly to avoid race conditions
+  let currentNonce = await wallet.getNonce("pending");
+
+  // Deploy Registry with explicit nonce
+  const registryFactory = new ethers.ContractFactory(
+    registryArtifact.abi,
+    registryArtifact.bytecode,
+    wallet,
+  );
+  const registryContract = await registryFactory.deploy({
+    nonce: currentNonce,
+  });
+  await registryContract.waitForDeployment();
+  const registryAddress = await registryContract.getAddress();
+  currentNonce++;
+
+  // Deploy Collection with explicit nonce
+  const collectionFactory = new ethers.ContractFactory(
+    collectionArtifact.abi,
+    collectionArtifact.bytecode,
+    wallet,
+  );
+  const collectionContract = await collectionFactory.deploy({
+    nonce: currentNonce,
+  });
+  await collectionContract.waitForDeployment();
+  const collectionAddress = await collectionContract.getAddress();
+
+  return {
+    registry: {
+      address: registryAddress,
+      contract: registryContract as ethers.Contract,
+      abi: registryArtifact.abi,
+    },
+    collection: {
+      address: collectionAddress,
+      contract: collectionContract as ethers.Contract,
+      abi: collectionArtifact.abi,
+    },
+  };
+}
+
+/**
+ * Get the compiled ABIs for use with existing service classes.
+ */
+export function getContractABIs(): {
+  registryABI: ethers.InterfaceAbi;
+  collectionABI: ethers.InterfaceAbi;
+} {
+  const registryArtifact = loadCompiledContract([
+    "MockMiladyAgentRegistry",
+    "MockMiladyAgentRegistry",
+  ]);
+  const collectionArtifact = loadCompiledContract([
+    "MockMiladyCollection",
+    "MockMiladyCollection",
+  ]);
+
+  return {
+    registryABI: registryArtifact.abi,
+    collectionABI: collectionArtifact.abi,
+  };
+}

package/test/contracts/MockMiladyAgentRegistry.sol

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title MockMiladyAgentRegistry
+ * @dev Mock ERC-8004 Agent Identity Registry for testing.
+ *
+ * Implements the core interface expected by RegistryService:
+ * - Agent registration (self and delegated)
+ * - Profile updates
+ * - Token URI management
+ * - Status queries
+ */
+contract MockMiladyAgentRegistry is ERC721URIStorage, Ownable {
+    struct Agent {
+        string name;
+        string endpoint;
+        bytes32 capabilitiesHash;
+        bool isActive;
+    }
+
+    uint256 private _tokenIdCounter;
+    mapping(uint256 => Agent) private _agents;
+    mapping(address => uint256) private _addressToTokenId;
+    mapping(string => bool) private _endpointTaken;
+
+    event AgentRegistered(
+        uint256 indexed tokenId,
+        address indexed owner,
+        string name,
+        string endpoint
+    );
+    event AgentUpdated(
+        uint256 indexed tokenId,
+        string endpoint,
+        bytes32 capabilitiesHash
+    );
+
+    constructor() ERC721("Milady Agent Registry", "MILAIDY") {
+        _tokenIdCounter = 1; // Start at 1, 0 means unregistered
+    }
+
+    /**
+     * @dev Register calling address as an agent.
+     */
+    function registerAgent(
+        string memory name,
+        string memory endpoint,
+        bytes32 capabilitiesHash,
+        string memory uri
+    ) external returns (uint256) {
+        return _registerAgentFor(msg.sender, name, endpoint, capabilitiesHash, uri);
+    }
+
+    /**
+     * @dev Register an agent for another address (delegated registration).
+     */
+    function registerAgentFor(
+        address owner,
+        string memory name,
+        string memory endpoint,
+        bytes32 capabilitiesHash,
+        string memory uri
+    ) external returns (uint256) {
+        return _registerAgentFor(owner, name, endpoint, capabilitiesHash, uri);
+    }
+
+    function _registerAgentFor(
+        address owner,
+        string memory name,
+        string memory endpoint,
+        bytes32 capabilitiesHash,
+        string memory uri
+    ) internal returns (uint256) {
+        require(_addressToTokenId[owner] == 0, "Address already registered");
+        require(!_endpointTaken[endpoint], "Endpoint already taken");
+
+        uint256 tokenId = _tokenIdCounter++;
+        _safeMint(owner, tokenId);
+        _setTokenURI(tokenId, uri);
+
+        _agents[tokenId] = Agent({
+            name: name,
+            endpoint: endpoint,
+            capabilitiesHash: capabilitiesHash,
+            isActive: true
+        });
+
+        _addressToTokenId[owner] = tokenId;
+        _endpointTaken[endpoint] = true;
+
+        emit AgentRegistered(tokenId, owner, name, endpoint);
+        return tokenId;
+    }
+
+    /**
+     * @dev Update agent endpoint and capabilities hash.
+     */
+    function updateAgent(
+        string memory endpoint,
+        bytes32 capabilitiesHash
+    ) external {
+        uint256 tokenId = _addressToTokenId[msg.sender];
+        require(tokenId != 0, "Not registered");
+        require(ownerOf(tokenId) == msg.sender, "Not owner");
+
+        Agent storage agent = _agents[tokenId];
+
+        // Free old endpoint if changing
+        if (keccak256(bytes(agent.endpoint)) != keccak256(bytes(endpoint))) {
+            _endpointTaken[agent.endpoint] = false;
+            require(!_endpointTaken[endpoint], "Endpoint already taken");
+            _endpointTaken[endpoint] = true;
+            agent.endpoint = endpoint;
+        }
+
+        agent.capabilitiesHash = capabilitiesHash;
+
+        emit AgentUpdated(tokenId, endpoint, capabilitiesHash);
+    }
+
+    /**
+     * @dev Update full agent profile (name, endpoint, capabilities, tokenURI).
+     */
+    function updateAgentProfile(
+        string memory name,
+        string memory endpoint,
+        bytes32 capabilitiesHash,
+        string memory uri
+    ) external {
+        uint256 tokenId = _addressToTokenId[msg.sender];
+        require(tokenId != 0, "Not registered");
+        require(ownerOf(tokenId) == msg.sender, "Not owner");
+
+        Agent storage agent = _agents[tokenId];
+
+        // Free old endpoint if changing
+        if (keccak256(bytes(agent.endpoint)) != keccak256(bytes(endpoint))) {
+            _endpointTaken[agent.endpoint] = false;
+            require(!_endpointTaken[endpoint], "Endpoint already taken");
+            _endpointTaken[endpoint] = true;
+        }
+
+        agent.name = name;
+        agent.endpoint = endpoint;
+        agent.capabilitiesHash = capabilitiesHash;
+        _setTokenURI(tokenId, uri);
+
+        emit AgentUpdated(tokenId, endpoint, capabilitiesHash);
+    }
+
+    /**
+     * @dev Update tokenURI for a specific token.
+     */
+    function updateTokenURI(uint256 tokenId, string memory uri) external {
+        require(ownerOf(tokenId) == msg.sender, "Not owner");
+        _setTokenURI(tokenId, uri);
+    }
+
+    /**
+     * @dev Deactivate the caller's agent.
+     */
+    function deactivateAgent() external {
+        uint256 tokenId = _addressToTokenId[msg.sender];
+        require(tokenId != 0, "Not registered");
+        _agents[tokenId].isActive = false;
+    }
+
+    /**
+     * @dev Reactivate the caller's agent.
+     */
+    function reactivateAgent() external {
+        uint256 tokenId = _addressToTokenId[msg.sender];
+        require(tokenId != 0, "Not registered");
+        _agents[tokenId].isActive = true;
+    }
+
+    // ── View functions ──────────────────────────────────────────────────────
+
+    function getAgentInfo(uint256 tokenId)
+        external
+        view
+        returns (string memory, string memory, bytes32, bool)
+    {
+        Agent storage agent = _agents[tokenId];
+        return (
+            agent.name,
+            agent.endpoint,
+            agent.capabilitiesHash,
+            agent.isActive
+        );
+    }
+
+    function addressToTokenId(address addr) external view returns (uint256) {
+        return _addressToTokenId[addr];
+    }
+
+    function isRegistered(address addr) external view returns (bool) {
+        return _addressToTokenId[addr] != 0;
+    }
+
+    function getTokenId(address addr) external view returns (uint256) {
+        return _addressToTokenId[addr];
+    }
+
+    function totalAgents() external view returns (uint256) {
+        return _tokenIdCounter - 1; // Counter starts at 1
+    }
+
+    function isEndpointTaken(string memory endpoint) external view returns (bool) {
+        return _endpointTaken[endpoint];
+    }
+}

package/test/contracts/MockMiladyCollection.sol

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
+
+/**
+ * @title MockMiladyCollection
+ * @dev Mock ERC-8041 fixed-supply collection for testing.
+ *
+ * Implements the core interface expected by DropService:
+ * - Public free mint (user pays gas)
+ * - Shiny mint (0.1 ETH + gas)
+ * - Whitelist mint (Merkle proof)
+ * - Supply tracking
+ */
+contract MockMiladyCollection is ERC721URIStorage, Ownable {
+    uint256 public constant MAX_SUPPLY = 2138;
+    uint256 public constant SHINY_PRICE = 0.1 ether;
+
+    uint256 private _currentSupply;
+    bool public publicMintOpen;
+    bool public whitelistMintOpen;
+    bytes32 public merkleRoot;
+
+    mapping(address => bool) private _hasMinted;
+    mapping(uint256 => uint256) private _agentMintNumber;
+    mapping(uint256 => bool) private _isShiny;
+
+    event AgentMinted(
+        uint256 indexed agentId,
+        uint256 indexed mintNumber,
+        address indexed owner,
+        bool shiny
+    );
+    event CollectionUpdated(
+        uint256 maxSupply,
+        uint256 currentSupply,
+        bool publicOpen,
+        bool whitelistOpen
+    );
+
+    constructor() ERC721("Milady Maker", "MILAIDYMAKER") {
+        publicMintOpen = true;
+        whitelistMintOpen = false;
+    }
+
+    // ── Admin functions ────────────────────────────────────────────────────
+
+    function setPublicMintOpen(bool open) external onlyOwner {
+        publicMintOpen = open;
+        emit CollectionUpdated(MAX_SUPPLY, _currentSupply, publicMintOpen, whitelistMintOpen);
+    }
+
+    function setWhitelistMintOpen(bool open) external onlyOwner {
+        whitelistMintOpen = open;
+        emit CollectionUpdated(MAX_SUPPLY, _currentSupply, publicMintOpen, whitelistMintOpen);
+    }
+
+    function setMerkleRoot(bytes32 root) external onlyOwner {
+        merkleRoot = root;
+    }
+
+    // ── Mint functions ─────────────────────────────────────────────────────
+
+    /**
+     * @dev Public free mint (one per address).
+     */
+    function mint(
+        string memory name,
+        string memory endpoint,
+        bytes32 capabilitiesHash
+    ) external returns (uint256) {
+        require(publicMintOpen, "Public mint not open");
+        require(!_hasMinted[msg.sender], "Already minted");
+        require(_currentSupply < MAX_SUPPLY, "Sold out");
+
+        return _doMint(msg.sender, name, endpoint, capabilitiesHash, false);
+    }
+
+    /**
+     * @dev Shiny mint (0.1 ETH, one per address).
+     */
+    function mintShiny(
+        string memory name,
+        string memory endpoint,
+        bytes32 capabilitiesHash
+    ) external payable returns (uint256) {
+        require(publicMintOpen, "Public mint not open");
+        require(!_hasMinted[msg.sender], "Already minted");
+        require(_currentSupply < MAX_SUPPLY, "Sold out");
+        require(msg.value >= SHINY_PRICE, "Insufficient payment");
+
+        return _doMint(msg.sender, name, endpoint, capabilitiesHash, true);
+    }
+
+    /**
+     * @dev Whitelist mint with Merkle proof.
+     */
+    function mintWhitelist(
+        string memory name,
+        string memory endpoint,
+        bytes32 capabilitiesHash,
+        bytes32[] calldata proof
+    ) external returns (uint256) {
+        require(whitelistMintOpen, "Whitelist mint not open");
+        require(!_hasMinted[msg.sender], "Already minted");
+        require(_currentSupply < MAX_SUPPLY, "Sold out");
+
+        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
+        require(MerkleProof.verify(proof, merkleRoot, leaf), "Invalid proof");
+
+        return _doMint(msg.sender, name, endpoint, capabilitiesHash, false);
+    }
+
+    /**
+     * @dev Mint for another address (delegated mint).
+     */
+    function mintFor(
+        address to,
+        string memory name,
+        string memory endpoint,
+        bytes32 capabilitiesHash,
+        bool shiny
+    ) external returns (uint256) {
+        require(publicMintOpen, "Public mint not open");
+        require(!_hasMinted[to], "Already minted");
+        require(_currentSupply < MAX_SUPPLY, "Sold out");
+
+        return _doMint(to, name, endpoint, capabilitiesHash, shiny);
+    }
+
+    function _doMint(
+        address to,
+        string memory, // name - not stored in this simple mock
+        string memory, // endpoint - not stored in this simple mock
+        bytes32, // capabilitiesHash - not stored in this simple mock
+        bool shiny
+    ) internal returns (uint256) {
+        _currentSupply++;
+        uint256 tokenId = _currentSupply;
+        uint256 mintNumber = _currentSupply;
+
+        _safeMint(to, tokenId);
+        _hasMinted[to] = true;
+        _agentMintNumber[tokenId] = mintNumber;
+        _isShiny[tokenId] = shiny;
+
+        // Set a default token URI
+        string memory uri = shiny
+            ? "ipfs://QmShinyMiladyMetadata"
+            : "ipfs://QmMiladyMetadata";
+        _setTokenURI(tokenId, uri);
+
+        emit AgentMinted(tokenId, mintNumber, to, shiny);
+        emit CollectionUpdated(MAX_SUPPLY, _currentSupply, publicMintOpen, whitelistMintOpen);
+
+        return tokenId;
+    }
+
+    // ── View functions ─────────────────────────────────────────────────────
+
+    function currentSupply() external view returns (uint256) {
+        return _currentSupply;
+    }
+
+    function hasMinted(address addr) external view returns (bool) {
+        return _hasMinted[addr];
+    }
+
+    function getAgentMintNumber(uint256 tokenId) external view returns (uint256) {
+        return _agentMintNumber[tokenId];
+    }
+
+    function isShiny(uint256 tokenId) external view returns (bool) {
+        return _isShiny[tokenId];
+    }
+
+    function getCollectionDetails()
+        external
+        view
+        returns (uint256 maxSupply, uint256 supply, bool publicOpen)
+    {
+        return (MAX_SUPPLY, _currentSupply, publicMintOpen);
+    }
+
+    // ── Withdraw ───────────────────────────────────────────────────────────
+
+    function withdraw() external onlyOwner {
+        uint256 balance = address(this).balance;
+        require(balance > 0, "No balance");
+        payable(owner()).transfer(balance);
+    }
+}