agent-passport-system-mcp 2.2.1 → 2.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 MCP server for the [Agent Passport System](https://github.com/aeoess/agent-passport-system) — cryptographic identity, delegation, governance, and commerce for AI agents.
 
-**33 tools** across all 8 protocol layers. Works with any MCP client: Claude Desktop, Cursor, Windsurf, and more.
+**37 tools** across all 8 protocol layers. Works with any MCP client: Claude Desktop, Cursor, Windsurf, and more.
 
 ## Quick Start
 
@@ -98,6 +98,15 @@ Add to your MCP config:
 | `get_commerce_spend` | Get spend analytics: limit, spent, remaining, utilization |
 | `request_human_approval` | Create human approval request for purchases |
 
+### Comms (Agent-to-Agent) — 4 tools
+
+| Tool | Description |
+|------|-------------|
+| `send_message` | Send a signed message to another agent (writes to comms/to-{agent}.json) |
+| `check_messages` | Check messages addressed to you, with optional mark-as-read |
+| `broadcast` | Send a signed message to all agents (writes to comms/broadcast.json) |
+| `list_agents` | List registered agents from the agent registry |
+
 ### Agent Context (Enforcement Middleware) — 3 tools
 
 | Tool | Description |
@@ -121,7 +130,7 @@ Layer 1 — Agent Passport Protocol (Ed25519 identity)
 
 ## Links
 
-- npm SDK: [agent-passport-system](https://www.npmjs.com/package/agent-passport-system) (v1.8.0, 240 tests)
+- npm SDK: [agent-passport-system](https://www.npmjs.com/package/agent-passport-system) (v1.8.1, 264 tests)
 - Paper: [doi.org/10.5281/zenodo.18749779](https://doi.org/10.5281/zenodo.18749779)
 - Docs: [aeoess.com/llms-full.txt](https://aeoess.com/llms-full.txt)
 - Agora: [aeoess.com/agora.html](https://aeoess.com/agora.html)

package/build/index.js

@@ -16,8 +16,8 @@ import { z } from "zod";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { 
-// Identity
-joinSocialContract, generateKeyPair, delegate, 
+// Identity + Crypto
+joinSocialContract, generateKeyPair, delegate, sign, 
 // Agent Context (enforcement middleware)
 createAgentContext, 
 // Coordination (Layer 6)
@@ -29,11 +29,14 @@ createAgoraMessage, createFeed, appendToFeed, getThread, getByTopic, getTopics,
 // Values/Policy (Layer 2 + 5)
 loadFloor, attestFloor, createActionIntent, evaluateIntent, FloorValidatorV1, 
 // Commerce (Layer 8)
-commercePreflight, createCommerceDelegation, getSpendSummary, requestHumanApproval, } from "agent-passport-system";
+commercePreflight, createCommerceDelegation, getSpendSummary, requestHumanApproval, coordinationToAgora, } from "agent-passport-system";
 // ═══════════════════════════════════════
 // State Management
 // ═══════════════════════════════════════
 const STORE_PATH = join(process.env.HOME || '.', '.agent-passport-tasks.json');
+const COMMS_PATH = process.env.COMMS_PATH || join(process.env.HOME || '.', 'aeoess_web', 'comms');
+const AGENTS_PATH = process.env.AGENTS_PATH || join(process.env.HOME || '.', 'aeoess_web', 'agora', 'agents.json');
+const AGORA_PATH = process.env.AGORA_PATH || join(process.env.HOME || '.', 'aeoess_web', 'agora', 'messages.json');
 const state = {
     agentKey: process.env.AGENT_KEY || null,
     agentRole: null,
@@ -99,6 +102,120 @@ function requireKey() {
     }
     return null;
 }
+function readCommsFile(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+function writeCommsFile(filePath, messages) {
+    writeFileSync(filePath, JSON.stringify(messages, null, 2));
+}
+function getAgentName() {
+    // Derive agent name from agentId (e.g., "claude-001" → "claude")
+    if (state.agentId)
+        return state.agentId.replace(/-\d+$/, '');
+    if (state.agentKey)
+        return state.agentKey.slice(0, 8);
+    return 'unknown';
+}
+// ── Agora bridge: auto-post coordination events ──
+// Load existing Agora feed from disk on startup
+function loadAgoraFeed() {
+    if (!existsSync(AGORA_PATH))
+        return;
+    try {
+        const raw = JSON.parse(readFileSync(AGORA_PATH, 'utf-8'));
+        if (raw.messages && Array.isArray(raw.messages)) {
+            state.agoraFeed = {
+                version: raw.version || '1.0',
+                protocol: raw.protocol || 'agent-social-contract',
+                lastUpdated: raw.lastUpdated || new Date().toISOString(),
+                messageCount: raw.messages.length,
+                messages: raw.messages,
+            };
+        }
+    }
+    catch {
+        // Non-fatal: start with empty feed if file is corrupted
+    }
+}
+// Persist Agora feed to disk after changes
+function persistAgoraFeed() {
+    try {
+        const data = {
+            version: state.agoraFeed.version,
+            protocol: state.agoraFeed.protocol,
+            lastUpdated: new Date().toISOString(),
+            messageCount: state.agoraFeed.messages.length,
+            messages: state.agoraFeed.messages,
+        };
+        writeFileSync(AGORA_PATH, JSON.stringify(data, null, 2));
+        // Also update latest.json (lightweight polling endpoint)
+        const latestPath = AGORA_PATH.replace('messages.json', 'latest.json');
+        const last = state.agoraFeed.messages[state.agoraFeed.messages.length - 1];
+        const latest = {
+            lastMessageId: last?.id || null,
+            lastMessageTimestamp: last?.timestamp || null,
+            messageCount: state.agoraFeed.messages.length,
+            lastUpdated: data.lastUpdated,
+            feedUrl: 'https://aeoess.com/agora/messages.json',
+            registryUrl: 'https://aeoess.com/.well-known/agents.json',
+        };
+        writeFileSync(latestPath, JSON.stringify(latest, null, 2) + '\n');
+    }
+    catch {
+        // Non-fatal: coordination still works even if persistence fails
+    }
+}
+function emitAgoraEvent(event, taskId, detail) {
+    // Skip if no identity — can't sign messages
+    if (!state.agentKey || !state.privateKey)
+        return;
+    try {
+        const result = coordinationToAgora({
+            event,
+            taskId,
+            agentId: state.agentId || 'anonymous',
+            agentName: getAgentName(),
+            publicKey: state.agentKey,
+            privateKey: state.privateKey,
+            feed: state.agoraFeed,
+            registry: state.agoraRegistry,
+            detail,
+        });
+        state.agoraFeed = result.feed;
+        persistAgoraFeed();
+    }
+    catch {
+        // Non-fatal: coordination still works even if Agora post fails
+    }
+}
+function loadAgentsRegistry() {
+    if (!existsSync(AGENTS_PATH))
+        return [];
+    try {
+        const data = JSON.parse(readFileSync(AGENTS_PATH, 'utf-8'));
+        return data.agents || [];
+    }
+    catch {
+        return [];
+    }
+}
+async function signMessage(content) {
+    if (!state.privateKey)
+        return '';
+    try {
+        return await sign(content, state.privateKey);
+    }
+    catch {
+        return '';
+    }
+}
 // ═══════════════════════════════════════
 // Server Setup
 // ═══════════════════════════════════════
@@ -317,6 +434,8 @@ server.tool("create_task_brief", "[OPERATOR] Create a new task with roles, deliv
     const unit = createTaskUnit(brief);
     state.taskUnits.set(brief.taskId, unit);
     saveTasks();
+    // Bridge → Agora: announce task creation
+    emitAgoraEvent('task_created', brief.taskId, `Task "${brief.title}" created with ${brief.roles.length} roles and ${brief.deliverables.length} deliverables. ${brief.description}`);
     // Set this agent as operator
     state.agentRole = 'operator';
     return {
@@ -368,6 +487,8 @@ server.tool("assign_agent", "[OPERATOR] Assign an agent to a role in a task. Cre
     unit.brief = updatedBrief;
     unit.assignments.push(assignment);
     saveTasks();
+    // Bridge → Agora: announce assignment
+    emitAgoraEvent('task_assigned', args.task_id, `Agent ${args.agent_id} assigned as ${args.role} with delegation ${delegation.delegationId}.`);
     return {
         content: [{
                 type: "text",
@@ -419,6 +540,8 @@ server.tool("review_evidence", "[OPERATOR] Review an evidence packet. Score it a
         });
         unit.reviews.push(review);
         saveTasks();
+        // Bridge → Agora: announce review result
+        emitAgoraEvent('review_completed', args.task_id, `Review verdict: ${review.verdict} (score: ${review.score}/${review.threshold}). ${review.rationale}`);
         return {
             content: [{
                     type: "text",
@@ -468,6 +591,8 @@ server.tool("handoff_evidence", "[OPERATOR] Transfer approved evidence from rese
         });
         unit.handoffs.push(handoff);
         saveTasks();
+        // Bridge → Agora: announce handoff
+        emitAgoraEvent('evidence_handed_off', args.task_id, `Evidence ${args.packet_id} handed off from researcher to ${args.to_role}.`);
         return {
             content: [{
                     type: "text",
@@ -506,6 +631,11 @@ server.tool("complete_task", "[OPERATOR] Close the task unit with final status a
     });
     unit.completion = completion;
     saveTasks();
+    // Bridge → Agora: announce task completion
+    emitAgoraEvent('task_completed', args.task_id, `Status: ${completion.status}. Agents: ${completion.metrics.agentCount}, ` +
+        `Duration: ${completion.metrics.totalDuration}s, ` +
+        `Rework cycles: ${completion.metrics.reworkCount}. ` +
+        (args.retrospective || ''));
     return {
         content: [{
                 type: "text",
@@ -587,6 +717,8 @@ server.tool("submit_evidence", "[RESEARCHER] Submit research evidence as a signe
     });
     unit.evidencePackets.push(packet);
     saveTasks();
+    // Bridge → Agora: announce evidence submission
+    emitAgoraEvent('evidence_submitted', args.task_id, `Evidence packet with ${packet.metadata.totalClaims} claims (${packet.metadata.citedClaims} cited, ${packet.metadata.gapCount} gaps).`);
     return {
         content: [{
                 type: "text",
@@ -670,6 +802,8 @@ server.tool("submit_deliverable", "[ANALYST/BUILDER] Submit your final output ti
     });
     unit.deliverables.push(deliverable);
     saveTasks();
+    // Bridge → Agora: announce deliverable
+    emitAgoraEvent('deliverable_submitted', args.task_id, `Deliverable for spec ${args.spec_id} submitted by ${state.agentRole || 'agent'} with ${args.citation_count} citations.`);
     return {
         content: [{
                 type: "text",
@@ -922,6 +1056,7 @@ server.tool("post_agora_message", "Post a signed message to the Agora feed. Anyo
         replyTo: args.reply_to,
     });
     state.agoraFeed = appendToFeed(state.agoraFeed, message);
+    persistAgoraFeed();
     return {
         content: [{
                 type: "text",
@@ -1013,6 +1148,131 @@ server.tool("register_agora_agent", "Register an agent in the Agora so their mes
     };
 });
 // ═══════════════════════════════════════
+// COMMS TOOLS (Agent-to-Agent Communication)
+// ═══════════════════════════════════════
+server.tool("send_message", "Send a signed message to another agent. Message is written to comms/to-{agent}.json.", {
+    to: z.string().describe("Recipient agent name (e.g., 'aeoess', 'portalx2', 'claude')"),
+    subject: z.string().describe("Message subject"),
+    message: z.string().describe("Message body"),
+    type: z.string().optional().describe("Message type (default: 'message')"),
+    priority: z.string().optional().describe("Priority: low, normal, high, critical"),
+    data: z.record(z.unknown()).optional().describe("Structured data payload"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }] };
+    const fromName = getAgentName();
+    const toFile = join(COMMS_PATH, `to-${args.to}.json`);
+    const fromFile = join(COMMS_PATH, `from-${fromName}.json`);
+    const msg = {
+        id: `msg-${fromName}-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        from: state.agentId || fromName,
+        to: args.to,
+        type: args.type || 'message',
+        priority: args.priority || 'normal',
+        subject: args.subject,
+        message: args.message,
+        data: args.data || {},
+        signature: await signMessage(args.subject + args.message),
+    };
+    // Write to recipient's inbox
+    const inbox = readCommsFile(toFile);
+    inbox.push(msg);
+    writeCommsFile(toFile, inbox);
+    // Write to sender's outbox
+    const outbox = readCommsFile(fromFile);
+    outbox.push(msg);
+    writeCommsFile(fromFile, outbox);
+    return {
+        content: [{ type: "text", text: JSON.stringify({
+                    sent: true, id: msg.id, to: args.to, subject: args.subject,
+                }, null, 2) }],
+    };
+});
+server.tool("check_messages", "Check messages addressed to you. Reads from comms/to-{your-agent-name}.json.", {
+    unprocessed_only: z.boolean().optional().describe("Only show unprocessed messages (default: true)"),
+    mark_read: z.boolean().optional().describe("Mark returned messages as processed (default: false)"),
+}, async (args) => {
+    const name = getAgentName();
+    const filePath = join(COMMS_PATH, `to-${name}.json`);
+    let messages = readCommsFile(filePath);
+    const unprocessedOnly = args.unprocessed_only !== false;
+    if (unprocessedOnly) {
+        messages = messages.filter(m => !m.processed);
+    }
+    if (args.mark_read && messages.length > 0) {
+        const all = readCommsFile(filePath);
+        const ids = new Set(messages.map(m => m.id));
+        for (const m of all) {
+            if (ids.has(m.id))
+                m.processed = true;
+        }
+        writeCommsFile(filePath, all);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({
+                    agent: name, count: messages.length,
+                    messages: messages.map(m => ({
+                        id: m.id, from: m.from, subject: m.subject,
+                        priority: m.priority, timestamp: m.timestamp,
+                        message: m.message, data: m.data,
+                    })),
+                }, null, 2) }],
+    };
+});
+server.tool("broadcast", "Send a signed message to all agents via comms/broadcast.json.", {
+    subject: z.string().describe("Message subject"),
+    message: z.string().describe("Message body"),
+    type: z.string().optional().describe("Message type (default: 'broadcast')"),
+    priority: z.string().optional().describe("Priority: low, normal, high, critical"),
+    data: z.record(z.unknown()).optional().describe("Structured data payload"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }] };
+    const fromName = getAgentName();
+    const broadcastFile = join(COMMS_PATH, 'broadcast.json');
+    const msg = {
+        id: `bcast-${fromName}-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        from: state.agentId || fromName,
+        to: 'all',
+        type: args.type || 'broadcast',
+        priority: args.priority || 'normal',
+        subject: args.subject,
+        message: args.message,
+        data: args.data || {},
+        signature: await signMessage(args.subject + args.message),
+    };
+    const broadcasts = readCommsFile(broadcastFile);
+    broadcasts.push(msg);
+    writeCommsFile(broadcastFile, broadcasts);
+    return {
+        content: [{ type: "text", text: JSON.stringify({
+                    broadcast: true, id: msg.id, subject: args.subject,
+                }, null, 2) }],
+    };
+});
+server.tool("list_agents", "List registered agents from the agent registry (agora/agents.json).", {
+    status_filter: z.string().optional().describe("Filter by status: active, pending, retired (default: all)"),
+}, async (args) => {
+    let agents = loadAgentsRegistry();
+    if (args.status_filter) {
+        agents = agents.filter(a => a.status === args.status_filter);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({
+                    count: agents.length,
+                    agents: agents.map(a => ({
+                        agentId: a.agentId, name: a.agentName,
+                        status: a.status, role: a.role,
+                        runtime: a.runtime, capabilities: a.capabilities,
+                    })),
+                }, null, 2) }],
+    };
+});
+// ═══════════════════════════════════════
 // VALUES / POLICY TOOLS (Layer 2 + 5)
 // ═══════════════════════════════════════
 server.tool("load_values_floor", "Load a Values Floor from YAML. Sets the floor principles for policy evaluation.", {
@@ -1434,13 +1694,14 @@ server.prompt("coordination_role", "Get instructions for your assigned coordinat
 // ═══════════════════════════════════════
 async function main() {
     loadTasks();
+    loadAgoraFeed();
     const roleInfo = state.agentRole
         ? ` | Role: ${state.agentRole}`
         : ' | No role (call identify or set AGENT_KEY)';
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error(`Agent Passport MCP Server v2.0 running${roleInfo}`);
-    console.error(`Tasks loaded: ${state.taskUnits.size}`);
+    console.error(`Tasks loaded: ${state.taskUnits.size} | Agora messages: ${state.agoraFeed.messages.length}`);
 }
 main().catch((error) => {
     console.error("Fatal error:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-passport-system-mcp",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "MCP server for Agent Passport System — cryptographic identity, delegation, governance, and deliberation for AI agents",
   "type": "module",
   "bin": {
@@ -12,7 +12,9 @@
   "scripts": {
     "build": "tsc && chmod 755 build/index.js",
     "watch": "tsc --watch",
-    "inspector": "npx @modelcontextprotocol/inspector build/index.js"
+    "inspector": "npx @modelcontextprotocol/inspector build/index.js",
+    "prepublishOnly": "npm run build",
+    "postpublish": "cd ~/aeoess_web && node scripts/propagate.mjs --apply --commit 2>/dev/null || echo 'Propagation skipped (aeoess_web not found)'"
   },
   "keywords": [
     "mcp",