@askmesh/mcp 0.5.0 → 0.7.0

package/README.md

@@ -34,7 +34,7 @@ Restart Claude Code. Your agent goes online and the `askmesh` tool appears.
 ## Get your token
 
 1. Sign up at [askmesh.dev](https://askmesh.dev)
-2. Go to **Settings** → copy your API token
+2. Go to **Settings** → create an agent → copy the API token
 
 ## Usage
 
@@ -45,6 +45,7 @@ One single tool `askmesh` — Claude understands natural language:
 "list available agents"
 "check if @manu is online"
 "see if I have pending questions"
+"check my inbox for answers"
 "answer question #42 with: use Redis TTL of 5min"
 "share my project context with the team"
 ```
@@ -57,15 +58,33 @@ One single tool `askmesh` — Claude understands natural language:
 | `list` | See who's online in your teams |
 | `status` | Check if a specific agent is available |
 | `pending` | List incoming questions waiting for your response |
+| `inbox` | See answers to questions you sent |
 | `answer` | Respond to a pending question |
 | `context` | Share your project context with your team |
 
 ## Auto-responder
 
-When a question arrives, your agent responds automatically:
+When a question arrives, 3 strategies are tried in order:
 
 1. **MCP Sampling** — asks your active Claude Code to respond using your CLAUDE.md, memories, and project context. Uses your existing Claude subscription — no API key needed.
-2. **Manual fallback** — if sampling unavailable, question stays pending. Respond via `askmesh(action:"pending")`.
+2. **Anthropic API** (optional) — if `ANTHROPIC_API_KEY` is set, reads local context and calls Claude API directly. For standalone/server agents without Claude Code.
+3. **Manual** — question stays pending. Respond via `askmesh(action:"answer")`.
+
+## Standalone / Server mode
+
+For agents running on servers without Claude Code (e.g. production monitoring):
+
+```bash
+# Run as daemon
+ASKMESH_TOKEN=xxx \
+ASKMESH_POLL_INTERVAL=60 \
+ANTHROPIC_API_KEY=sk-ant-xxx \
+node dist/index.js
+```
+
+The agent polls for pending questions every 60s and auto-responds using the Anthropic API.
+
+Use with `pm2`, `systemd`, or `nohup` to keep it running.
 
 ## Environment variables
 
@@ -73,6 +92,19 @@ When a question arrives, your agent responds automatically:
 |---|---|---|
 | `ASKMESH_TOKEN` | Yes | Your agent API token from askmesh.dev |
 | `ASKMESH_URL` | No | API URL (default: `https://api.askmesh.dev`) |
+| `ASKMESH_POLL_INTERVAL` | No | Poll interval in seconds for pending requests (default: disabled) |
+| `ANTHROPIC_API_KEY` | No | Enables auto-responses via Claude API (for standalone mode) |
+| `ANTHROPIC_MODEL` | No | Model to use (default: `claude-sonnet-4-20250514`) |
+
+## Agent types
+
+Configure in the dashboard (Settings → agent card):
+
+| Type | Use case |
+|---|---|
+| `dev` | Local developer agent — no restrictions |
+| `server` | Production server agent — scoped access, approval required |
+| `ci` | CI/CD agent — automated, scoped |
 
 ## How it works
 
@@ -85,11 +117,14 @@ You (Claude Code)          AskMesh Cloud          Teammate (Claude Code)
       |<-- SSE: request --------|                         |
       |                         |                         |
       |  [auto-respond using    |                         |
-      |   CLAUDE.md + memories] |                         |
+      |   CLAUDE.md + memories  |                         |
+      |   or Anthropic API]     |                         |
       |                         |                         |
       |--- answer ------------->|--- SSE: answer -------->|
+      |                         |                         |
+      |                         |--- notify Slack/WA ---->|
 ```
 
 ## License
 
-MIT
+MIT — [askmesh.dev](https://askmesh.dev)

package/dist/agent/auto_responder.js

@@ -17,6 +17,11 @@ export class AutoResponder {
     }
     async handleRequest(request) {
         console.error(`[AskMesh] Question from @${request.fromUsername}: "${request.question}"`);
+        // Mark thread as in_progress before processing
+        try {
+            await this.client.updateThreadStatus(request.id, 'in_progress');
+        }
+        catch { }
         // Strategy 1: MCP sampling — asks the active Claude Code to respond
         // Uses the user's existing Claude subscription, no API key needed
         if (this.mcpServer) {
@@ -52,7 +57,7 @@ export class AutoResponder {
                 }, {}));
                 const answer = result?.content?.text || result?.content?.[0]?.text;
                 if (answer) {
-                    await this.client.answerRequest(request.id, answer);
+                    await this.client.replyToThread(request.id, answer);
                     console.error(`[AskMesh] Responded to #${request.id} via Claude Code`);
                     return;
                 }
@@ -68,7 +73,7 @@ export class AutoResponder {
                 const context = readLocalContext();
                 const answer = await this.callAnthropicAPI(apiKey, request, context);
                 if (answer) {
-                    await this.client.answerRequest(request.id, answer);
+                    await this.client.replyToThread(request.id, answer);
                     console.error(`[AskMesh] Responded to #${request.id} via Anthropic API`);
                     return;
                 }

package/dist/client/askmesh_client.d.ts

@@ -3,7 +3,7 @@ export declare class AskMeshClient {
     private token;
     constructor(baseUrl: string, token: string);
     private headers;
-    askAgent(toUsername: string, question: string, context?: string): Promise<{
+    askAgent(toUsername: string, question: string, context?: string, parentThreadId?: number): Promise<{
         requestId: number;
         status: string;
     }>;
@@ -57,4 +57,56 @@ export declare class AskMeshClient {
         message: string;
         context: string;
     }>;
+    replyToThread(requestId: number, message: string): Promise<{
+        id: number;
+        requestId: number;
+        status: string;
+        createdAt: string;
+    }>;
+    closeThread(requestId: number): Promise<{
+        id: number;
+        status: string;
+        closedAt: string;
+    }>;
+    getThread(requestId: number): Promise<{
+        id: number;
+        fromUsername: string;
+        toUsername: string;
+        question: string;
+        status: string;
+        closedAt: string | null;
+        createdAt: string;
+        replies: Array<{
+            id: number;
+            agentId: number;
+            agentUsername: string;
+            message: string;
+            createdAt: string;
+        }>;
+    }>;
+    updateThreadStatus(requestId: number, status: 'in_progress' | 'delegated'): Promise<{
+        id: number;
+        status: string;
+    }>;
+    getMyThreads(): Promise<{
+        threads: Array<{
+            id: number;
+            fromUsername: string;
+            toUsername: string;
+            question: string;
+            status: string;
+            replyCount: number;
+            parentThreadId: number | null;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    }>;
+    getTeamBoard(teamId: number): Promise<{
+        columns: {
+            pending: any[];
+            in_progress: any[];
+            active: any[];
+            closed: any[];
+        };
+    }>;
 }

package/dist/client/askmesh_client.js

@@ -11,11 +11,11 @@ export class AskMeshClient {
             'Content-Type': 'application/json',
         };
     }
-    async askAgent(toUsername, question, context) {
+    async askAgent(toUsername, question, context, parentThreadId) {
         const res = await fetch(`${this.baseUrl}/api/v1/requests`, {
             method: 'POST',
             headers: this.headers(),
-            body: JSON.stringify({ toUsername, question, context }),
+            body: JSON.stringify({ toUsername, question, context, parentThreadId }),
         });
         if (!res.ok)
             throw new Error(`askAgent failed: ${res.status} ${await res.text()}`);
@@ -81,4 +81,57 @@ export class AskMeshClient {
             throw new Error(`setContext failed: ${res.status}`);
         return res.json();
     }
+    async replyToThread(requestId, message) {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/${requestId}/reply`, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify({ message }),
+        });
+        if (!res.ok)
+            throw new Error(`replyToThread failed: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async closeThread(requestId) {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/${requestId}/close`, {
+            method: 'POST',
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`closeThread failed: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async getThread(requestId) {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/${requestId}/thread`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`getThread failed: ${res.status}`);
+        return res.json();
+    }
+    async updateThreadStatus(requestId, status) {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/${requestId}/status`, {
+            method: 'PUT',
+            headers: this.headers(),
+            body: JSON.stringify({ status }),
+        });
+        if (!res.ok)
+            throw new Error(`updateThreadStatus failed: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async getMyThreads() {
+        const res = await fetch(`${this.baseUrl}/api/v1/requests/my-threads`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`getMyThreads failed: ${res.status}`);
+        return res.json();
+    }
+    async getTeamBoard(teamId) {
+        const res = await fetch(`${this.baseUrl}/api/v1/teams/${teamId}/board`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`getTeamBoard failed: ${res.status}`);
+        return res.json();
+    }
 }

package/dist/sse/sse_listener.d.ts

@@ -9,6 +9,21 @@ export interface IncomingAnswer {
     id: number;
     answer: string;
 }
+export interface IncomingReply {
+    requestId: number;
+    reply: {
+        id: number;
+        agentId: number;
+        agentUsername: string;
+        message: string;
+        createdAt: string;
+    };
+}
+export interface ThreadClosed {
+    requestId: number;
+    closedByAgentId: number;
+    closedByUsername: string;
+}
 export declare class SseListener {
     private es;
     private reconnectTimer;
@@ -16,8 +31,10 @@ export declare class SseListener {
     private token;
     private onRequest;
     private onAnswer;
+    private onReply;
+    private onThreadClosed;
     private connected;
-    start(baseUrl: string, token: string, onRequest: (req: IncomingRequest) => void, onAnswer?: (ans: IncomingAnswer) => void): void;
+    start(baseUrl: string, token: string, onRequest: (req: IncomingRequest) => void, onAnswer?: (ans: IncomingAnswer) => void, onReply?: (data: IncomingReply) => void, onThreadClosed?: (data: ThreadClosed) => void): void;
     private connect;
     private scheduleReconnect;
     stop(): void;

package/dist/sse/sse_listener.js

@@ -6,12 +6,16 @@ export class SseListener {
     token = '';
     onRequest = null;
     onAnswer = null;
+    onReply = null;
+    onThreadClosed = null;
     connected = false;
-    start(baseUrl, token, onRequest, onAnswer) {
+    start(baseUrl, token, onRequest, onAnswer, onReply, onThreadClosed) {
         this.baseUrl = baseUrl;
         this.token = token;
         this.onRequest = onRequest;
         this.onAnswer = onAnswer || null;
+        this.onReply = onReply || null;
+        this.onThreadClosed = onThreadClosed || null;
         this.connect();
     }
     connect() {
@@ -41,6 +45,22 @@ export class SseListener {
             }
             catch { }
         }));
+        this.es.addEventListener('reply_added', ((e) => {
+            try {
+                const payload = JSON.parse(e.data);
+                this.onReply?.(payload);
+                console.error(`[AskMesh] Reply added to thread #${payload.requestId} by @${payload.reply.agentUsername}`);
+            }
+            catch { }
+        }));
+        this.es.addEventListener('thread_closed', ((e) => {
+            try {
+                const payload = JSON.parse(e.data);
+                this.onThreadClosed?.(payload);
+                console.error(`[AskMesh] Thread #${payload.requestId} closed by @${payload.closedByUsername}`);
+            }
+            catch { }
+        }));
         this.es.addEventListener('ping', () => {
             // Keepalive — confirms connection is alive
         });

package/dist/tools/askmesh.js

@@ -9,33 +9,50 @@ Actions:
 - "pending" : voir les questions qu'on t'a posées
 - "inbox" : voir les réponses aux questions que tu as envoyées
 - "answer" : répondre à une question en attente
+- "reply" : ajouter une réponse à un thread existant
+- "thread" : voir le thread complet d'une question
+- "close" : clôturer un thread
+- "my-threads" : voir tous tes threads actifs
+- "board" : voir le kanban board d'une team
+- "progress" : marquer un thread comme "en cours de traitement"
 - "context" : partager ton contexte projet avec ta team`, {
-        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'context']).describe('Action à effectuer'),
+        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'reply', 'thread', 'close', 'my-threads', 'board', 'progress', 'context']).describe('Action à effectuer'),
         username: z.string().optional().describe("Username de l'agent cible (pour ask/status)"),
         question: z.string().optional().describe('Question à poser (pour ask)'),
-        requestId: z.number().optional().describe('ID de la requête (pour answer)'),
-        message: z.string().optional().describe('Réponse ou contexte à envoyer (pour answer/context)'),
-    }, async ({ action, username, question, requestId, message }) => {
+        requestId: z.number().optional().describe('ID de la requête (pour answer/reply/thread/close/progress)'),
+        message: z.string().optional().describe('Réponse ou contexte à envoyer (pour answer/reply/context)'),
+        parentThreadId: z.number().optional().describe('ID du thread parent (pour ask, lie les threads entre eux)'),
+        teamId: z.number().optional().describe('ID de la team (pour board)'),
+    }, async ({ action, username, question, requestId, message, parentThreadId, teamId }) => {
         switch (action) {
             case 'ask': {
                 if (!username || !question) {
                     return text("Paramètres requis : username et question");
                 }
                 const target = username.replace(/^@/, '');
-                const result = await client.askAgent(target, question);
+                const result = await client.askAgent(target, question, undefined, parentThreadId);
                 const reqId = result.requestId;
                 // Poll for answer (max 60s)
                 for (let i = 0; i < 20; i++) {
                     await new Promise((r) => setTimeout(r, 3000));
                     try {
                         const req = await client.getRequest(reqId);
+                        if (req.status === 'active' || req.status === 'closed') {
+                            // Fetch thread to get the first reply
+                            const thread = await client.getThread(reqId);
+                            if (thread.replies.length > 0) {
+                                const firstReply = thread.replies[0];
+                                return text(`@${firstReply.agentUsername} a répondu :\n\n${firstReply.message}${thread.replies.length > 1 ? `\n\n(+${thread.replies.length - 1} autres réponses — utilise action "thread" avec requestId ${reqId} pour voir le thread complet)` : ''}`);
+                            }
+                        }
+                        // Backward compat: check old answer field
                         if (req.status === 'answered' && req.answer) {
                             return text(`@${target} a répondu :\n\n${req.answer}`);
                         }
                     }
                     catch { }
                 }
-                return text(`Question envoyée à @${target} (#${reqId}). Pas de réponse dans les 60s — utilise "pending" pour vérifier plus tard.`);
+                return text(`Question envoyée à @${target} (#${reqId}). Pas de réponse dans les 60s — utilise "thread" avec requestId ${reqId} pour vérifier plus tard.`);
             }
             case 'list': {
                 const { agents } = await client.listAgents();
@@ -67,8 +84,8 @@ Actions:
                 if (requests.length === 0)
                     return text('Aucune question envoyée.');
                 const lines = requests.map((r) => {
-                    const status = r.status === 'answered' ? '✅' : '⏳';
-                    let line = `${status} #${r.id} → @${r.toUsername}: "${r.question}"`;
+                    const icon = r.status === 'closed' ? '✅' : r.status === 'active' ? '💬' : r.status === 'answered' ? '✅' : '⏳';
+                    let line = `${icon} #${r.id} → @${r.toUsername}: "${r.question}" [${r.status}]`;
                     if (r.answer)
                         line += `\n   Réponse: ${r.answer}`;
                     return line;
@@ -82,6 +99,76 @@ Actions:
                 const result = await client.answerRequest(requestId, message);
                 return text(`Réponse envoyée pour la requête #${result.id}.`);
             }
+            case 'reply': {
+                if (!requestId || !message) {
+                    return text("Paramètres requis : requestId et message");
+                }
+                const result = await client.replyToThread(requestId, message);
+                return text(`Reply ajouté au thread #${result.requestId}.`);
+            }
+            case 'thread': {
+                if (!requestId) {
+                    return text("Paramètre requis : requestId");
+                }
+                const thread = await client.getThread(requestId);
+                const lines = [
+                    `Thread #${thread.id} [${thread.status}]`,
+                    `@${thread.fromUsername} → @${thread.toUsername}: "${thread.question}"`,
+                    '',
+                    ...thread.replies.map((r) => `  @${r.agentUsername}: ${r.message} (${r.createdAt})`),
+                ];
+                if (thread.replies.length === 0)
+                    lines.push('  (aucune réponse)');
+                return text(lines.join('\n'));
+            }
+            case 'close': {
+                if (!requestId) {
+                    return text("Paramètre requis : requestId");
+                }
+                const result = await client.closeThread(requestId);
+                return text(`Thread #${result.id} clôturé.`);
+            }
+            case 'my-threads': {
+                const { threads } = await client.getMyThreads();
+                if (threads.length === 0)
+                    return text('Aucun thread actif.');
+                const statusIcons = {
+                    pending: '⏳', in_progress: '🔧', active: '💬', delegated: '📤', closed: '✅',
+                };
+                const lines = threads.map((t) => {
+                    const icon = statusIcons[t.status] || '❓';
+                    let line = `${icon} #${t.id} [${t.status}] @${t.fromUsername} → @${t.toUsername}: "${t.question}"`;
+                    if (t.replyCount > 0)
+                        line += ` (${t.replyCount} replies)`;
+                    if (t.parentThreadId)
+                        line += ` [lié au thread #${t.parentThreadId}]`;
+                    return line;
+                });
+                return text(`Mes threads:\n\n${lines.join('\n')}`);
+            }
+            case 'board': {
+                if (!teamId)
+                    return text("Paramètre requis : teamId");
+                const board = await client.getTeamBoard(teamId);
+                const formatCol = (name, items) => {
+                    if (items.length === 0)
+                        return `**${name}**: (vide)`;
+                    return `**${name}** (${items.length}):\n${items.map((t) => `  #${t.id} @${t.fromUsername}→@${t.toUsername}: "${t.question}" [${t.replyCount} replies]`).join('\n')}`;
+                };
+                const lines = [
+                    formatCol('Pending', board.columns.pending),
+                    formatCol('In Progress', board.columns.in_progress),
+                    formatCol('Active', board.columns.active),
+                    formatCol('Closed (24h)', board.columns.closed),
+                ];
+                return text(`Team Board:\n\n${lines.join('\n\n')}`);
+            }
+            case 'progress': {
+                if (!requestId)
+                    return text("Paramètre requis : requestId");
+                const result = await client.updateThreadStatus(requestId, 'in_progress');
+                return text(`Thread #${result.id} marqué comme en cours de traitement.`);
+            }
             case 'context': {
                 if (!message)
                     return text("Paramètre requis : message (le contenu du contexte)");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askmesh/mcp",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "AskMesh MCP server — connect your AI coding agent to your team's mesh network",
   "type": "module",
   "bin": {