@askmesh/mcp 0.10.4 → 0.10.7

package/dist/agent/auto_responder.js

@@ -6,7 +6,14 @@ 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.`;
+Keep responses under 500 words unless more detail is needed.
+
+SECURITY RULES:
+- READ-ONLY: Never suggest or execute destructive operations (DELETE, DROP, rm, reset --hard, etc.)
+- NO SECRETS: Never include passwords, API keys, tokens, or credentials in your responses
+- NO SENSITIVE DATA: Never expose personal data, database connection strings, or internal URLs
+- If asked for sensitive information, respond: "I can't share this information via AskMesh for security reasons."
+- You may share: code patterns, architecture decisions, file structures, conventions, public configs`;
 export class AutoResponder {
     client;
     mcpServer = null;

package/dist/index.js

@@ -11,7 +11,7 @@ const TOKEN = process.env.ASKMESH_TOKEN;
 const URL = process.env.ASKMESH_URL || 'https://api.askmesh.dev';
 const server = new McpServer({
     name: 'askmesh',
-    version: '0.10.4',
+    version: '0.10.7',
 });
 if (!TOKEN) {
     // No token — start in setup-only mode

package/dist/statusline/cache.d.ts

@@ -2,6 +2,7 @@ interface StatusCache {
     pending: number;
     active: number;
     unread_replies: number;
+    loop_active: boolean;
     last_update: string;
 }
 /** Call once at startup with the agent token to isolate the cache file per agent */
@@ -13,4 +14,6 @@ export declare function onReplyAdded(): void;
 export declare function onThreadClosed(): void;
 export declare function onPendingFetched(count: number): void;
 export declare function syncFromApi(pending: number, active: number): void;
+export declare function setLoopActive(active: boolean): void;
+export declare function isLoopActive(): boolean;
 export {};

package/dist/statusline/cache.js

@@ -3,7 +3,7 @@ import { createHash } from 'crypto';
 import { tmpdir } from 'os';
 import { join } from 'path';
 let CACHE_FILE = join(tmpdir(), 'askmesh_status.json');
-let cache = { pending: 0, active: 0, unread_replies: 0, last_update: '' };
+let cache = { pending: 0, active: 0, unread_replies: 0, loop_active: false, last_update: '' };
 /** Call once at startup with the agent token to isolate the cache file per agent */
 export function init(token) {
     const hash = createHash('md5').update(token).digest('hex').slice(0, 8);
@@ -25,7 +25,7 @@ export function load() {
         cache = JSON.parse(raw);
     }
     catch {
-        cache = { pending: 0, active: 0, unread_replies: 0, last_update: '' };
+        cache = { pending: 0, active: 0, unread_replies: 0, loop_active: false, last_update: '' };
     }
     return cache;
 }
@@ -58,3 +58,12 @@ export function syncFromApi(pending, active) {
     cache.unread_replies = 0;
     flush();
 }
+export function setLoopActive(active) {
+    load();
+    cache.loop_active = active;
+    flush();
+}
+export function isLoopActive() {
+    load();
+    return cache.loop_active;
+}

package/dist/tools/askmesh.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { mkdirSync, writeFileSync, readFileSync, appendFileSync, existsSync, unlinkSync, copyFileSync, chmodSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { createHash } from 'crypto';
 import { fileURLToPath } from 'url';
 import * as statusCache from '../statusline/cache.js';
 export function registerAskMesh(server, client) {
@@ -34,8 +35,10 @@ Actions disponibles :
 - "broadcast" : envoyer un message à toute ton équipe (notification Telegram/Slack, sans créer de thread)
 - "context" : partager ton contexte projet avec ton équipe
 - "setup" : installer les slash commands (/ask-inbox, /ask-broadcast, etc.) et la status line dans le projet courant
-- "update" : vérifier les mises à jour du MCP, mettre à jour les skills et la status line`, {
-        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'reply', 'thread', 'close', 'my-threads', 'board', 'progress', 'broadcast', 'context', 'setup', 'update']).describe('Action à effectuer'),
+- "update" : vérifier les mises à jour du MCP, mettre à jour les skills et la status line
+- "loop-start" : marquer le loop comme actif (utilisé par /ask-loop)
+- "loop-stop" : arrêter le loop (utilisé par /ask-loop-stop)`, {
+        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'reply', 'thread', 'close', 'my-threads', 'board', 'progress', 'broadcast', 'context', 'setup', 'update', 'loop-start', 'loop-stop']).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/reply/thread/close/progress)'),
@@ -107,23 +110,39 @@ Actions disponibles :
                 const { requests } = await client.getSentRequests();
                 if (requests.length === 0)
                     return text('Aucune question envoyée.');
-                const lines = requests.map((r) => {
-                    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;
-                });
-                return text(`Questions envoyées:\n\n${lines.join('\n\n')}`);
+                // Separate threads with unread replies from the rest
+                const withReply = requests.filter((r) => r.status === 'active' || r.status === 'answered');
+                const pending = requests.filter((r) => r.status === 'pending' || r.status === 'in_progress');
+                const closed = requests.filter((r) => r.status === 'closed');
+                const sections = [];
+                if (withReply.length > 0) {
+                    const lines = withReply.map((r) => {
+                        let line = `🔔 #${r.id} → @${r.toUsername}: "${r.question}"`;
+                        if (r.answer)
+                            line += `\n   Réponse: ${r.answer}`;
+                        line += `\n   → Utilise action "thread" requestId ${r.id} pour voir le fil complet, ou "close" pour clôturer.`;
+                        return line;
+                    });
+                    sections.push(`Réponses à lire (${withReply.length}):\n\n${lines.join('\n\n')}`);
+                }
+                if (pending.length > 0) {
+                    const lines = pending.map((r) => `⏳ #${r.id} → @${r.toUsername}: "${r.question}" [${r.status}]`);
+                    sections.push(`En attente de réponse (${pending.length}):\n${lines.join('\n')}`);
+                }
+                if (closed.length > 0) {
+                    const lines = closed.map((r) => `✅ #${r.id} → @${r.toUsername}: "${r.question}"`);
+                    sections.push(`Terminés (${closed.length}):\n${lines.join('\n')}`);
+                }
+                if (sections.length === 0)
+                    return text('Rien à traiter, tout est à jour.');
+                return text(sections.join('\n\n---\n\n'));
             }
             case 'answer': {
                 if (!requestId || !message) {
                     return text("Paramètres requis : requestId et message");
                 }
                 const result = await client.answerRequest(requestId, message);
-                // Auto-close thread after answering
-                await client.closeThread(requestId).catch(() => { });
-                return text(`Réponse envoyée et thread #${result.id} clôturé.`);
+                return text(`Réponse envoyée au thread #${result.id}. Le demandeur peut consulter la réponse via /ask-inbox.`);
             }
             case 'reply': {
                 if (!requestId || !message) {
@@ -216,8 +235,19 @@ Actions disponibles :
             case 'update': {
                 return await checkUpdateAndSetup();
             }
+            case 'loop-start': {
+                if (statusCache.isLoopActive()) {
+                    return text('Un loop est déjà actif. Utilise /ask-loop-stop pour l\'arrêter avant d\'en lancer un nouveau.');
+                }
+                statusCache.setLoopActive(true);
+                return text('Loop activé. La status line affiche maintenant l\'indicateur "loop".');
+            }
+            case 'loop-stop': {
+                statusCache.setLoopActive(false);
+                return text('Loop arrêté.');
+            }
             default:
-                return text('Action inconnue. Actions disponibles : ask, list, status, pending, answer, context, setup, update');
+                return text('Action inconnue.');
         }
     });
 }
@@ -247,7 +277,7 @@ Si l'utilisateur n'a pas encore de compte, dirige-le vers https://askmesh.dev po
         return text('Action inconnue.');
     });
 }
-const CURRENT_VERSION = '0.10.4';
+const CURRENT_VERSION = '0.10.7';
 async function checkUpdateAndSetup() {
     const lines = [];
     lines.push(`Version actuelle : ${CURRENT_VERSION}`);
@@ -279,6 +309,14 @@ async function checkUpdateAndSetup() {
 function text(t) {
     return { content: [{ type: 'text', text: t }] };
 }
+function readEnvToken(envPath) {
+    if (!existsSync(envPath))
+        return undefined;
+    const content = readFileSync(envPath, 'utf-8');
+    const match = content.match(/ASKMESH_TOKEN=(.+)/);
+    const val = match?.[1]?.trim();
+    return val && val !== 'your_token_here' ? val : undefined;
+}
 function setupSkillsAndStatusLine(token, pollInterval, url) {
     const cwd = process.cwd();
     const commandsDir = join(cwd, '.claude', 'commands');
@@ -294,6 +332,8 @@ function setupSkillsAndStatusLine(token, pollInterval, url) {
         'ask-status.md': `Utilise l'outil MCP askmesh avec l'action "list" pour voir qui est connecté sur le réseau.\n\nAffiche la liste des membres de l'équipe avec leur statut (online/offline) de manière claire et concise.`,
         'ask-setup.md': `Utilise l'outil MCP askmesh avec l'action "setup" pour installer ou mettre à jour la configuration AskMesh dans ce projet.\n\nCela va :\n- Créer ou vérifier le .env avec le token AskMesh\n- Installer les slash commands (/ask-inbox, /ask-broadcast, etc.)\n- Configurer la status line\n- Ajouter .env au .gitignore\n\nSi l'utilisateur fournit un token dans les arguments ($ARGUMENTS), passe-le en paramètre "token".`,
         'ask-update.md': `Utilise l'outil MCP askmesh avec l'action "update" pour vérifier les mises à jour et mettre à jour les skills et la status line.\n\nCela va :\n- Vérifier si une nouvelle version du MCP est disponible sur npm\n- Mettre à jour les slash commands\n- Mettre à jour le script de status line\n\nSi une mise à jour est disponible, indique à l'utilisateur comment l'installer (relancer Claude Code ou npx clear-npx-cache).`,
+        'ask-loop.md': `Lance une boucle de vérification périodique des messages AskMesh.\n\nÉtapes :\n1. D'abord, utilise l'outil MCP askmesh avec l'action "loop-start" pour vérifier qu'aucun loop n'est déjà actif et marquer le loop comme actif\n2. Si le loop-start réussit, lance : /loop <intervalle ou 2m> /ask-inbox\n\nArguments optionnels : $ARGUMENTS (intervalle, ex: "2m", "5m", "30s")\nPar défaut : 2m\n\nSi un loop est déjà actif, préviens l'utilisateur et propose /ask-loop-stop.`,
+        'ask-loop-stop.md': `Arrête la boucle de vérification périodique des messages AskMesh.\n\nÉtapes :\n1. Utilise l'outil MCP askmesh avec l'action "loop-stop" pour marquer le loop comme inactif\n2. Indique à l'utilisateur que le loop est arrêté\n\nNote : cela met à jour la status line pour retirer l'indicateur "loop".`,
     };
     // Create commands directory
     try {
@@ -379,33 +419,49 @@ function setupSkillsAndStatusLine(token, pollInterval, url) {
             gitignoreStatus = '.gitignore : .env ajouté';
         }
     }
-    // Auto-configure status line
-    // Copy statusline.sh to a stable location (~/.claude/) so it survives npx cache clears
+    // Auto-configure status line — per-project, not global
+    // Copy statusline.sh to ~/.claude/ (stable location), configure per-project with agent hash
     const mcpDir = dirname(fileURLToPath(import.meta.url));
     const sourceScript = join(mcpDir, '..', '..', 'statusline.sh');
-    const claudeSettingsDir = join(homedir(), '.claude');
-    const stableScript = join(claudeSettingsDir, 'askmesh-statusline.sh');
-    const claudeSettingsPath = join(claudeSettingsDir, 'settings.json');
+    const globalClaudeDir = join(homedir(), '.claude');
+    const stableScript = join(globalClaudeDir, 'askmesh-statusline.sh');
+    const projectClaudeDir = join(cwd, '.claude');
+    const projectSettingsPath = join(projectClaudeDir, 'settings.local.json');
     let statusLineStatus = '';
+    // Compute token hash for this agent
+    const envToken = token || readEnvToken(envPath);
+    const tokenHash = envToken ? createHash('md5').update(envToken).digest('hex').slice(0, 8) : '';
+    const statusLineCommand = tokenHash
+        ? `${stableScript} ${tokenHash}`
+        : stableScript;
     try {
-        mkdirSync(claudeSettingsDir, { recursive: true });
+        mkdirSync(globalClaudeDir, { recursive: true });
+        mkdirSync(projectClaudeDir, { recursive: true });
         // Copy script to stable location
         if (existsSync(sourceScript)) {
             copyFileSync(sourceScript, stableScript);
             chmodSync(stableScript, 0o755);
         }
         if (existsSync(stableScript)) {
+            // Write to project-level settings (not global)
             let settings = {};
-            if (existsSync(claudeSettingsPath)) {
-                settings = JSON.parse(readFileSync(claudeSettingsPath, 'utf-8'));
+            if (existsSync(projectSettingsPath)) {
+                settings = JSON.parse(readFileSync(projectSettingsPath, 'utf-8'));
             }
-            if (settings.statusLine?.command === stableScript) {
-                statusLineStatus = 'Status line : déjà configurée';
-            }
-            else {
-                settings.statusLine = { type: 'command', command: stableScript };
-                writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2) + '\n');
-                statusLineStatus = 'Status line : configurée automatiquement';
+            settings.statusLine = { type: 'command', command: statusLineCommand };
+            writeFileSync(projectSettingsPath, JSON.stringify(settings, null, 2) + '\n');
+            statusLineStatus = `Status line : configurée pour ce projet${tokenHash ? ` (agent ${tokenHash})` : ''}`;
+            // Clean up global settings if it had the old config
+            const globalSettingsPath = join(globalClaudeDir, 'settings.json');
+            if (existsSync(globalSettingsPath)) {
+                try {
+                    const globalSettings = JSON.parse(readFileSync(globalSettingsPath, 'utf-8'));
+                    if (globalSettings.statusLine?.command?.includes('askmesh')) {
+                        delete globalSettings.statusLine;
+                        writeFileSync(globalSettingsPath, JSON.stringify(globalSettings, null, 2) + '\n');
+                    }
+                }
+                catch { }
             }
         }
         else {

package/package.json

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

package/statusline.sh

@@ -1,28 +1,47 @@
 #!/bin/bash
 # AskMesh status line for Claude Code
-# Reads cached notification counts from MCP server(s)
-# Aggregates across all active agent caches
+# Usage: statusline.sh [token_hash]
+# If token_hash provided, reads only that agent's cache
+# Otherwise reads the single cache file
 
 input=$(cat)
 
 tmpdir="${TMPDIR:-/tmp}"
+hash="$1"
 pending=0
 active=0
 replies=0
+loop="false"
 
-# Aggregate all agent cache files
-for f in "$tmpdir"/askmesh_status_*.json; do
-  [ -f "$f" ] || continue
-  p=$(jq -r '.pending // 0' "$f" 2>/dev/null)
-  a=$(jq -r '.active // 0' "$f" 2>/dev/null)
-  r=$(jq -r '.unread_replies // 0' "$f" 2>/dev/null)
-  pending=$((pending + p))
-  active=$((active + a))
-  replies=$((replies + r))
-done
+if [ -n "$hash" ]; then
+  # Read specific agent cache
+  f="$tmpdir/askmesh_status_${hash}.json"
+  if [ -f "$f" ]; then
+    pending=$(jq -r '.pending // 0' "$f" 2>/dev/null)
+    active=$(jq -r '.active // 0' "$f" 2>/dev/null)
+    replies=$(jq -r '.unread_replies // 0' "$f" 2>/dev/null)
+    loop=$(jq -r '.loop_active // false' "$f" 2>/dev/null)
+  fi
+else
+  # Fallback: aggregate all agent caches
+  for f in "$tmpdir"/askmesh_status_*.json; do
+    [ -f "$f" ] || continue
+    p=$(jq -r '.pending // 0' "$f" 2>/dev/null)
+    a=$(jq -r '.active // 0' "$f" 2>/dev/null)
+    r=$(jq -r '.unread_replies // 0' "$f" 2>/dev/null)
+    l=$(jq -r '.loop_active // false' "$f" 2>/dev/null)
+    pending=$((pending + p))
+    active=$((active + a))
+    replies=$((replies + r))
+    [ "$l" = "true" ] && loop="true"
+  done
+fi
 
 parts=()
 
+if [ "$loop" = "true" ]; then
+  parts+=("\033[35mloop\033[0m")
+fi
 if [ "$pending" -gt 0 ] 2>/dev/null; then
   parts+=("\033[33m${pending} pending\033[0m")
 fi