@way_marks/cli 4.4.2 → 4.4.4

package/README.md

@@ -139,6 +139,16 @@ npx @way_marks/cli logs --pending   # Show only pending actions
 npx @way_marks/cli logs --blocked   # Show only blocked actions
 ```
 
+### Version Management
+
+```bash
+npx @way_marks/cli --version     # Check installed version
+npx @way_marks/cli status        # Shows version + update banner if available
+npx @way_marks/cli update        # Install latest version from npm
+```
+
+The CLI automatically checks for updates on startup (non-blocking, 3-second timeout). Results are cached for 24 hours. See the [main README](../../README.md#checking-for-updates) for detailed troubleshooting and update instructions.
+
 ---
 
 ## Slack Notifications

package/dist/commands/status.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = run;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const version_check_1 = require("../utils/version-check");
 async function run() {
     const projectRoot = process.cwd();
     const configPath = path.join(projectRoot, '.waymark', 'config.json');
@@ -70,6 +71,12 @@ async function run() {
         }
     }
     catch { /* not running */ }
+    // Check version (non-blocking)
+    let versionInfo = null;
+    try {
+        versionInfo = await (0, version_check_1.checkVersion)();
+    }
+    catch { /* version check failed, continue anyway */ }
     console.log('Waymark — Project Status');
     console.log('─'.repeat(35));
     console.log(`Project:    ${projectName}`);
@@ -86,4 +93,13 @@ async function run() {
         console.log(`Start with: npx @way_marks/cli start`);
     if (startedAt)
         console.log(`Started:    ${startedAt}`);
+    // Display version info
+    if (versionInfo) {
+        console.log('─'.repeat(35));
+        console.log(`Version:    ${versionInfo.current}`);
+        if (versionInfo.updateAvailable && versionInfo.latest) {
+            console.log(`⚠️  New version ${versionInfo.latest} available!`);
+            console.log(`Update:     npm install -g @way_marks/cli@latest`);
+        }
+    }
 }

package/dist/commands/update.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const child_process_1 = require("child_process");
+const version_check_1 = require("../utils/version-check");
+async function run() {
+    try {
+        const versionInfo = await (0, version_check_1.checkVersion)();
+        if (!versionInfo.updateAvailable || !versionInfo.latest) {
+            console.log(`✓ Already on latest version ${versionInfo.current}`);
+            return;
+        }
+        console.log(`Update available: ${versionInfo.current} → ${versionInfo.latest}`);
+        console.log('Installing @way_marks/cli@latest...');
+        try {
+            (0, child_process_1.execSync)('npm install -g @way_marks/cli@latest', {
+                stdio: 'inherit',
+                timeout: 300000, // 5 minutes
+            });
+            console.log('');
+            console.log('✓ Update complete!');
+            console.log('');
+            console.log('To start using the updated version:');
+            console.log('  • Restart your terminal, or');
+            console.log('  • Run: source ~/.bashrc  (on Linux/macOS)');
+            console.log('  • Run: refreshenv        (on Windows PowerShell)');
+        }
+        catch (err) {
+            console.error('');
+            console.error('✗ npm install failed');
+            if (err instanceof Error) {
+                console.error(`  Error: ${err.message}`);
+            }
+            console.error('');
+            console.error('Try these troubleshooting steps:');
+            console.error('  1. Check npm is installed and working:');
+            console.error('     npm --version');
+            console.error('  2. Try installing again:');
+            console.error('     npm install -g @way_marks/cli@latest');
+            console.error('  3. Check npm permissions:');
+            console.error('     npm config get prefix');
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error('✗ Version check failed');
+        if (err instanceof Error) {
+            console.error(`  Error: ${err.message}`);
+        }
+        console.error('');
+        console.error('Unable to check for updates. This may be a network issue.');
+        console.error('You can manually update with:');
+        console.error('  npm install -g @way_marks/cli@latest');
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const version_check_1 = require("./utils/version-check");
 function getVersion() {
     // dist/index.js → ../package.json (when published or installed globally)
     // dev (ts-node from src/) → ../package.json relative to repo
@@ -28,6 +30,7 @@ function printHelp() {
     console.log('  pause                 Pause a project (keep port allocated)');
     console.log('  resume                Resume a paused project');
     console.log('  status                Show current Waymark status and pending count');
+    console.log('  update                Check for and install the latest version');
     console.log('  logs                  Show recent action log');
     console.log('  agents                List running AI agent sessions');
     console.log('  list                  List all registered Waymark projects');
@@ -53,6 +56,10 @@ if (command === '-h' || command === '--help' || command === 'help' || command ==
     printHelp();
     process.exit(command === undefined ? 0 : 0);
 }
+// Fire off version check asynchronously (non-blocking)
+(0, version_check_1.runVersionCheckAsync)(1000).catch(() => {
+    // Silently ignore any errors from version check
+});
 switch (command) {
     case 'init':
         require('./commands/init').run();
@@ -72,6 +79,9 @@ switch (command) {
     case 'status':
         require('./commands/status').run();
         break;
+    case 'update':
+        require('./commands/update').run();
+        break;
     case 'logs':
         require('./commands/logs').run();
         break;

package/dist/utils/version-check.js

@@ -0,0 +1,201 @@
+"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.checkVersion = checkVersion;
+exports.shouldSkipVersionCheck = shouldSkipVersionCheck;
+exports.printUpdateBanner = printUpdateBanner;
+exports.runVersionCheckAsync = runVersionCheckAsync;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+function getCacheFilePath() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    return path.join(homeDir, '.waymark', 'cli-version-cache.json');
+}
+function readCache() {
+    try {
+        const cacheFile = getCacheFilePath();
+        if (!fs.existsSync(cacheFile))
+            return null;
+        const data = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+        const age = Date.now() - data.checkedAt;
+        if (age > CACHE_TTL_MS)
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(data) {
+    try {
+        const cacheDir = path.dirname(getCacheFilePath());
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        fs.writeFileSync(getCacheFilePath(), JSON.stringify(data), 'utf8');
+    }
+    catch {
+        // Silently fail if we can't write cache
+    }
+}
+function getCurrentVersion() {
+    try {
+        const packageJsonPath = path.join(__dirname, '../../package.json');
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        return pkg.version;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+async function fetchLatestVersion() {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch('https://registry.npmjs.org/@way_marks/cli/latest', {
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data.version || null;
+    }
+    catch {
+        return null;
+    }
+}
+function compareVersions(current, latest) {
+    try {
+        const parseCurrent = current.split('.').map(Number);
+        const parseLatest = latest.split('.').map(Number);
+        for (let i = 0; i < 3; i++) {
+            const curr = parseCurrent[i] || 0;
+            const latestVal = parseLatest[i] || 0;
+            if (latestVal > curr)
+                return true;
+            if (curr > latestVal)
+                return false;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkVersion() {
+    const current = getCurrentVersion();
+    // Try to use cache first
+    const cached = readCache();
+    if (cached && cached.current === current) {
+        return {
+            current: cached.current,
+            latest: cached.latest,
+            updateAvailable: compareVersions(cached.current, cached.latest || ''),
+        };
+    }
+    // Fetch latest version
+    const latest = await fetchLatestVersion();
+    // Write to cache
+    if (latest) {
+        writeCache({
+            current,
+            latest,
+            checkedAt: Date.now(),
+        });
+    }
+    return {
+        current,
+        latest,
+        updateAvailable: latest ? compareVersions(current, latest) : false,
+    };
+}
+function shouldSkipVersionCheck() {
+    // Check environment variable
+    if (process.env.WAYMARK_SKIP_VERSION_CHECK === '1') {
+        return true;
+    }
+    // Check ~/.waymark/config.json
+    try {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        const configPath = path.join(homeDir, '.waymark', 'config.json');
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            if (config.skipVersionCheck === true) {
+                return true;
+            }
+        }
+    }
+    catch {
+        // Ignore errors reading config
+    }
+    // Check .waymarkrc in cwd
+    try {
+        const rcPath = path.join(process.cwd(), '.waymarkrc');
+        if (fs.existsSync(rcPath)) {
+            const config = JSON.parse(fs.readFileSync(rcPath, 'utf8'));
+            if (config.skipVersionCheck === true) {
+                return true;
+            }
+        }
+    }
+    catch {
+        // Ignore errors reading .waymarkrc
+    }
+    return false;
+}
+function printUpdateBanner(current, latest) {
+    const banner = `⚠️  Waymark ${current} → ${latest} available! Run: npx @way_marks/cli update`;
+    console.error(banner);
+}
+async function runVersionCheckAsync(timeoutMs = 1000) {
+    if (shouldSkipVersionCheck()) {
+        return;
+    }
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        // Create a promise that checks the version
+        const checkPromise = checkVersion().finally(() => clearTimeout(timeoutId));
+        const result = await checkPromise;
+        if (result.updateAvailable && result.latest) {
+            printUpdateBanner(result.current, result.latest);
+        }
+    }
+    catch {
+        // Silently fail on any error (including timeout)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@way_marks/cli",
-  "version": "4.4.2",
+  "version": "4.4.4",
   "description": "Control what AI agents can do in your codebase",
   "author": "Waymark <hello@waymarks.dev>",
   "license": "MIT",
@@ -43,7 +43,7 @@
     ]
   },
   "dependencies": {
-    "@way_marks/server": "4.4.2"
+    "@way_marks/server": "4.4.4"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/dist/commands/start.test.js

@@ -1,138 +0,0 @@
-"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 });
-const net = __importStar(require("net"));
-// ─── kebabCase ────────────────────────────────────────────────────────────────
-// We inline kebabCase here because it is not exported from start.ts.
-// This matches the implementation exactly.
-function kebabCase(str) {
-    return str
-        .toLowerCase()
-        .replace(/[\s_]+/g, '-')
-        .replace(/[^a-z0-9-]/g, '')
-        .replace(/-+/g, '-')
-        .replace(/^-|-$/g, '');
-}
-describe('kebabCase', () => {
-    it('lowercases the string', () => {
-        expect(kebabCase('MyProject')).toBe('myproject');
-    });
-    it('replaces spaces with dashes', () => {
-        expect(kebabCase('my project')).toBe('my-project');
-    });
-    it('replaces underscores with dashes', () => {
-        expect(kebabCase('my_project')).toBe('my-project');
-    });
-    it('replaces multiple spaces/underscores with a single dash', () => {
-        expect(kebabCase('my  __project')).toBe('my-project');
-    });
-    it('strips special characters', () => {
-        expect(kebabCase('my@project!')).toBe('myproject');
-    });
-    it('collapses multiple dashes', () => {
-        expect(kebabCase('my---project')).toBe('my-project');
-    });
-    it('strips leading dashes', () => {
-        expect(kebabCase('-my-project')).toBe('my-project');
-    });
-    it('strips trailing dashes', () => {
-        expect(kebabCase('my-project-')).toBe('my-project');
-    });
-    it('handles already clean kebab input', () => {
-        expect(kebabCase('my-project')).toBe('my-project');
-    });
-    it('handles numbers in string', () => {
-        expect(kebabCase('project-v2-api')).toBe('project-v2-api');
-    });
-    it('handles all-special-char input returning empty string', () => {
-        expect(kebabCase('!!!@@@')).toBe('');
-    });
-    it('handles typical project directory names', () => {
-        expect(kebabCase('ecommerce_backend')).toBe('ecommerce-backend');
-        expect(kebabCase('Japan Travel App')).toBe('japan-travel-app');
-        expect(kebabCase('my.project.v2')).toBe('myprojectv2');
-    });
-});
-// ─── findAvailablePort ────────────────────────────────────────────────────────
-function findAvailablePort(preferred) {
-    return new Promise((resolve) => {
-        const server = net.createServer();
-        server.listen(preferred, () => {
-            const port = server.address().port;
-            server.close(() => resolve(port));
-        });
-        server.on('error', () => {
-            // No ceiling in tests — recurse to next port unconditionally
-            resolve(findAvailablePort(preferred + 1));
-        });
-    });
-}
-/** Find a free high port dynamically so tests don't depend on 3001 being free */
-function getFreePort() {
-    return new Promise((resolve) => {
-        const srv = net.createServer();
-        srv.listen(0, () => {
-            const port = srv.address().port;
-            srv.close(() => resolve(port));
-        });
-    });
-}
-describe('findAvailablePort', () => {
-    it('returns the preferred port when it is free', async () => {
-        const free = await getFreePort();
-        const port = await findAvailablePort(free);
-        expect(port).toBe(free);
-    });
-    it('falls back to next port when preferred is in use', async () => {
-        const base = await getFreePort();
-        // Occupy base
-        const blocker = net.createServer();
-        await new Promise(res => blocker.listen(base, res));
-        try {
-            const port = await findAvailablePort(base);
-            expect(port).not.toBe(base);
-            expect(port).toBeGreaterThan(0);
-        }
-        finally {
-            await new Promise(res => blocker.close(() => res()));
-        }
-    });
-    it('returns a number (valid port)', async () => {
-        const free = await getFreePort();
-        const port = await findAvailablePort(free);
-        expect(typeof port).toBe('number');
-        expect(port).toBeGreaterThan(0);
-    });
-});