@thisness.ai/concord-mcp 0.1.2

package/README.md

@@ -0,0 +1,66 @@
+# @thisness.ai/concord-mcp
+
+Wrapper MCP léger pour [Concord](https://codeberg.org/DDS-Genki/Concord-beta).
+Télécharge automatiquement le binaire compilé correspondant à votre
+plateforme depuis Codeberg releases, vérifie sha256, et expose le
+serveur MCP stdio.
+
+## Installation et usage
+
+Pas d'installation préalable. Configurez votre client MCP avec :
+
+```json
+{
+  "mcpServers": {
+    "concord": {
+      "command": "npx",
+      "args": ["-y", "@thisness.ai/concord-mcp@latest"]
+    }
+  }
+}
+```
+
+Au premier lancement, le wrapper télécharge le binaire (~100 MB) depuis
+les [releases Codeberg](https://codeberg.org/DDS-Genki/Concord-beta/releases),
+vérifie son sha256, et le met en cache à `~/.cache/concord-mcp/v<version>/`.
+Les lancements suivants sont instantanés.
+
+## Plateformes supportées
+
+- Linux x64
+- Linux ARM64
+- macOS Apple Silicon (M1+)
+- macOS Intel
+- Windows x64
+
+## Prérequis runtime
+
+Concord lance un service caché Tor pour exposer son endpoint. Installez
+`tor` :
+
+```bash
+# Debian / Ubuntu
+sudo apt install tor
+
+# macOS
+brew install tor
+
+# Windows : WSL2 recommandé pour la phase bêta (voir docs/INSTALL.md du repo)
+```
+
+## Variables d'environnement
+
+- `CONCORD_MCP_CACHE` : override le dossier de cache (défaut `~/.cache/concord-mcp/`).
+- `CONCORD_ROOT` : override le dossier d'état Concord (défaut `~/.concord/`).
+- Voir le binaire `concord` pour les autres variables.
+
+## Doc complète
+
+- [README protocole](https://codeberg.org/DDS-Genki/Concord-beta/src/branch/main/README.md)
+- [docs/INSTALL.md](https://codeberg.org/DDS-Genki/Concord-beta/src/branch/main/docs/INSTALL.md) — install détaillée + modus operandi de test entre deux instances
+- [docs/PROTOCOL.md](https://codeberg.org/DDS-Genki/Concord-beta/src/branch/main/docs/PROTOCOL.md) — vocabulaire, cycles de vie, opcodes
+
+## Licence
+
+Voir [LICENSE](https://codeberg.org/DDS-Genki/Concord-beta/src/branch/main/LICENSE)
+du repo principal (PolyForm Noncommercial 1.0.0).

package/bin/concord-mcp.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// Concord MCP wrapper — détecte plateforme, télécharge le binaire compilé
+// depuis Codeberg releases (compressé gzip), vérifie sha256 du .gz,
+// décompresse vers le cache, puis spawn le binaire en stdio MCP inherit.
+//
+// Cache : ~/.cache/concord-mcp/v<version>/concord[.exe]
+// Source : https://codeberg.org/DDS-Genki/Concord-beta/releases/download/Concord-<ver>/concord-<plat>-v<ver>[.exe].gz
+//
+// Compression gzip choisie pour respecter la limite Codeberg 100 MB par
+// asset (binaire 100-120 MB → 25-45 MB compressé). Décompression native
+// via node:zlib, zéro dépendance.
+
+import { createHash } from 'node:crypto';
+import { createWriteStream, existsSync, mkdirSync, chmodSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { createGunzip } from 'node:zlib';
+import { Readable } from 'node:stream';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const pkgPath = join(__dirname, '..', 'package.json');
+const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+const VERSION = pkg.version;
+
+const REPO_BASE = 'https://codeberg.org/DDS-Genki/Concord-beta/releases/download';
+// Codeberg tag format : Concord-X.Y.Z (cohérent avec naming des releases)
+const TAG_PREFIX = 'Concord-';
+
+const PLATFORM_MAP = {
+  'linux-x64': { name: `concord-linux-x64-v${VERSION}`, ext: '' },
+  'linux-arm64': { name: `concord-linux-arm64-v${VERSION}`, ext: '' },
+  'darwin-x64': { name: `concord-darwin-x64-v${VERSION}`, ext: '' },
+  'darwin-arm64': { name: `concord-darwin-arm64-v${VERSION}`, ext: '' },
+  'win32-x64': { name: `concord-windows-x64-v${VERSION}`, ext: '.exe' },
+};
+
+function log(level, msg) {
+  // stderr pour ne pas polluer stdio MCP (stdout)
+  process.stderr.write(`[concord-mcp ${level}] ${msg}\n`);
+}
+
+function detectPlatform() {
+  const key = `${process.platform}-${process.arch}`;
+  const entry = PLATFORM_MAP[key];
+  if (!entry) {
+    log('error', `plateforme non supportée: ${key}. Supportées: ${Object.keys(PLATFORM_MAP).join(', ')}`);
+    process.exit(2);
+  }
+  return entry;
+}
+
+function cacheDir() {
+  const base = process.env['CONCORD_MCP_CACHE'] ?? join(homedir(), '.cache', 'concord-mcp');
+  return join(base, `v${VERSION}`);
+}
+
+async function fetchToFile(url, destPath) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} ${res.statusText} sur ${url}`);
+  }
+  const out = createWriteStream(destPath);
+  await pipeline(res.body, out);
+}
+
+async function fetchText(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} ${res.statusText} sur ${url}`);
+  }
+  return await res.text();
+}
+
+function sha256File(path) {
+  const hash = createHash('sha256');
+  hash.update(readFileSync(path));
+  return hash.digest('hex');
+}
+
+async function ensureBinary() {
+  const { name, ext } = detectPlatform();
+  const dir = cacheDir();
+  const binPath = join(dir, `concord${ext}`);
+  const gzPath = `${binPath}.gz`;
+
+  if (existsSync(binPath)) {
+    return binPath;
+  }
+
+  mkdirSync(dir, { recursive: true });
+
+  const gzAssetName = `${name}${ext}.gz`;
+  const binUrl = `${REPO_BASE}/${TAG_PREFIX}${VERSION}/${gzAssetName}`;
+  const shaUrl = `${REPO_BASE}/${TAG_PREFIX}${VERSION}/${gzAssetName}.sha256`;
+
+  log('info', `download ${gzAssetName} (~25-45MB première fois, mis en cache après décompression)`);
+  log('info', `from ${binUrl}`);
+
+  try {
+    await fetchToFile(binUrl, gzPath);
+  } catch (err) {
+    log('error', `téléchargement échoué: ${err.message}`);
+    log('error', `vérifier que la release Concord-${VERSION} contient ${gzAssetName}`);
+    process.exit(3);
+  }
+
+  // Vérification sha256 sur le .gz (le binaire décompressé sera vérifié implicitement par l'OS au chargement)
+  try {
+    const shaText = await fetchText(shaUrl);
+    const expectedHash = shaText.trim().split(/\s+/)[0];
+    const actualHash = sha256File(gzPath);
+    if (expectedHash !== actualHash) {
+      log('error', `sha256 mismatch sur ${gzAssetName}: attendu ${expectedHash}, obtenu ${actualHash}`);
+      process.exit(4);
+    }
+    log('info', `sha256 OK (${actualHash.slice(0, 12)}...)`);
+  } catch (err) {
+    log('warn', `vérification sha256 échouée: ${err.message}. Archive conservée sans vérification.`);
+  }
+
+  // Décompression .gz → binaire
+  log('info', `décompression gzip vers ${binPath}`);
+  const { createReadStream, unlinkSync } = await import('node:fs');
+  try {
+    await pipeline(createReadStream(gzPath), createGunzip(), createWriteStream(binPath));
+  } catch (err) {
+    log('error', `décompression échouée: ${err.message}`);
+    process.exit(6);
+  }
+
+  // Cleanup .gz une fois décompressé (gain de place cache)
+  try {
+    unlinkSync(gzPath);
+  } catch {
+    // best-effort, pas bloquant
+  }
+
+  // chmod +x sur Unix
+  if (ext !== '.exe') {
+    chmodSync(binPath, 0o755);
+  }
+
+  log('info', `prêt: ${binPath}`);
+  return binPath;
+}
+
+async function main() {
+  const binPath = await ensureBinary();
+
+  // Spawn en stdio inherit (pas-through MCP stdio)
+  const child = spawn(binPath, process.argv.slice(2), {
+    stdio: 'inherit',
+    env: process.env,
+  });
+
+  // Propager signaux (SIGTERM, SIGINT)
+  const forward = (sig) => {
+    if (!child.killed) child.kill(sig);
+  };
+  process.on('SIGTERM', () => forward('SIGTERM'));
+  process.on('SIGINT', () => forward('SIGINT'));
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code ?? 0);
+    }
+  });
+
+  child.on('error', (err) => {
+    log('error', `exec échec: ${err.message}`);
+    process.exit(5);
+  });
+}
+
+main().catch((err) => {
+  log('error', `fatal: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@thisness.ai/concord-mcp",
+  "version": "0.1.2",
+  "description": "Concord MCP — auto-fetch binaire prebuild Codeberg + spawn stdio MCP. Wrapper léger autour de concord-standalone.",
+  "type": "module",
+  "bin": {
+    "concord-mcp": "./bin/concord-mcp.js"
+  },
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://codeberg.org/DDS-Genki/Concord-beta.git",
+    "directory": "apps/mcp-wrapper"
+  },
+  "homepage": "https://codeberg.org/DDS-Genki/Concord-beta",
+  "bugs": "https://codeberg.org/DDS-Genki/Concord-beta/issues",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Andréa Vistoli (Thisness.ai)",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "concord",
+    "thisness",
+    "agent",
+    "framework-to-framework",
+    "tor",
+    "ed25519",
+    "polkadot"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}