@askmesh/mcp 0.1.0

package/dist/client/askmesh_client.d.ts

@@ -0,0 +1,43 @@
+export declare class AskMeshClient {
+    private baseUrl;
+    private token;
+    constructor(baseUrl: string, token: string);
+    private headers;
+    askAgent(toUsername: string, question: string, context?: string): Promise<{
+        requestId: number;
+        status: string;
+    }>;
+    getPendingRequests(): Promise<{
+        requests: Array<{
+            id: number;
+            fromAgentId: number;
+            question: string;
+            context: string | null;
+            status: string;
+            createdAt: string;
+            expiresAt: string;
+        }>;
+    }>;
+    answerRequest(requestId: number, answer: string): Promise<{
+        id: number;
+        status: string;
+        answeredAt: string;
+    }>;
+    listAgents(): Promise<{
+        agents: Array<{
+            id: number;
+            username: string;
+            status: string;
+            lastSeenAt: string | null;
+        }>;
+    }>;
+    getAgentStatus(username: string): Promise<{
+        username: string;
+        status: string;
+        lastSeenAt: string | null;
+    }>;
+    setContext(context: string): Promise<{
+        message: string;
+        context: string;
+    }>;
+}

package/dist/client/askmesh_client.js

@@ -0,0 +1,68 @@
+export class AskMeshClient {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+        };
+    }
+    async askAgent(toUsername, question, context) {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests`, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify({ toUsername, question, context }),
+        });
+        if (!res.ok)
+            throw new Error(`askAgent failed: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async getPendingRequests() {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/pending`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`getPending failed: ${res.status}`);
+        return res.json();
+    }
+    async answerRequest(requestId, answer) {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/${requestId}/answer`, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify({ answer }),
+        });
+        if (!res.ok)
+            throw new Error(`answerRequest failed: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async listAgents() {
+        const res = await fetch(`${this.baseUrl}/api/v1/agents`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`listAgents failed: ${res.status}`);
+        return res.json();
+    }
+    async getAgentStatus(username) {
+        const res = await fetch(`${this.baseUrl}/api/v1/agents/${username}/status`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`getAgentStatus failed: ${res.status}`);
+        return res.json();
+    }
+    async setContext(context) {
+        const res = await fetch(`${this.baseUrl}/api/v1/agents/context`, {
+            method: 'PUT',
+            headers: this.headers(),
+            body: JSON.stringify({ context }),
+        });
+        if (!res.ok)
+            throw new Error(`setContext failed: ${res.status}`);
+        return res.json();
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { AskMeshClient } from './client/askmesh_client.js';
+import { SseListener } from './sse/sse_listener.js';
+import { registerAskAgent } from './tools/ask_agent.js';
+import { registerListAgents } from './tools/list_agents.js';
+import { registerGetStatus } from './tools/get_status.js';
+import { registerAnswerPending } from './tools/answer_pending.js';
+import { registerSetContext } from './tools/set_context.js';
+const TOKEN = process.env.ASKMESH_TOKEN;
+const URL = process.env.ASKMESH_URL || 'https://api.askmesh.dev';
+if (!TOKEN) {
+    console.error('[AskMesh] ASKMESH_TOKEN is required');
+    process.exit(1);
+}
+const client = new AskMeshClient(URL, TOKEN);
+const server = new McpServer({
+    name: 'askmesh',
+    version: '0.1.0',
+});
+// Register all tools
+registerAskAgent(server, client);
+registerListAgents(server, client);
+registerGetStatus(server, client);
+registerAnswerPending(server, client);
+registerSetContext(server, client);
+// Start SSE listener (marks agent online + receives incoming requests)
+const sse = new SseListener();
+sse.start(URL, TOKEN, (request) => {
+    console.error(`[AskMesh] Incoming request from @${request.fromUsername}: "${request.question}"`);
+});
+// Cleanup on exit
+process.on('SIGINT', () => {
+    sse.stop();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    sse.stop();
+    process.exit(0);
+});
+// Start MCP server via stdio
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/sse/sse_listener.d.ts

@@ -0,0 +1,12 @@
+export interface IncomingRequest {
+    id: number;
+    fromAgentId: number;
+    fromUsername: string;
+    question: string;
+    context: string | null;
+}
+export declare class SseListener {
+    private es;
+    start(baseUrl: string, token: string, onRequest: (req: IncomingRequest) => void): void;
+    stop(): void;
+}

package/dist/sse/sse_listener.js

@@ -0,0 +1,29 @@
+import EventSource from 'eventsource';
+export class SseListener {
+    es = null;
+    start(baseUrl, token, onRequest) {
+        this.es = new EventSource(`${baseUrl}/api/v1/sse/subscribe`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        this.es.addEventListener('request_incoming', ((e) => {
+            try {
+                const payload = JSON.parse(e.data);
+                onRequest(payload);
+            }
+            catch {
+                // ignore parse errors
+            }
+        }));
+        this.es.addEventListener('ping', () => {
+            // keepalive — nothing to do
+        });
+        this.es.onerror = () => {
+            // EventSource handles automatic reconnection
+            console.error('[AskMesh SSE] Connection error — will reconnect');
+        };
+    }
+    stop() {
+        this.es?.close();
+        this.es = null;
+    }
+}

package/dist/tools/answer_pending.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AskMeshClient } from '../client/askmesh_client.js';
+export declare function registerAnswerPending(server: McpServer, client: AskMeshClient): void;

package/dist/tools/answer_pending.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export function registerAnswerPending(server, client) {
+    server.tool('answer_pending', 'Liste les questions en attente ou répond à une question spécifique', {
+        requestId: z
+            .number()
+            .optional()
+            .describe('ID de la requête à laquelle répondre (omit pour lister)'),
+        answer: z.string().optional().describe('Réponse à envoyer (requis si requestId fourni)'),
+    }, async ({ requestId, answer }) => {
+        // Mode listing
+        if (!requestId) {
+            const { requests } = await client.getPendingRequests();
+            if (requests.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'Aucune question en attente.' }],
+                };
+            }
+            const lines = requests.map((r) => `#${r.id} — "${r.question}"${r.context ? ` (contexte: ${r.context})` : ''}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Questions en attente:\n${lines.join('\n')}\n\nUtilise answer_pending avec requestId et answer pour répondre.`,
+                    },
+                ],
+            };
+        }
+        // Mode réponse
+        if (!answer) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: "Le paramètre 'answer' est requis pour répondre à une requête.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const result = await client.answerRequest(requestId, answer);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Réponse envoyée pour la requête #${result.id}\nStatut: ${result.status}`,
+                },
+            ],
+        };
+    });
+}

package/dist/tools/ask_agent.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AskMeshClient } from '../client/askmesh_client.js';
+export declare function registerAskAgent(server: McpServer, client: AskMeshClient): void;

package/dist/tools/ask_agent.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export function registerAskAgent(server, client) {
+    server.tool('ask_agent', 'Pose une question à un agent de ton équipe par son username', {
+        username: z.string().describe("Username de l'agent cible (ex: manu)"),
+        question: z.string().describe('La question à poser'),
+        context: z.string().optional().describe('Contexte additionnel (optionnel)'),
+    }, async ({ username, question, context }) => {
+        const target = username.replace(/^@/, '');
+        const result = await client.askAgent(target, question, context);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Question envoyée à @${target} (request #${result.requestId})\nStatut: ${result.status}`,
+                },
+            ],
+        };
+    });
+}

package/dist/tools/get_status.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AskMeshClient } from '../client/askmesh_client.js';
+export declare function registerGetStatus(server: McpServer, client: AskMeshClient): void;

package/dist/tools/get_status.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export function registerGetStatus(server, client) {
+    server.tool('get_status', "Retourne le statut d'un agent spécifique", {
+        username: z.string().describe("Username de l'agent (ex: manu)"),
+    }, async ({ username }) => {
+        const target = username.replace(/^@/, '');
+        const result = await client.getAgentStatus(target);
+        const status = result.status === 'online' ? '🟢 online' : '⚫ offline';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `@${result.username} — ${status}${result.lastSeenAt ? `\nDernière activité: ${result.lastSeenAt}` : ''}`,
+                },
+            ],
+        };
+    });
+}

package/dist/tools/list_agents.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AskMeshClient } from '../client/askmesh_client.js';
+export declare function registerListAgents(server: McpServer, client: AskMeshClient): void;

package/dist/tools/list_agents.js

@@ -0,0 +1,17 @@
+export function registerListAgents(server, client) {
+    server.tool('list_agents', 'Liste les agents de ton équipe avec leur statut online/offline', {}, async () => {
+        const { agents } = await client.listAgents();
+        if (agents.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'Aucun agent trouvé.' }],
+            };
+        }
+        const lines = agents.map((a) => {
+            const status = a.status === 'online' ? '🟢' : '⚫';
+            return `${status} @${a.username} — ${a.status}`;
+        });
+        return {
+            content: [{ type: 'text', text: lines.join('\n') }],
+        };
+    });
+}

package/dist/tools/set_context.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AskMeshClient } from '../client/askmesh_client.js';
+export declare function registerSetContext(server: McpServer, client: AskMeshClient): void;

package/dist/tools/set_context.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export function registerSetContext(server, client) {
+    server.tool('set_context', 'Partage ton contexte projet (CLAUDE.md) avec les autres agents AskMesh', {
+        context: z
+            .string()
+            .describe('Le contenu de ton contexte projet (ex: contenu de CLAUDE.md)'),
+    }, async ({ context }) => {
+        const result = await client.setContext(context);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Contexte mis à jour (${context.length} caractères).`,
+                },
+            ],
+        };
+    });
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@askmesh/mcp",
+  "version": "0.1.0",
+  "description": "AskMesh MCP server — connect your AI coding agent to your team's mesh network",
+  "type": "module",
+  "bin": {
+    "askmesh-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "tsc"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "ai-agent",
+    "askmesh",
+    "claude-code",
+    "cursor",
+    "windsurf"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mantoine/askmesh",
+    "directory": "apps/mcp"
+  },
+  "homepage": "https://askmesh.dev",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "eventsource": "^2.0.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "~5.6"
+  }
+}