genexus-mcp 2.8.2 → 2.8.4

package/cli/lib/update-check.js

@@ -2,18 +2,18 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const https = require('https');
+const { spawn } = require('child_process');
 const {
     getGatewayExePath,
-    getClientConfigTargets,
-    filterClientTargets,
-    readClientCommandEntry,
+    clientsStatus,
     normalizeExePath
 } = require('./config');
 
 const REPO = 'lennix1337/Genexus18MCP';
 const NPM_PACKAGE = 'genexus-mcp';
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-const FETCH_TIMEOUT_MS = 2000;
+const FETCH_TIMEOUT_MS = 2500;
+const INSTALL_ONE_LINER = 'iex (irm https://raw.githubusercontent.com/lennix1337/Genexus18MCP/main/scripts/install.ps1)';
 
 function getPackageVersion() {
     try {
@@ -25,9 +25,21 @@ function getPackageVersion() {
 }
 
 function getCacheFile() {
+    // Share the cache with the gateway (UpdateNotifier.cs) so a check by either
+    // side serves the other. On Windows that's %LOCALAPPDATA%\GenexusMCP; on other
+    // platforms fall back to ~/.genexus-mcp (the gateway is Windows-only).
+    if (process.platform === 'win32') {
+        const base = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+        return path.join(base, 'GenexusMCP', 'update-check.json');
+    }
     return path.join(os.homedir(), '.genexus-mcp', 'update-check.json');
 }
 
+function releaseUrlForVersion(version) {
+    const v = stripV(version);
+    return v ? `https://github.com/${REPO}/releases/tag/v${v}` : null;
+}
+
 function readCache() {
     try {
         const raw = fs.readFileSync(getCacheFile(), 'utf8');
@@ -69,51 +81,62 @@ function compareSemver(a, b) {
     return 0;
 }
 
-function fetchLatestRelease() {
+function httpGetJson(url) {
     return new Promise((resolve) => {
-        const options = {
-            hostname: 'api.github.com',
-            path: `/repos/${REPO}/releases/latest`,
-            method: 'GET',
-            headers: {
-                'User-Agent': `${NPM_PACKAGE}-cli`,
-                'Accept': 'application/vnd.github+json'
-            }
-        };
-
-        const req = https.request(options, (res) => {
-            if (res.statusCode !== 200) {
-                res.resume();
-                resolve(null);
-                return;
-            }
-            let body = '';
-            res.setEncoding('utf8');
-            res.on('data', (chunk) => { body += chunk; });
-            res.on('end', () => {
-                try {
-                    const json = JSON.parse(body);
-                    const tag = stripV(json.tag_name || '');
-                    const url = typeof json.html_url === 'string' ? json.html_url : null;
-                    if (!tag) { resolve(null); return; }
-                    resolve({ latestVersion: tag, releaseUrl: url });
-                } catch {
-                    resolve(null);
-                }
+        let req;
+        try {
+            req = https.request(url, { method: 'GET', headers: { 'User-Agent': `${NPM_PACKAGE}-cli`, Accept: 'application/json' } }, (res) => {
+                if (res.statusCode !== 200) { res.resume(); resolve(null); return; }
+                let body = '';
+                res.setEncoding('utf8');
+                res.on('data', (c) => { body += c; });
+                res.on('end', () => {
+                    try { resolve(JSON.parse(body)); } catch { resolve(null); }
+                });
             });
-        });
-
-        req.on('error', () => resolve(null));
-        req.setTimeout(FETCH_TIMEOUT_MS, () => {
-            req.destroy();
+        } catch {
             resolve(null);
-        });
-
+            return;
+        }
+        req.on('error', () => resolve(null));
+        req.setTimeout(FETCH_TIMEOUT_MS, () => { req.destroy(); resolve(null); });
         req.end();
         if (typeof req.unref === 'function') req.unref();
     });
 }
 
+// Resolve the latest version for a dist-tag channel. Authority is the npm
+// registry — that's exactly what `npm install -g <pkg>@<channel>` resolves, so
+// we never advertise a version npm can't install yet (the GitHub-release-before-
+// npm-publish window) and we work on networks that allow npm but block
+// api.github.com. Falls back to the GitHub releases API only for the default
+// channel. The release URL is derived from the version (no API call needed).
+async function fetchLatestRelease(opts = {}) {
+    const channel = (opts && opts.channel) || 'latest';
+
+    // 1. npm registry dist-tags (lightweight: just the tag → version map).
+    const tags = await httpGetJson(`https://registry.npmjs.org/-/package/${NPM_PACKAGE}/dist-tags`);
+    if (tags && typeof tags === 'object') {
+        const v = stripV(tags[channel] || '');
+        if (v) return { latestVersion: v, releaseUrl: releaseUrlForVersion(v), source: 'npm' };
+        // Channel not found on npm — for non-default channels, that's a definitive "no".
+        if (channel !== 'latest') return null;
+    }
+
+    // 2. GitHub releases fallback (default channel only).
+    if (channel === 'latest') {
+        const rel = await httpGetJson(`https://api.github.com/repos/${REPO}/releases/latest`);
+        if (rel && typeof rel === 'object') {
+            const tag = stripV(rel.tag_name || '');
+            if (tag) {
+                const url = typeof rel.html_url === 'string' ? rel.html_url : releaseUrlForVersion(tag);
+                return { latestVersion: tag, releaseUrl: url, source: 'github' };
+            }
+        }
+    }
+    return null;
+}
+
 function formatBanner(current, latest, releaseUrl) {
     const lines = [
         `[genexus-mcp] update available: v${current} -> v${latest}`,
@@ -155,7 +178,8 @@ function scheduleBackgroundFetch() {
         writeCache({
             checkedAt: Date.now(),
             latestVersion: result.latestVersion,
-            releaseUrl: result.releaseUrl
+            releaseUrl: result.releaseUrl,
+            source: result.source || null
         });
     }).catch(() => {});
 }
@@ -166,21 +190,23 @@ function startBackgroundUpdateCheck(opts) {
     scheduleBackgroundFetch();
 }
 
+// Drift = a client points at a gateway launcher (exe/bat/...) that is NOT this
+// npm package's gateway, so `npm install -g` won't update it. Reuses the
+// broadened command resolution from config.js rather than re-implementing the
+// (formerly .exe-only) match.
 function detectClientExeDrift() {
     try {
         const packageNorm = normalizeExePath(getGatewayExePath());
-        const targets = filterClientTargets(getClientConfigTargets(), { platform: process.platform });
         const mismatches = [];
-        for (const client of targets) {
-            if (!fs.existsSync(client.path)) continue;
-            const entry = readClientCommandEntry(client);
-            if (!entry || !entry.command) continue;
-            const cmd = entry.command;
-            // Skip launchers that resolve via npm at runtime.
-            if (/(^|[\\/])(npx|npx\.cmd|node|node\.exe)$/i.test(cmd) || /[\\/]genexus-mcp(\.cmd)?$/i.test(cmd)) continue;
-            if (!/\.exe$/i.test(cmd)) continue;
+        for (const c of clientsStatus()) {
+            if (!c.registered || !c.command) continue;
+            const cmd = c.command;
+            // npx/node/genexus-mcp shims resolve via npm at runtime — not drift.
+            if (/(^|[\\/])(npx|npx\.cmd|node|node\.exe|genexus-mcp|genexus-mcp\.cmd)$/i.test(cmd)) continue;
+            // Only an explicit-path launcher can "drift" from the package exe.
+            if (!/[\\/]/.test(cmd)) continue;
             if (normalizeExePath(cmd) !== packageNorm) {
-                mismatches.push({ client: client.name, configured: cmd });
+                mismatches.push({ client: c.name, configured: cmd });
             }
         }
         return mismatches;
@@ -189,41 +215,161 @@ function detectClientExeDrift() {
     }
 }
 
-async function handleUpdate(_options, ctx) {
+// How is the gateway actually launched by the registered clients? That decides
+// the right upgrade action (npx@latest auto-updates on restart; npm-global needs
+// `npm i -g`; a fixed exe path needs the installer). Returns the dominant method
+// plus per-method evidence.
+function detectInstallMethod() {
+    // Corporate/fixed-path env override wins — the gateway runs from a pinned exe.
+    if (process.env.GENEXUS_MCP_GATEWAY_EXE) {
+        return { method: 'fixed-path', detail: process.env.GENEXUS_MCP_GATEWAY_EXE, evidence: [] };
+    }
+    const counts = { 'npx-latest': 0, 'npm-global': 0, 'fixed-path': 0 };
+    const evidence = [];
+    try {
+        for (const c of clientsStatus()) {
+            if (!c.registered || !c.command) continue;
+            const cmd = String(c.command);
+            let m;
+            if (/(^|[\\/])npx(\.cmd)?$/i.test(cmd)) m = 'npx-latest';
+            else if (/(^|[\\/])genexus-mcp(\.cmd)?$/i.test(cmd)) m = 'npm-global';
+            else if (/[\\/]/.test(cmd)) m = 'fixed-path';
+            else m = 'npm-global';
+            counts[m] = (counts[m] || 0) + 1;
+            evidence.push({ client: c.name, method: m, command: cmd });
+        }
+    } catch { /* ignore */ }
+    // Pick the most common; default to npx-latest (the recommended/auto path).
+    let method = 'npx-latest';
+    let best = -1;
+    for (const k of Object.keys(counts)) {
+        if (counts[k] > best) { best = counts[k]; method = k; }
+    }
+    if (best <= 0) method = 'npx-latest';
+    return { method, counts, evidence };
+}
+
+// The method-appropriate upgrade plan. `auto` means no manual install step is
+// needed (the npx launcher fetches @latest on the next client start).
+function upgradePlanFor(method, channel) {
+    const tag = channel && channel !== 'latest' ? `@${channel}` : '@latest';
+    if (method === 'npx-latest') {
+        return {
+            method,
+            auto: true,
+            steps: [
+                'Your clients launch via `npx genexus-mcp@latest`, which fetches the newest version on each start.',
+                'Just fully restart your AI client — it will pick up the new version automatically.'
+            ],
+            // --apply busts a stale npx cache so the next spawn is guaranteed fresh.
+            applyCommand: { exe: process.platform === 'win32' ? 'npm.cmd' : 'npm', args: ['cache', 'clean', '--force'] },
+            restartRequired: true
+        };
+    }
+    if (method === 'fixed-path') {
+        return {
+            method,
+            auto: false,
+            steps: [
+                'Your install runs the gateway from a fixed path (corporate install).',
+                `Re-run the installer to update in place: ${INSTALL_ONE_LINER}`,
+                'Then fully restart your AI client.'
+            ],
+            applyCommand: null, // self-stage is a future enhancement; installer is the path
+            restartRequired: true
+        };
+    }
+    // npm-global
+    return {
+        method: 'npm-global',
+        auto: false,
+        steps: [
+            `Run: npm install -g ${NPM_PACKAGE}${tag}`,
+            'Then fully restart your AI client.'
+        ],
+        applyCommand: { exe: process.platform === 'win32' ? 'npm.cmd' : 'npm', args: ['install', '-g', `${NPM_PACKAGE}${tag}`] },
+        restartRequired: true
+    };
+}
+
+function runCommand(exe, args) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(exe, args, { stdio: 'inherit', windowsHide: true });
+        } catch (err) {
+            resolve({ ok: false, code: null, error: err && err.message ? err.message : 'spawn failed' });
+            return;
+        }
+        child.on('error', (err) => resolve({ ok: false, code: null, error: err && err.message ? err.message : 'spawn failed' }));
+        child.on('exit', (code) => resolve({ ok: code === 0, code }));
+    });
+}
+
+async function handleUpdate(options, ctx) {
+    const opts = options || {};
+    const channel = opts.channel || 'latest';
     const current = getPackageVersion();
-    const result = await fetchLatestRelease();
+    const result = await fetchLatestRelease({ channel });
     const mismatches = detectClientExeDrift();
+    const install = detectInstallMethod();
 
     const driftHelp = mismatches.length
-        ? [`WARNING: ${mismatches.length} AI client(s) point at a gateway exe that is NOT this npm package — \`npm install -g ${NPM_PACKAGE}@latest\` will NOT update them. Mismatches: ${mismatches.map((m) => `${m.client} -> ${m.configured}`).join('; ')}. Re-run scripts/install.ps1 (or genexus-mcp init --write-clients) to resync.`]
+        ? [`WARNING: ${mismatches.length} AI client(s) point at a gateway launcher that is NOT this npm package — updating npm will NOT update them. Mismatches: ${mismatches.map((m) => `${m.client} -> ${m.configured}`).join('; ')}. Re-run scripts/install.ps1 (or genexus-mcp clients add) to resync.`]
         : [];
 
     if (!result) {
+        const reason = channel !== 'latest'
+            ? `No '${channel}' version found — the npm dist-tag '${channel}' is absent (or the registry is unreachable).`
+            : 'Could not resolve the latest version (npm registry + GitHub both unreachable). Check connectivity/proxy or retry later.';
         return {
             exitCode: ctx.EXIT_CODES.OK,
             envelope: {
-                ok: {
-                    current,
-                    latest: null,
-                    updateAvailable: false,
-                    fetched: false,
-                    clientDrift: mismatches
-                },
-                help: ['Could not reach GitHub releases API. Check connectivity or retry later.', ...driftHelp]
+                ok: { current, latest: null, channel, updateAvailable: false, fetched: false, installMethod: install.method, clientDrift: mismatches },
+                help: [reason, ...driftHelp]
             }
         };
     }
 
-    writeCache({
-        checkedAt: Date.now(),
-        latestVersion: result.latestVersion,
-        releaseUrl: result.releaseUrl
-    });
+    writeCache({ checkedAt: Date.now(), latestVersion: result.latestVersion, releaseUrl: result.releaseUrl, source: result.source || null });
 
     const updateAvailable = compareSemver(result.latestVersion, current || '0.0.0') > 0;
-    const baseHelp = updateAvailable
-        ? [`Run: npm install -g ${NPM_PACKAGE}@latest`, result.releaseUrl ? `Release: ${result.releaseUrl}` : null].filter(Boolean)
-        : ['Already on latest version.'];
+    const plan = upgradePlanFor(install.method, channel);
+
+    // --apply: actually perform the method-appropriate upgrade.
+    let applied = null;
+    if (opts.apply && updateAvailable) {
+        if (!plan.applyCommand) {
+            applied = { ran: false, reason: 'No automatic apply for this install method; follow the steps above.' };
+        } else if (!opts.yes && (!process.stderr || !process.stderr.isTTY)) {
+            applied = { ran: false, reason: 'Refusing to run an unattended install without --yes (no interactive terminal).' };
+        } else {
+            if (!opts.yes) {
+                ctx.stderr.write(`\n[genexus-mcp update] About to run: ${plan.applyCommand.exe} ${plan.applyCommand.args.join(' ')}\n`);
+            }
+            const proceed = opts.yes ? true : await confirmTty(ctx, 'Proceed?');
+            if (!proceed) {
+                applied = { ran: false, reason: 'Cancelled by user.' };
+            } else {
+                const r = await runCommand(plan.applyCommand.exe, plan.applyCommand.args);
+                applied = { ran: true, ok: r.ok, exitCode: r.code, command: `${plan.applyCommand.exe} ${plan.applyCommand.args.join(' ')}`, error: r.error || null };
+            }
+        }
+    }
+
+    const help = [];
+    if (updateAvailable) {
+        if (plan.auto) help.push('Auto-update path: restart your AI client and it fetches the new version (via npx @latest).');
+        help.push(...plan.steps);
+        if (result.releaseUrl) help.push(`Release notes: ${result.releaseUrl}`);
+        if (!opts.apply && plan.applyCommand) help.push('Or run `genexus-mcp update --apply` to do it now.');
+    } else {
+        help.push(`Already on the latest ${channel} version.`);
+    }
+    if (applied && applied.ran && applied.ok) help.push('Update applied. Fully restart your AI client to load it.');
+    if (applied && applied.ran && !applied.ok) help.push(`Apply command exited non-zero (${applied.exitCode}). ${applied.error || ''}`.trim());
+    if (applied && !applied.ran) help.push(applied.reason);
+    help.push(...driftHelp);
 
     return {
         exitCode: ctx.EXIT_CODES.OK,
@@ -231,21 +377,42 @@ async function handleUpdate(_options, ctx) {
             ok: {
                 current,
                 latest: result.latestVersion,
+                channel,
                 releaseUrl: result.releaseUrl,
                 updateAvailable,
-                installCommand: `npm install -g ${NPM_PACKAGE}@latest`,
+                source: result.source || null,
+                installMethod: install.method,
+                autoUpdates: plan.auto,
+                installCommand: plan.applyCommand ? `${plan.applyCommand.exe} ${plan.applyCommand.args.join(' ')}` : INSTALL_ONE_LINER,
+                applied,
                 fetched: true,
                 clientDrift: mismatches
             },
-            help: [...baseHelp, ...driftHelp]
+            help
         }
     };
 }
 
+function confirmTty(ctx, question) {
+    return new Promise((resolve) => {
+        if (!process.stdin || !process.stdin.isTTY) { resolve(false); return; }
+        const readline = require('readline');
+        const rl = readline.createInterface({ input: process.stdin, output: ctx.stderr });
+        rl.question(`${question} [y/N]: `, (a) => {
+            rl.close();
+            const t = (a || '').trim().toLowerCase();
+            resolve(t === 'y' || t === 'yes');
+        });
+    });
+}
+
 module.exports = {
     startBackgroundUpdateCheck,
     handleUpdate,
     compareSemver,
     parseSemver,
-    getPackageVersion
+    getPackageVersion,
+    detectInstallMethod,
+    upgradePlanFor,
+    fetchLatestRelease
 };