overmind-mcp 2.8.24 → 2.8.26

package/docs/provider-config-map.md

@@ -5,15 +5,22 @@
 Chaque variable suit cette priorite (la premiere gagne):
 
 ```
-HERMES_HOME/.env  (C:\Users\Deamon\AppData\Local\hermes\.env)
-      ↓
-settings_[agent].json  →  env  (apres interpolation $VAR par process.env)
+process.env  (env du parent, herite par le spawn)
       ↓
 Workflow/.env  (C:\Users\Deamon\Desktop\Backup\Serveur MCP\Workflow\.env)
       ↓
-process.env  (env du parent, herite par le spawn)
+settings_[agent].json  →  env  (apres interpolation $VAR par process.env)
+      ↓
+HERMES_HOME/.env  (C:\Users\Deamon\AppData\Local\hermes\.env)  ← DERNIER MOT
 ```
 
+**Detail du code** (`NousHermesRunner.ts` l.268-456):
+1. `agentCustomEnv = { ...process.env, ...settings.env }` (line 268 puis 384)
+2. Puis lit `overmindHermesSubPath/.env` (le `.hermes/.env` de l'agent) et fait `agentCustomEnv[key] = value` (line 437-456) — ce qui OVERRIDE tout ce qui precede.
+3. Finalement ecrit ce `agentCustomEnv` dans le `.env` final de l'agent (line 722-732) avec dedup sur les cles `*api_key` / `*auth_token`.
+
+Donc le `.hermes/.env` de l'agent a **toujours le dernier mot**. Si tu mets `MINIMAX_API_KEY=*** dans le .hermes/.env, il ecrase `MINIMAX_API_KEY` du process.env et du settings.
+
 **MAIS** pour `OPENROUTER_API_KEY` uniquement:
 - Hermes lit d'abord `HERMES_HOME/.env` puis `os.environ`
 - Si present dans `auth.json` avec status `exhausted` → skip
@@ -108,7 +115,7 @@ Pour qu'un agent utilise le token Y (secondary) au lieu de E (primary), le setti
 | Provider ID | `minimax-cn` | config.yaml ou settings |
 | API Key | `MINIMAX_CN_API_KEY` **uniquement** | `HERMES_HOME/.env` → `os.environ` |
 | Base URL | `https://api.minimaxi.com/anthropic` | hardcoded dans ProviderConfig |
-| Model | `MiniMax-M2.7` | settings `env.ANTHROPIC_MODEL` |
+| Model | `MiniMax-M3` | settings `env.ANTHROPIC_MODEL` |
 
 ```json
 // settings_[agent].json — MiniMax correct
@@ -116,18 +123,42 @@ Pour qu'un agent utilise le token Y (secondary) au lieu de E (primary), le setti
   "env": {
     "ANTHROPIC_AUTH_TOKEN": "$MINIMAX_CN_API_KEY",
     "ANTHROPIC_BASE_URL": "https://api.minimaxi.com/anthropic",
-    "ANTHROPIC_MODEL": "MiniMax-M2.7"
+    "ANTHROPIC_MODEL": "MiniMax-M3"
   }
 }
 ```
 
 ```bash
-# .env minimal pour MiniMax
+# .env minimal pour MiniMax CN
 MINIMAX_CN_API_KEY=ton_token_minimax_ici
 ```
 
 **auth.json** stocke sous `MINIMAX_CN_API_KEY`.
 
+#### MiniMax CN par défaut (convention)
+
+Le préfixe `sk-cp-` est partagé entre MiniMax GLOBAL (`api.minimax.com`) et
+MiniMax CN (`api.minimaxi.com`). L'URL est le seul signal qui disambiguïse.
+Pour les setups où TOUS les tokens MiniMax sont CN (cas le plus commun),
+le runner a un fallback par défaut : quand un token `sk-cp-*` est détecté
+sans URL explicite, on bascule sur CN.
+
+Controlable via env var :
+
+```bash
+# Défaut (recommandé pour les setups CN-only)
+OVERMIND_MINIMAX_DEFAULT=cn      # sk-cp-* sans URL → minimax-cn
+
+# Pour les setups GLOBAL-only
+OVERMIND_MINIMAX_DEFAULT=global  # sk-cp-* sans URL → minimax
+
+# Strict mode (jamais d'inference, URL obligatoire)
+OVERMIND_MINIMAX_DEFAULT=auto    # sk-cp-* sans URL → minimax (no override)
+```
+
+Si une URL explicite est présente dans `ANTHROPIC_BASE_URL`, elle gagne
+toujours sur `OVERMIND_MINIMAX_DEFAULT`.
+
 ---
 
 ### OpenRouter — BANNIR pour LLM
@@ -145,8 +176,63 @@ MINIMAX_CN_API_KEY=ton_token_minimax_ici
 
 ---
 
+## HERMES_HOME resolution (multi-OS, multi-install)
+
+Chaque agent Hermes a son propre HERMES_HOME. Le path est resolu de maniere
+deterministe par `getAgentHermesHome(agentName)` dans `src/lib/config.ts`.
+
+Ordre de resolution (la premiere gagne):
+
+```
+OVERMIND_AGENT_HOME  (env var, set par l'install ou systemd)
+      ↓
+<workspace>/.overmind/hermes/agent_<name>/.hermes  (legacy, si deja existant)
+      ↓
+$HOME/.overmind/hermes/agent_<name>/.hermes                  (Linux/Mac sudo npm -g)
+%LOCALAPPDATA%\overmind\hermes\agent_<name>\.hermes        (Windows npm -g)
+%USERPROFILE%\overmind\hermes\agent_<name>\.hermes         (Windows fallback)
+```
+
+Pour un agent nomme `sniperbot_analyst`:
+- Dev local (workspace = `C:\Users\Deamon\Desktop\Backup\Serveur MCP\Workflow`):
+  `Workflow\.overmind\hermes\agent_sniperbot_analyst\.hermes` (si deja cree)
+- Prod Linux: `~/.overmind/hermes/agent_sniperbot_analyst/.hermes`
+- Prod Windows: `%LOCALAPPDATA%\overmind\hermes\agent_sniperbot_analyst\.hermes`
+
+**Pourquoi c'est important**: avant, le runner Overmind calculait HERMES_HOME
+depuis `process.cwd()`. Si le sniper etait lance depuis `C:\Users\Deamon\Desktop\Backup\Serveur MCP\`
+et le runner depuis `Workflow\`, ils lisaient des `.hermes/.env` differents
+et ecrivaient dans des `auth.json` differents. Maintenant, c'est cwd-independent.
+
+Pour forcer un chemin explicite (ex: deploy Docker), set:
+```bash
+export OVERMIND_AGENT_HOME=/var/lib/overmind/hermes
+```
+
+
 ## Comment Hermes decide quel provider utiliser
 
+Il y a DEUX niveaux de decision:
+
+### Niveau 1: Overmind runner (avant spawn)
+
+`NousHermesRunner.writeAuthJson()` (l.782-918) vote entre 3 signaux pour determiner le `effectiveProvider` qui sera seed dans `auth.json` et le `.env` de l'agent:
+
+1. **Token prefix** (le plus fiable) — `detectTokenProvider()` reconnait:
+   - `sk-cp-...` ou `sk-mm-...` → `minimax`
+   - `32hex.32hex` ou 32-char hex → `zai`
+   - `sk-ant-...` → `anthropic`
+   - `sk-or-...` → `openrouter` (mais BLOQUE pour LLM par la suite)
+   - `sk-...` (autre) → `openai`
+2. **BASE_URL** (tres fiable, plus specifique que le token pour CN vs GLOBAL) — `api.minimaxi.com` → `minimax-cn`, `api.minimax.com` → `minimax`, `api.z.ai/api/coding/paas/v4` → `zai`, `anthropic.com` → `anthropic`, `openai.com` → `openai`.
+3. **ANTHROPIC_PROVIDER** hint du settings (le moins fiable).
+
+**Cas special CN vs GLOBAL**: `sk-cp-` est ambigu entre `minimax` et `minimax-cn` (meme prefix). Si l'URL dit `minimaxi` (avec le `i`), c'est CN. Si `minimax` (sans le `i`), c'est GLOBAL. **L'URL gagne dans ce cas precis** parce qu'elle est la seule a desambiguïser.
+
+### Niveau 2: Hermes upstream (apres spawn)
+
+Hermes relit son `auth.json` + `HERMES_HOME/.env` + `os.environ` avec sa propre logique (dans `hermes_cli/auth.py`):
+
 ```
 1.  Si `provider` explicite dans config.yaml → utilise ce provider
 2.  Sinon si `ANTHROPIC_BASE_URL` contient openrouter → "openrouter"
@@ -156,7 +242,7 @@ MINIMAX_CN_API_KEY=ton_token_minimax_ici
 4.  Sinon fallback: model.default dans config.yaml
 ```
 
-Le model resolve le provider. Donc `ANTHROPIC_MODEL=glm-5.1` sans provider explicite → `zai`. `ANTHROPIC_MODEL=MiniMax-M2.7` → `minimax-cn`.
+**Le runner a deja vote au Niveau 1** — donc ce que tu mets dans `auth.json` (via `writeAuthJson()`) determine ce qu'Hermes verra au Niveau 2. Si le runner a seed `minimax-cn` mais que `config.yaml` dit `provider: minimax`, Hermes va probablement se plaindre. **Garde les deux alignes** ou laisse le runner ecrire le `config.yaml` (ce qu'il fait deja a chaque run).
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overmind-mcp",
-  "version": "2.8.24",
+  "version": "2.8.26",
   "description": "Orchestrateur universel agents IA multi-modeles via MCP. Inclut le protocole 'Custom-Nickname' pour identifier vos agents avec des surnoms originaux (The Chaos Prophet, Shadow Sniper, etc.), l'isolation mémoire (Private Memory Context) et le support pour QwenCli et Nous Hermes. Installation automatique des dépendances Docker (PostgreSQL, pgvector) inclus.",
   "type": "module",
   "main": "dist/index.js",

package/scripts/migrate-hermes-home.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+/**
+ * migrate-hermes-home.js — One-shot migration for HERMES_HOME path change.
+ *
+ * Background: HERMES_HOME was previously computed from process.cwd() which
+ * produced different paths depending on where the runner was launched from.
+ * Starting with Overmind 2.8.27, HERMES_HOME is resolved from
+ * OVERMIND_AGENT_HOME or $HOME/.overmind/hermes/agent_<name>/.hermes.
+ *
+ * This script migrates any existing state from the legacy workspace-relative
+ * paths (e.g. <workflow>/.overmind/hermes/agent_<name>/) to the new canonical
+ * HOME-based path. Safe to run multiple times.
+ *
+ * Usage:  node scripts/migrate-hermes-home.js [--dry-run]
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const args = process.argv.slice(2);
+const dryRun = args.includes('--dry-run');
+
+function log(msg) {
+  process.stdout.write(`[migrate-hermes-home] ${msg}\n`);
+}
+
+function findLegacyBases(workspaceDir) {
+  const legacy = [];
+  for (const sub of ['.overmind/hermes', '.overmind/hermes/agent_*']) {
+    const full = path.join(workspaceDir, sub);
+    if (fs.existsSync(full)) {
+      try {
+        const entries = fs.readdirSync(full, { withFileTypes: true });
+        for (const e of entries) {
+          if (e.isDirectory() && e.name.startsWith('agent_')) {
+            legacy.push(path.join(full, e.name));
+          } else if (e.isDirectory() && e.name === 'central') {
+            legacy.push(path.join(full, e.name));
+          }
+        }
+      } catch { /* ignore */ }
+    }
+  }
+  return legacy;
+}
+
+function getCanonicalBase(platform) {
+  const homeBase = process.env.LOCALAPPDATA
+    || process.env.USERPROFILE
+    || os.homedir();
+  return platform === 'win32'
+    ? path.join(homeBase, 'overmind', 'hermes')
+    : path.join(homeBase, '.overmind', 'hermes');
+}
+
+function migrateOne(src, dst) {
+  // src = legacy agent dir (e.g. <workspace>/.overmind/hermes/agent_foo)
+  // dst = canonical agent dir (e.g. ~/.overmind/hermes/agent_foo)
+  if (fs.existsSync(dst)) {
+    log(`  SKIP: destination already exists: ${dst}`);
+    return false;
+  }
+  if (dryRun) {
+    log(`  DRY-RUN: would move ${src} -> ${dst}`);
+    return true;
+  }
+  // Make parent if missing
+  fs.mkdirSync(path.dirname(dst), { recursive: true });
+  // Use rename for atomicity (works on same-filesystem; cross-fs would need copy+delete)
+  try {
+    fs.renameSync(src, dst);
+    log(`  MOVED: ${src} -> ${dst}`);
+    return true;
+  } catch (e) {
+    if (e.code === 'EXDEV') {
+      // Cross-device: copy + delete
+      log(`  CROSS-FS: copying ${src} -> ${dst}`);
+      copyDirSync(src, dst);
+      fs.rmSync(src, { recursive: true, force: true });
+      return true;
+    }
+    throw e;
+  }
+}
+
+function copyDirSync(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(s, d);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+function main() {
+  const workspaceDir = process.env.OVERMIND_WORKSPACE
+    || process.cwd();
+  const platform = process.platform;
+  const canonicalBase = getCanonicalBase(platform);
+
+  log(`workspace:  ${workspaceDir}`);
+  log(`platform:   ${platform}`);
+  log(`canonical:  ${canonicalBase}`);
+  log(`mode:       ${dryRun ? 'DRY-RUN' : 'LIVE'}`);
+  log('');
+
+  const legacy = findLegacyBases(workspaceDir);
+  if (legacy.length === 0) {
+    log('No legacy .overmind directories found. Nothing to migrate.');
+    return;
+  }
+
+  let moved = 0;
+  for (const src of legacy) {
+    const name = path.basename(src);
+    const dst = path.join(canonicalBase, name);
+    log(`Migrating ${name}:`);
+    if (migrateOne(src, dst)) moved++;
+  }
+
+  log('');
+  log(`Done. ${moved}/${legacy.length} agent directories migrated.`);
+  if (dryRun) {
+    log('Re-run without --dry-run to actually perform the migration.');
+  }
+}
+
+main();