Publish v3.2.2

Author: philcunliffe

CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.2.2] — 2026-05-20
+
+### Fixed
+
+- The foreground CLI update notice and daemon self-update check now compare
+  versions numerically, so an unpublished local patch release no longer treats
+  an older npm version as newer.
+
 ## [3.2.1] — 2026-05-20
 
 ### Fixed

bin/cli.js

@@ -129,13 +129,13 @@ async function loadSubcommand(name) {
  */
 async function checkForUpdates() {
   try {
-    const [{ readPackageVersion }, { fetchLatestVersion }] = await Promise.all([
+    const [{ readPackageVersion }, { fetchLatestVersion, isNewerVersion }] = await Promise.all([
       import('../src/cli/common.js'),
       import('../src/update.js'),
     ])
     const currentVersion = readPackageVersion()
     const latest = await fetchLatestVersion()
-    if (latest && latest !== currentVersion) {
+    if (latest && isNewerVersion(latest, currentVersion)) {
       process.stderr.write(
         `\x1b[33mA newer version of collectivus is available: ${latest} (current: ${currentVersion})\x1b[0m\n` +
         '\x1b[33mRun \'npm install -g collectivus\' to update\x1b[0m\n'

package.json

@@ -1,6 +1,6 @@
 {
   "name": "collectivus",
-  "version": "3.2.1",
+  "version": "3.2.2",
   "description": "OTLP collector and pass-through LLM proxy",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",

src/update.js

@@ -38,6 +38,30 @@ export async function fetchLatestVersion(options = {}) {
   }
 }
 
+/**
+ * Return whether `candidate` is newer than `current` using the package's
+ * semver-shaped versions. Invalid versions are treated as not newer so a
+ * malformed registry response cannot trigger a bogus update notice.
+ *
+ * @param {string} candidate
+ * @param {string} current
+ * @returns {boolean}
+ */
+export function isNewerVersion(candidate, current) {
+  const next = parseVersion(candidate)
+  const base = parseVersion(current)
+  if (!next || !base) return false
+  for (const key of ['major', 'minor', 'patch']) {
+    const k = /** @type {'major' | 'minor' | 'patch'} */ (key)
+    if (next[k] > base[k]) return true
+    if (next[k] < base[k]) return false
+  }
+  if (next.prerelease === base.prerelease) return false
+  if (!next.prerelease) return Boolean(base.prerelease)
+  if (!base.prerelease) return false
+  return comparePrerelease(next.prerelease, base.prerelease) > 0
+}
+
 /**
  * Whether the running script lives somewhere `npm install -g` can replace.
  *
@@ -116,7 +140,7 @@ export async function selfUpdate(options = {}) {
 
     const currentVersion = readVersion()
     const latest = await fetchLatest()
-    if (!latest || latest === currentVersion) return
+    if (!latest || !isNewerVersion(latest, currentVersion)) return
 
     log.write(`[collectivus] update available: ${currentVersion} -> ${latest}; running npm install -g collectivus@${latest}\n`)
     const installed = await install(latest)
@@ -163,3 +187,45 @@ function defaultRun(command, args, opts) {
     child.once('exit', (code) => resolve(code === null ? -1 : code))
   })
 }
+
+/**
+ * @param {string} value
+ * @returns {{ major: number, minor: number, patch: number, prerelease: string } | undefined}
+ */
+function parseVersion(value) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(value)
+  if (!match) return undefined
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ?? '',
+  }
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+function comparePrerelease(a, b) {
+  const aa = a.split('.')
+  const bb = b.split('.')
+  const len = Math.max(aa.length, bb.length)
+  for (let i = 0; i < len; i++) {
+    const av = aa[i]
+    const bv = bb[i]
+    if (av === undefined) return -1
+    if (bv === undefined) return 1
+    const an = /^\d+$/.test(av) ? Number(av) : undefined
+    const bn = /^\d+$/.test(bv) ? Number(bv) : undefined
+    if (an !== undefined && bn !== undefined) {
+      if (an !== bn) return an - bn
+      continue
+    }
+    if (an !== undefined) return -1
+    if (bn !== undefined) return 1
+    if (av !== bv) return av < bv ? -1 : 1
+  }
+  return 0
+}

test/update.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { canSelfUpdate, fetchLatestVersion, isSupervised, runNpmInstall, selfUpdate } from '../src/update.js'
+import { canSelfUpdate, fetchLatestVersion, isNewerVersion, isSupervised, runNpmInstall, selfUpdate } from '../src/update.js'
 
 /**
  * Minimal stdout/stderr collector.
@@ -73,6 +73,25 @@ describe('fetchLatestVersion', () => {
   })
 })
 
+describe('isNewerVersion', () => {
+  it('compares semver components numerically', () => {
+    expect(isNewerVersion('3.2.0', '3.2.1')).toBe(false)
+    expect(isNewerVersion('3.10.0', '3.2.9')).toBe(true)
+    expect(isNewerVersion('4.0.0', '3.99.99')).toBe(true)
+  })
+
+  it('handles prerelease precedence', () => {
+    expect(isNewerVersion('3.2.1', '3.2.1-beta.1')).toBe(true)
+    expect(isNewerVersion('3.2.1-beta.2', '3.2.1-beta.1')).toBe(true)
+    expect(isNewerVersion('3.2.1-beta.1', '3.2.1')).toBe(false)
+  })
+
+  it('treats invalid versions as not newer', () => {
+    expect(isNewerVersion('latest', '3.2.1')).toBe(false)
+    expect(isNewerVersion('3.2.2', 'current')).toBe(false)
+  })
+})
+
 describe('runNpmInstall', () => {
   it('returns true on exit code 0', async () => {
     /** @type {string[]} */
@@ -140,6 +159,21 @@ describe('selfUpdate', () => {
     expect(installCalls).toBe(0)
   })
 
+  it('does not install when registry returns an older version', async () => {
+    let installCalls = 0
+    const log = memo()
+    const result = await selfUpdate({
+      binPath: installedBinPath,
+      readVersion: () => '3.2.1',
+      fetchLatest: () => Promise.resolve('3.2.0'),
+      install: () => { installCalls++; return Promise.resolve(true) },
+      log,
+    })
+    expect(result).toBeUndefined()
+    expect(installCalls).toBe(0)
+    expect(log.value()).toBe('')
+  })
+
   it('installs and returns the new version when newer', async () => {
     /** @type {string[]} */
     const installedVersions = []