@askmesh/mcp 0.10.4 → 0.10.5

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.5',
 });
 if (!TOKEN) {
     // No token — start in setup-only mode

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) {
@@ -107,23 +108,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) {
@@ -247,7 +264,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.5';
 async function checkUpdateAndSetup() {
     const lines = [];
     lines.push(`Version actuelle : ${CURRENT_VERSION}`);
@@ -279,6 +296,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');
@@ -379,33 +404,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 (settings.statusLine?.command === stableScript) {
-                statusLineStatus = 'Status line : déjà configurée';
+            if (existsSync(projectSettingsPath)) {
+                settings = JSON.parse(readFileSync(projectSettingsPath, 'utf-8'));
             }
-            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.5",
   "description": "AskMesh MCP server — connect your AI coding agent to your team's mesh network",
   "type": "module",
   "bin": {

package/statusline.sh

@@ -1,25 +1,37 @@
 #!/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
 
-# 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)
+  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)
+    pending=$((pending + p))
+    active=$((active + a))
+    replies=$((replies + r))
+  done
+fi
 
 parts=()