@way_marks/server 4.4.2 → 4.4.4

package/README.md

@@ -52,6 +52,7 @@ All endpoints are served by `dist/api/server.js` on port 3001.
 | `POST` | `/api/slack/interact` | Slack interactive component handler (approve/reject from Slack message buttons). |
 | `GET` | `/api/sessions` | List all session IDs that have logged actions. |
 | `GET` | `/api/config` | Return the current parsed `waymark.config.json` for the active project. |
+| `GET` | `/api/version` | Return version information: `{ currentVersion, latestVersion, updateAvailable }`. Checks npm registry with 24-hour cache. Used by dashboard VersionBanner for update notifications. |
 | `GET` | `*` | Catch-all — serves the dashboard `index.html`. |
 
 ---

package/dist/api/server.js

@@ -49,6 +49,7 @@ const manager_3 = require("../escalation/manager");
 const events_1 = require("./events");
 const multi_collector_1 = require("../collectors/multi-collector");
 const agent_monitor_1 = require("./routes/agent-monitor");
+const version_1 = require("../services/version");
 // Import registry for Phase 2 hub navigation
 const registryPath = path.join(process.env.HOME || process.env.USERPROFILE || '', '.waymark', 'registry.json');
 function getRegistryProjects() {
@@ -540,6 +541,16 @@ app.get('/api/project', (_req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+// GET /api/version — returns version information
+app.get('/api/version', async (req, res) => {
+    try {
+        const versionInfo = await (0, version_1.getVersionInfo)();
+        res.json(versionInfo);
+    }
+    catch (err) {
+        res.status(500).json({ error: 'Failed to check version', status: 500 });
+    }
+});
 // GET /api/hub/projects — Phase 2: returns all registered projects (optional hub feature)
 app.get('/api/hub/projects', (req, res) => {
     try {

package/dist/services/version.js

@@ -0,0 +1,213 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setProjectRoot = setProjectRoot;
+exports.resetState = resetState;
+exports.getVersionInfo = getVersionInfo;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const NPM_TIMEOUT_MS = 5000; // 5 seconds
+const CACHE_FILE_NAME = 'version-cache.json';
+let projectRoot = process.env.WAYMARK_PROJECT_ROOT || process.cwd();
+function setProjectRoot(root) {
+    projectRoot = root;
+}
+function getCachePath() {
+    return path.join(projectRoot, '.waymark', CACHE_FILE_NAME);
+}
+function readCacheFile() {
+    const cachePath = getCachePath();
+    try {
+        if (!fs.existsSync(cachePath)) {
+            return null;
+        }
+        const content = fs.readFileSync(cachePath, 'utf-8');
+        const data = JSON.parse(content);
+        // Validate cache structure
+        if (!data.latestVersion || typeof data.timestamp !== 'number') {
+            return null;
+        }
+        return data;
+    }
+    catch (error) {
+        // Ignore any read/parse errors
+        return null;
+    }
+}
+function writeCacheFile(latestVersion) {
+    const cachePath = getCachePath();
+    const cacheDir = path.dirname(cachePath);
+    try {
+        // Ensure directory exists
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        const data = {
+            latestVersion,
+            timestamp: Date.now(),
+        };
+        fs.writeFileSync(cachePath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (error) {
+        // Silently ignore write errors
+    }
+}
+function isCacheValid(cache) {
+    const age = Date.now() - cache.timestamp;
+    return age < CACHE_TTL_MS;
+}
+function compareVersions(current, latest) {
+    try {
+        const currentParts = current.split('.').map(Number);
+        const latestParts = latest.split('.').map(Number);
+        // Pad with zeros if needed
+        const maxLength = Math.max(currentParts.length, latestParts.length);
+        while (currentParts.length < maxLength)
+            currentParts.push(0);
+        while (latestParts.length < maxLength)
+            latestParts.push(0);
+        // Compare parts
+        for (let i = 0; i < maxLength; i++) {
+            if (latestParts[i] > currentParts[i]) {
+                return true;
+            }
+            if (latestParts[i] < currentParts[i]) {
+                return false;
+            }
+        }
+        return false; // Versions are equal
+    }
+    catch (error) {
+        // If comparison fails, assume no update
+        return false;
+    }
+}
+async function fetchLatestVersionFromNpm() {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), NPM_TIMEOUT_MS);
+        const response = await fetch('https://registry.npmjs.org/@way_marks/cli/latest', {
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return null;
+        }
+        const data = (await response.json());
+        if (!data.version || typeof data.version !== 'string') {
+            return null;
+        }
+        return data.version;
+    }
+    catch (error) {
+        // Ignore any fetch errors (timeout, network, etc.)
+        return null;
+    }
+}
+function getCurrentVersion() {
+    try {
+        const cliPackageJsonPath = path.join(projectRoot, 'packages', 'cli', 'package.json');
+        if (!fs.existsSync(cliPackageJsonPath)) {
+            return '0.0.0';
+        }
+        const content = fs.readFileSync(cliPackageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(content);
+        return packageJson.version || '0.0.0';
+    }
+    catch (error) {
+        return '0.0.0';
+    }
+}
+let lastFetchPromise = null;
+let lastFetchTime = 0;
+function resetState() {
+    lastFetchPromise = null;
+    lastFetchTime = 0;
+}
+async function getVersionInfo() {
+    const currentVersion = getCurrentVersion();
+    // Check cache first
+    const cache = readCacheFile();
+    if (cache && isCacheValid(cache)) {
+        return {
+            currentVersion,
+            latestVersion: cache.latestVersion,
+            updateAvailable: compareVersions(currentVersion, cache.latestVersion),
+        };
+    }
+    // Prevent multiple concurrent fetches within a short window
+    const now = Date.now();
+    const timeSinceLastFetch = now - lastFetchTime;
+    if (lastFetchPromise && timeSinceLastFetch < 1000) {
+        // Return the pending fetch result
+        const latestVersion = await lastFetchPromise;
+        if (latestVersion) {
+            writeCacheFile(latestVersion);
+            return {
+                currentVersion,
+                latestVersion,
+                updateAvailable: compareVersions(currentVersion, latestVersion),
+            };
+        }
+    }
+    // Fetch from npm
+    lastFetchTime = now;
+    lastFetchPromise = fetchLatestVersionFromNpm();
+    const latestVersion = await lastFetchPromise;
+    if (latestVersion) {
+        // Successfully fetched, cache it
+        writeCacheFile(latestVersion);
+        return {
+            currentVersion,
+            latestVersion,
+            updateAvailable: compareVersions(currentVersion, latestVersion),
+        };
+    }
+    // Fetch failed, try to use existing cache
+    if (cache) {
+        return {
+            currentVersion,
+            latestVersion: cache.latestVersion,
+            updateAvailable: compareVersions(currentVersion, cache.latestVersion),
+        };
+    }
+    // No cache available, return current version as fallback
+    return {
+        currentVersion,
+        latestVersion: currentVersion,
+        updateAvailable: false,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@way_marks/server",
-  "version": "4.4.2",
+  "version": "4.4.4",
   "description": "Waymark MCP server and dashboard",
   "author": "Waymark <hello@waymarks.dev>",
   "license": "MIT",