@askmesh/mcp 0.4.2 → 0.6.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.d.ts

@@ -7,4 +7,5 @@ export declare class AutoResponder {
     constructor(client: AskMeshClient);
     setServer(server: Server): void;
     handleRequest(request: IncomingRequest): Promise<void>;
+    private callAnthropicAPI;
 }

package/dist/agent/auto_responder.js

@@ -1,4 +1,11 @@
 import { readLocalContext } from './context_reader.js';
+const SYSTEM_PROMPT = `You are an AI coding agent responding on behalf of a developer through AskMesh.
+You have access to the developer's project context below.
+Use this context to answer accurately and concisely.
+Reference specific files, conventions, or decisions when relevant.
+If the context doesn't contain enough info, say so honestly.
+Answer in the same language as the question.
+Keep responses under 500 words unless more detail is needed.`;
 export class AutoResponder {
     client;
     mcpServer = null;
@@ -14,7 +21,6 @@ export class AutoResponder {
         // Uses the user's existing Claude subscription, no API key needed
         if (this.mcpServer) {
             try {
-                // Include local context in the sampling request
                 const context = readLocalContext();
                 const result = (await this.mcpServer.request({
                     method: 'sampling/createMessage',
@@ -46,7 +52,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;
                 }
@@ -55,7 +61,50 @@ export class AutoResponder {
                 console.error('[AskMesh] MCP sampling not available');
             }
         }
-        // Strategy 2: Manual — question stays pending
+        // Strategy 2: Anthropic API fallback (optional — for standalone/server mode)
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (apiKey) {
+            try {
+                const context = readLocalContext();
+                const answer = await this.callAnthropicAPI(apiKey, request, context);
+                if (answer) {
+                    await this.client.replyToThread(request.id, answer);
+                    console.error(`[AskMesh] Responded to #${request.id} via Anthropic API`);
+                    return;
+                }
+            }
+            catch (err) {
+                console.error('[AskMesh] Anthropic API failed:', err);
+            }
+        }
+        // Strategy 3: Manual — question stays pending
         console.error(`[AskMesh] Question #${request.id} queued — use askmesh(action:"pending") to respond`);
     }
+    async callAnthropicAPI(apiKey, request, context) {
+        const model = process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-20250514';
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: 2048,
+                system: SYSTEM_PROMPT,
+                messages: [
+                    {
+                        role: 'user',
+                        content: `Project context:\n\n${context}\n\n---\n\nQuestion from @${request.fromUsername}:\n${request.question}${request.context ? `\n\nAdditional context: ${request.context}` : ''}`,
+                    },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Anthropic API ${response.status}: ${await response.text()}`);
+        }
+        const data = (await response.json());
+        return data.content?.[0]?.text || null;
+    }
 }

package/dist/client/askmesh_client.d.ts

@@ -57,4 +57,31 @@ 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;
+        }>;
+    }>;
 }

package/dist/client/askmesh_client.js

@@ -81,4 +81,31 @@ 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();
+    }
 }

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,12 +9,15 @@ 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
 - "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', '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)'),
+        requestId: z.number().optional().describe('ID de la requête (pour answer/reply/thread/close)'),
+        message: z.string().optional().describe('Réponse ou contexte à envoyer (pour answer/reply/context)'),
     }, async ({ action, username, question, requestId, message }) => {
         switch (action) {
             case 'ask': {
@@ -29,13 +32,22 @@ Actions:
                     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 +79,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 +94,35 @@ 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 '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.4.2",
+  "version": "0.6.0",
   "description": "AskMesh MCP server — connect your AI coding agent to your team's mesh network",
   "type": "module",
   "bin": {