@ailuntz/minilink 0.8.0

package/src/update.mjs

@@ -0,0 +1,119 @@
+import { readFileSync, writeFileSync, cpSync, mkdirSync, mkdtempSync, rmSync, existsSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { PACKAGE_NAME, VERSION, codexHome, atomicJSON } from './config.mjs';
+import { setting } from './legacy.mjs';
+import { installation, installRoot, updateInProgress } from './install.mjs';
+
+const name = PACKAGE_NAME, registry = 'https://registry.npmjs.org/';
+const interval = 24 * 60 * 60 * 1000;
+const version = value => typeof value === 'string' && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value) && value.split('.').every(n => Number.isSafeInteger(Number(n)));
+const disabled = () => Boolean(setting('NO_UPDATE_CHECK') || process.env.CI || process.env.NODE_TEST_CONTEXT);
+const pathFor = home => join(home, 'minilink-update.json');
+const execute = promisify(execFile);
+
+export function isNewer(latest, current) {
+  if (!version(latest) || !version(current)) return false;
+  const left = latest.split('.').map(Number), right = current.split('.').map(Number);
+  for (let i = 0; i < 3; i++) if (left[i] !== right[i]) return left[i] > right[i];
+  return false;
+}
+function read(home) {
+  try { return JSON.parse(readFileSync(pathFor(home), 'utf8')); } catch { return {}; }
+}
+const due = (state, now) => !Number.isFinite(state.checkedAt) || now < state.checkedAt || now - state.checkedAt >= interval;
+export function updateStatus(home = codexHome()) {
+  const state = read(home);
+  return { current: VERSION, latest: version(state.latest) ? state.latest : null, installed: version(state.installed) ? state.installed : null, checkedAt: state.checkedAt || null };
+}
+
+// Stage and validate before npm touches the installed package. npm verifies the
+// archive integrity; the rollback archive is local and does not need a network.
+export async function upgrade(latest, state, { root = installRoot(), exec = execute } = {}) {
+  if (!version(latest) || !state?.npm || !state?.runtime || !state?.prefix || !existsSync(state.source)) return false;
+  if (resolve(state.source) !== join(resolve(state.prefix), 'lib/node_modules', name)) return false;
+  const directory = mkdtempSync(join(root, '.update-'));
+  const env = { ...process.env, PATH: `${dirname(state.node)}:${process.env.PATH || '/usr/bin:/bin:/usr/sbin:/sbin'}`, MINILINK_NO_UPDATE_CHECK: '1', CODEX_HOME: state.codexHome, MINILINK_CONFIG: state.configPath };
+  const npm = async args => (await exec(state.node, [state.npm, ...args, `--registry=${registry}`, '--no-audit', '--no-fund', '--logs-max=0', '--fetch-retries=0', '--fetch-timeout=15000'], { env, cwd: directory, timeout: 180000, maxBuffer: 1024 * 1024 })).stdout;
+  const pack = async spec => {
+    const result = JSON.parse(await npm(['pack', spec, '--ignore-scripts', '--json', '--pack-destination', directory]));
+    const filename = result[0]?.filename;
+    if (result[0]?.name !== name || !filename || filename !== filename.split('/').pop() || !filename.endsWith('.tgz')) throw new Error('Invalid package archive');
+    return join(directory, filename);
+  };
+  let rollback, installing = false;
+  try {
+    const candidate = await pack(`${name}@${latest}`);
+    const stage = join(directory, 'stage');
+    await npm(['install', '--prefix', stage, candidate, '--ignore-scripts', '--omit=dev', '--engine-strict']);
+    const source = join(stage, 'node_modules', name);
+    const manifest = JSON.parse(readFileSync(join(source, 'package.json'), 'utf8'));
+    if (manifest.name !== name || manifest.version !== latest) throw new Error('Package version mismatch');
+    await exec(state.node, ['--input-type=module', '-e', `await import(${JSON.stringify(pathToFileURL(join(source, 'src/config.mjs')).href)}); await import(${JSON.stringify(pathToFileURL(join(source, 'src/proxy.mjs')).href)});`], { env, timeout: 15000 });
+    await exec(state.node, ['--check', join(source, 'bin/minilink.mjs')], { env, timeout: 15000 });
+    const backup = join(directory, 'rollback');
+    cpSync(state.runtime, backup, { recursive: true });
+    const original = JSON.parse(readFileSync(join(backup, 'package.json'), 'utf8'));
+    atomicJSON(join(backup, 'package.json'), { ...original, bundledDependencies: Object.keys(original.dependencies || {}) });
+    rollback = await pack(backup);
+    // A manual uninstall during the download must not be undone by the worker.
+    if (!existsSync(state.source) || installation(root)?.installedAt !== state.installedAt) return false;
+    installing = true;
+    await npm(['install', '-g', '--prefix', state.prefix, candidate, '--offline', '--engine-strict', '--ignore-scripts=false']);
+    const active = installation(root);
+    if (!active?.runtime || JSON.parse(readFileSync(join(active.runtime, 'package.json'), 'utf8')).version !== latest) throw new Error('Desktop activation failed');
+    return true;
+  } catch {
+    if (installing && rollback) {
+      try { await npm(['install', '-g', '--prefix', state.prefix, rollback, '--offline', '--ignore-scripts']); } catch { /* The independent Desktop runtime remains usable. */ }
+    }
+    return false;
+  } finally { rmSync(directory, { recursive: true, force: true }); }
+}
+
+export async function checkForUpdates({ root = installRoot(), home = codexHome(), fetcher = fetch, now = Date.now(), skip = disabled(), state = installation(root), apply = upgrade } = {}) {
+  const cached = read(home);
+  if (skip || !state?.npm || !due(cached, now)) return updateStatus(home);
+  const lock = join(root, 'update.lock');
+  let owned = false;
+  try {
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    // Only the serial login agent removes abandoned locks. Workers never
+    // unlink a competitor's lock between checking it and taking ownership.
+    writeFileSync(lock, JSON.stringify({ pid: process.pid }), { flag: 'wx', mode: 0o600 }); owned = true;
+    if (!due(read(home), now)) return updateStatus(home);
+    atomicJSON(pathFor(home), { ...cached, checkedAt: now });
+    const response = await fetcher(`${registry}${encodeURIComponent(name)}/latest`, {
+      headers: { accept: 'application/json' }, signal: AbortSignal.timeout(2500), redirect: 'error'
+    });
+    if (!response.ok) { await response.body?.cancel(); return updateStatus(home); }
+    const chunks = []; let size = 0;
+    for await (const chunk of response.body) { size += chunk.length; if (size > 65536) throw new Error('Oversized registry response'); chunks.push(chunk); }
+    const manifest = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (manifest.name !== name || !version(manifest.version)) return updateStatus(home);
+    const next = { ...cached, checkedAt: now, latest: manifest.version };
+    atomicJSON(pathFor(home), next);
+    const current = JSON.parse(readFileSync(join(state.runtime, 'package.json'), 'utf8')).version;
+    if (isNewer(manifest.version, current) && await apply(manifest.version, state, { root })) atomicJSON(pathFor(home), { ...next, installed: manifest.version });
+  } catch { /* Offline, permissions, registry and install failures stay silent. */ }
+  finally { if (owned) rmSync(lock, { force: true }); }
+  return updateStatus(home);
+}
+
+export function startUpdate() {
+  if (disabled()) return;
+  try {
+    const state = installation();
+    if (!state?.npm || !state.runtime || !existsSync(state.source) || !due(read(state.codexHome), Date.now()) || updateInProgress()) return;
+    const child = spawn(state.node, [join(state.runtime, 'src/update.mjs')], {
+      detached: true, stdio: 'ignore', env: { ...process.env, CODEX_HOME: state.codexHome }
+    });
+    child.on('error', () => {}); child.unref();
+  } catch { /* Startup must not depend on updates. */ }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try { await checkForUpdates(); } catch { /* A background worker never logs errors. */ }
+}