@stratta/mcp 0.9.4 → 0.9.5

package/README.md

@@ -56,6 +56,20 @@ precedence over the saved key):
 claude mcp add stratta --scope user --env STRATTA_API_KEY=sk_strt_xxx -- npx -y @stratta/mcp
 ```
 
+## Staying up to date
+
+`npx -y @stratta/mcp` fetches the published package, but npx caches what it
+resolved, so a server can keep launching a version npm replaced weeks ago with
+nothing to tell you.
+
+```bash
+npx -y @stratta/mcp update
+```
+
+Prints the version you are running and the one npm serves, and fetches the new
+one if they differ. Restart your agent afterwards. The server also mentions it
+on stderr at startup when it notices it is behind.
+
 ### Claude Desktop
 
 Sign in once from a terminal — the desktop app cannot prompt you interactively:

package/dist/index.js

@@ -93,14 +93,31 @@ for (const def of [...readTools, ...dossierTools, ...ingestTools]) {
     (args) => call(def, args));
 }
 async function main() {
-    if (process.argv[2] === 'login') {
+    const command = process.argv[2];
+    if (command === 'login') {
         const { runLogin } = await import('./login.js');
         await runLogin(process.argv.slice(3));
         return;
     }
+    if (command === 'update') {
+        const { runUpdate } = await import('./update.js');
+        await runUpdate(packageVersion());
+        return;
+    }
+    // `--version` because that is what everyone types first, and because
+    // `update` needs a cheap way to make npx materialise a given version.
+    if (command === '--version' || command === '-v' || command === 'version') {
+        console.log(packageVersion());
+        return;
+    }
     await server.connect(new StdioServerTransport());
     // Stderr only; stdout carries the MCP protocol.
     console.error(`[stratta-mcp] v${packageVersion()} listening on stdio`);
+    // After connect, never before: the check reaches the network, and a server
+    // that starts slowly because of a version lookup is a worse problem than an
+    // out-of-date one.
+    const { noticeIfOutdated } = await import('./update.js');
+    noticeIfOutdated(packageVersion());
 }
 main().catch((err) => {
     console.error('[stratta-mcp] fatal:', err);

package/dist/update.d.ts

@@ -0,0 +1,29 @@
+/**
+ * What version npm would serve right now, or null if we could not ask.
+ *
+ * Deliberately quiet about failures: this runs on a path where being offline,
+ * behind a proxy, or on a flaky connection is ordinary, and none of that is
+ * worth an error. A missed check is not a problem; a server that refuses to
+ * start because a version check failed would be.
+ */
+export declare function latestPublished(timeoutMs?: number): Promise<string | null>;
+/** Numeric compare, so 0.9.10 sorts above 0.9.9. */
+export declare function isNewer(candidate: string, current: string): boolean;
+/**
+ * Tell the user, on stderr, when they are running something old.
+ *
+ * Fire-and-forget from `main`: the server is already listening by the time
+ * this resolves, so a slow registry delays nothing. stdout carries the MCP
+ * protocol and must stay clean.
+ */
+export declare function noticeIfOutdated(current: string): void;
+/**
+ * `npx @stratta/mcp update`.
+ *
+ * npx caches a resolved package and reuses it, so `npx -y @stratta/mcp` can
+ * keep launching a version that npm replaced weeks ago — the user has no way
+ * to tell, and nothing tells them. This says which version is running, which
+ * one is published, and clears the cache entry so the next launch fetches the
+ * new one.
+ */
+export declare function runUpdate(current: string): Promise<void>;

package/dist/update.js

@@ -0,0 +1,88 @@
+import { spawnSync } from 'node:child_process';
+const REGISTRY = 'https://registry.npmjs.org/@stratta/mcp/latest';
+/**
+ * What version npm would serve right now, or null if we could not ask.
+ *
+ * Deliberately quiet about failures: this runs on a path where being offline,
+ * behind a proxy, or on a flaky connection is ordinary, and none of that is
+ * worth an error. A missed check is not a problem; a server that refuses to
+ * start because a version check failed would be.
+ */
+export async function latestPublished(timeoutMs = 3000) {
+    try {
+        const res = await fetch(REGISTRY, {
+            signal: AbortSignal.timeout(timeoutMs),
+            headers: { accept: 'application/json' },
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return body.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Numeric compare, so 0.9.10 sorts above 0.9.9. */
+export function isNewer(candidate, current) {
+    const a = candidate.split('.').map(Number);
+    const b = current.split('.').map(Number);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const x = a[i] ?? 0;
+        const y = b[i] ?? 0;
+        if (x !== y)
+            return x > y;
+    }
+    return false;
+}
+/**
+ * Tell the user, on stderr, when they are running something old.
+ *
+ * Fire-and-forget from `main`: the server is already listening by the time
+ * this resolves, so a slow registry delays nothing. stdout carries the MCP
+ * protocol and must stay clean.
+ */
+export function noticeIfOutdated(current) {
+    void latestPublished().then((latest) => {
+        if (!latest || !isNewer(latest, current))
+            return;
+        console.error(`[stratta-mcp] version ${latest} disponible (vous avez ${current}) — ` +
+            `lancez : npx -y @stratta/mcp update`);
+    });
+}
+/**
+ * `npx @stratta/mcp update`.
+ *
+ * npx caches a resolved package and reuses it, so `npx -y @stratta/mcp` can
+ * keep launching a version that npm replaced weeks ago — the user has no way
+ * to tell, and nothing tells them. This says which version is running, which
+ * one is published, and clears the cache entry so the next launch fetches the
+ * new one.
+ */
+export async function runUpdate(current) {
+    console.log(`Version installée : ${current}`);
+    const latest = await latestPublished(8000);
+    if (!latest) {
+        console.log('Impossible de joindre npm. Vérifiez votre connexion et réessayez.');
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`Dernière publiée  : ${latest}`);
+    if (!isNewer(latest, current)) {
+        console.log('\nVous êtes à jour.');
+        return;
+    }
+    console.log('\nRécupération de la nouvelle version…');
+    // `npx -y pkg@version` bypasses whatever npx had cached for the bare name,
+    // and populates the cache with the new one in the same step.
+    const r = spawnSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['-y', `@stratta/mcp@${latest}`, '--version'], { stdio: 'inherit' });
+    if (r.status === 0) {
+        console.log(`\n@stratta/mcp ${latest} est prêt.\n` +
+            'Redémarrez votre agent pour que le serveur reparte sur cette version.');
+    }
+    else {
+        console.log(`\nLa récupération a échoué. À lancer à la main :\n` +
+            `  npx -y @stratta/mcp@${latest}`);
+        process.exitCode = 1;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stratta/mcp",
   "mcpName": "ch.stratta/mcp",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "description": "MCP server exposing the engineering norms your firm is licensed for (SIA / Eurocodes) to any MCP client, via Stratta TreeRAG.",
   "license": "UNLICENSED",
   "author": "SmartFlow <hello@stratta.ch>",