feat(cli): add internal update notifier package - #18502

#!/bin/bash
set -euo pipefail
sed -n '151,165p' utils/update-notifier/src/internal.js

#!/bin/bash
set -euo pipefail

echo "Relevant imports and functions:"
sed -n '1,80p' utils/update-notifier/src/internal.js
sed -n '140,210p' utils/update-notifier/src/internal.js

echo
echo "Search for startBackgroundCheck callers/registrations:"
rg -n "startBackgroundCheck|notifyUpdate|update_notifier|update-notifier" -S .

echo
echo "Node ChildProcess spawn error behavior probe:"
node - <<'JS'
const { spawn } = require('node:child_process')
const events = []
try {
  const child = spawn('this-binary-must-not-exist', ['--arg'], { detached: true, stdio: 'ignore' })
  child.once('error', (err) => events.push({ event: 'error', name: err.name, code: err.code }))
  child.unref()
  setTimeout(() => {
    console.log(JSON.stringify(events))
  }, 100)
} catch (error) {
  console.log(JSON.stringify({ event: 'throw', name: error.name, code: error.code }))
}
JS

#!/bin/bash
set -euo pipefail
sed -n '151,157p' utils/update-notifier/src/internal.js

#!/bin/bash
set -euo pipefail
ast-grep outline utils/update-notifier/src/internal.js --items all --type function
rg -n -C 5 'getCacheFile|npm_config_registry|registry|checkedAt|latest' \
  utils/update-notifier/src/internal.js \
  utils/update-notifier/test/index.test.js

#!/bin/bash
set -euo pipefail

echo '--- internal.js relevant lines ---'
cat -n utils/update-notifier/src/internal.js | sed -n '1,210p'

echo '--- package-specific tests and registry-related occurrences ---'
grep -RIn 'npm_config_registry|registry|dist-tags|latest|getCacheFile|cacheFile' utils/update-notifier -n

echo '--- deterministic cache path and interval behavior probe ---'
node - <<'JS'
import { readFileSync } from 'node:fs';
import vm from 'node:vm';

const code = readFileSync('utils/update-notifier/src/internal.js', 'utf8');

const sandbox = {
  console,
  process: {
    argv: ['node', 'internal.js'],
    once() {},
    stdout: { isTTY: true },
    env: { npm_config_registry: 'https://registry.npmjs.org' },
  },
};
const moduleExports = {};
const fn = vm.compileFunction(code, ['exports'], { filename: 'internal.js' });
fn(moduleExports);

const { getCacheFile, notifyUpdate, startBackgroundCheck, checkForUpdate, isNewerVersion } = moduleExports;

console.log('getCacheFile quasar CLI:', getCacheFile('`@quasar/cli`'));

const base = '/tmp/cache';
const path1 = getCacheFile('`@quasar/cli`');
const base2 = getCacheFile('`@quasar/cli`');
console.log('same getCacheFile path for same package:', path1 === base2);
console.log('same getCacheFile path for different package:', path1 === getCacheFile('`@quasar/other-cli`'));

let requestedUrl, writtenCache, startTime;
vm.modifyGlobal = function() {};
function setupDetachedProbe() {
  const src = code.replace('const backgroundCheckFlag =', 'console.error("started-background-check"); const backgroundCheckFlag =');
  const moduleExports2 = {};
  const fn2 = vm.compileFunction(src, ['exports'], { filename: 'internal.js' });
  fn2(moduleExports2);
  globals = moduleExports2;
  return globals;
}

let requestedUrl2, writtenCache2;
function setupFetchAndSpawnMocks(g) {
  global.fetch = async (url) => Object.assign({}, {
    ok: true,
    json: async () => ({ latest: '9.9.9' }),
  }, { url: url.href });
  g.spawn = (cmd, args, opts) => {
    requestedUrl2 = url;
    return {
      on(event, cb) {},
      unref() {},
    };
  };
  g.writeFile = async (cacheFile, data) => { writtenCache2 = JSON.parse(data); };
  g.readFile = async (cacheFile) => JSON.stringify({ checkedAt: Date.now(), latest: '1.1.1' });
  g.join = (a,b) => `${a}/${b}`;
  g.mkdir = async () => {};
}
const g = setupDetachedProbe();
setupFetchAndSpawnMocks(g);
console.log(g.checkForUpdate({ cacheFile: '/tmp/quasar.json', name: '`@quasar/cli`', version: '1.0.0' }).then(() => JSON.stringify({ requestedUrl2, requestedUrl2: requestedUrl2, writtenCache2, requestedUrl, writtenCache })));
JS

echo '--- no external dependencies in update-notifier js ---'
node - <<'JS'
const fs = require('fs');
const code = fs.readFileSync('utils/update-notifier/src/internal.js','utf8').split('\n').slice(0,22).join('\n');
console.log(code);
console.log('uses fetch:', code.includes('fetch'));
console.log('uses spawn:', code.includes('spawn'));
console.log('uses writeFile:', code.includes('writeFile'));
JS

#!/bin/bash
set -euo pipefail

echo '--- package-specific tests and registry-related occurrences ---'
rg -n -C 3 '-registry|registry|dist-tags|npm_config_registry|cacheFile|getCacheFile|startBackgroundCheck|notifyUpdate|BackgroundCheckFlag|checkForUpdate' utils/update-notifier

echo '--- package-specific cache path behavior ---'
node - <<'JS'
const path = require('path');
const os = require('os');

function getCacheFile(packageName) {
  const cacheDir =
    process.env.XDG_CACHE_HOME ||
    process.env.LOCALAPPDATA ||
    path.join(os.homedir(), '.cache')
  return path.join(cacheDir, 'quasar', 'update-notifier', `${encodeURIComponent(packageName)}.json`)
}

console.log('getCacheFile `@quasar/cli`:', getCacheFile('`@quasar/cli`'));
console.log('getCacheFile `@quasar/other`:', getCacheFile('`@quasar/other`'));
console.log('getCacheFile quasar/cli:', getCacheFile('quasar/cli'));
console.log('normalizedRegistry from URL pathname:', JSON.stringify([
  { input: 'https://registry.npmjs.org', pathname: new URL('https://registry.npmjs.org').pathname },
  { input: 'https://registry.npmjs.org/', pathname: new URL('https://registry.npmjs.org/').pathname },
]));
JS

echo '--- deterministic registry reuse scenario ---'
cat > /tmp/update-notifier-reg-scoped-probe.mjs <<'JS'
import { pathToFileURL } from 'node:url';
import { readFileSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

const cacheRoot = join(tmpdir(), `quasar-update-notifier-registry-probe-${process.pid}`);
let requestedUrls = [];
let writtenCaches = [];

// Inline stable implementation from utils/update-notifier/src/internal.js without module dependencies.
function dirname(p) { return p.slice(0, Math.max(0, p.lastIndexOf('/'))) }
function getCacheFile(packageName) {
  return join(cacheRoot, 'update-notifier', `${encodeURIComponent(packageName)}.json`)
}
function readCache(cacheFile) {
  try {
    return JSON.parse(readFileSync(cacheFile, 'utf8'))
  } catch {
    return void 0
  }
}
function writeCache(cacheFile, value) {
  mkdirSync(dirname(cacheFile), { recursive: true })
  writeFileSync(cacheFile, JSON.stringify(value))
}
function parseVersion(version) {
  if (typeof version !== 'string') return void 0
  const match = version.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?(?:\+[\dA-Za-z-]+)?)$/i)
  if (!match) return void 0
  return {
    core: match.slice(1, 4),
    prerelease: match[4]?.split('.')
  }
}
function compareNumeric(left, right) {
  if (left.length !== right.length) return left.length > right.length
  return left > right
}
function isNewerVersion(next, current) {
  const installed = parseVersion(current)
  const nextParsed = parseVersion(next)
  if (!nextParsed || !installed) return false
  for (let index = 0; index < 3; index++) {
    if (nextParsed.core[index] !== installed.core[index]) return compareNumeric(nextParsed.core[index], installed.core[index])
  }
  if (!nextParsed.prerelease) return installed.prerelease !== void 0
  if (!installed.prerelease) return false
  const length = Math.max(nextParsed.prerelease.length, installed.prerelease.length)
  for (let index = 0; index < length; index++) {
    const nextId = nextParsed.prerelease[index]
    const installedId = installed.prerelease[index]
    if (nextId === installedId) continue
    if (nextId === void 0) return false
    if (installedId === void 0) return true
    const nextIsNumber = /^\d+$/.test(nextId)
    const installedIsNumber = /^\d+$/.test(installedId)
    if (nextIsNumber && installedIsNumber) return compareNumeric(nextId, installedId)
    if (nextIsNumber !== installedIsNumber) return installedIsNumber
    return nextId > installedId
  }
  return false
}
function fetchRegistry(urlOrTarget) {
  requestedUrls.push(urlOrTarget)
  return Promise.resolve({
    ok: true,
    json: async () => ({ latest: urlOrTarget === 'private-registry' ? '3.0.0' : '2.0.0' })
  })
}

const pkg = '`@quasar/cli`'
const registryCacheFile = getCacheFile(pkg)
writeCache(registryCacheFile, { checkedAt: Date.now(), latest: '2.0.0' })

const previousRegistry = process.env.npm_config_registry
process.env.npm_config_registry = 'http://private.example/registry/'
function checkFromCacheSim(cacheFile, pkg, version) {
  const cache = readCache(cacheFile)
  if (cache && cache.checkedAt && Date.now() - cache.checkedAt < 24 * 60 * 60 * 1000) return { cache, backgroundCheckScheduled: false }
  const cacheFileAfter = getCacheFile(pkg)
  return { cache, backgroundCheckScheduled: true, cacheFileAfter }
}

function checkFromFetchSim(cacheFile, pkg, version) {
  const registry = new URL(process.env.npm_config_registry || 'https://registry.npmjs.org')
  if (!registry.pathname.endsWith('/')) registry.pathname += '/'
  const packagePath = encodeURIComponent(pkg)
  const url = new URL(`-/package/${packagePath}/dist-tags`, registry)
  return fetchRegistry(registry.pathname + `-/package/${packagePath}/dist-tags`).then(async (response) => {
    const { latest } = await response.json()
    writeCache(cacheFile, {
      checkedAt: Date.now(),
      latest: isNewerVersion(latest, version) ? latest : void 0
    })
  })
}

const cache = readCache(registryCacheFile)
console.log(JSON.stringify({
  cacheKey: registryCacheFile,
  cachedLatestInitially: cache.latest,
  selectedRegistryConfig: process.env.npm_config_registry,
  selectedRegistryPathname: new URL(process.env.npm_config_registry).pathname,
  cachedCheckedAtAgeWithinInterval: cache && cache.checkedAt && Date.now() - cache.checkedAt < 24 * 60 * 60 * 1000,
  intervalTriggeredBackgroundCheck: false,
  fetchWouldHaveQueriedPathname: new URL(process.env.npm_config_registry).pathname,
}))

if (previousRegistry === undefined) delete process.env.npm_config_registry
else process.env.npm_config_registry = previousRegistry
rmSync(cacheRoot, { recursive: true, force: true })
JS

echo '--- lint check presence (if available without repo code execution) ---'
if [ -f package.json ]; then jq '.scripts // {}' package.json; fi