kiku-agent 1.0.11 → 1.2.0

package/server/agent/updateManager.js

@@ -1,456 +0,0 @@
-import { spawn } from 'node:child_process';
-import { existsSync, promises as fs } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { KIKU_DATA_DIR } from './appPaths.js';
-import { PACKAGE_NAME, PACKAGE_VERSION } from './version.js';
-
-export const UPDATE_CHANNELS = Object.freeze(['latest', 'next', 'canary']);
-export const UPDATE_STATE_FILE = path.join(KIKU_DATA_DIR, 'update-state.json');
-
-const PACKAGE_ROOT = fileURLToPath(new URL('../../', import.meta.url));
-const STRICT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-const MAX_NPM_OUTPUT = 2 * 1024 * 1024;
-const DEFAULT_TIMEOUT_MS = 20_000;
-const INSTALL_TIMEOUT_MS = 180_000;
-
-export class UpdateError extends Error {
-  constructor(message, code = 'UPDATE_ERROR', details = {}) {
-    super(message);
-    this.name = 'UpdateError';
-    this.code = code;
-    this.details = details;
-  }
-}
-
-function cleanOutput(value, maxLength = 400) {
-  const text = String(value || '')
-    .replace(/\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))/g, '')
-    .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '')
-    .split('\n')
-    .map(line => line.replace(/^npm\s+(?:error|ERR!)\s*/i, '').trim())
-    .filter(Boolean)
-    .join(' ');
-  return text.slice(0, maxLength);
-}
-
-function parseSemver(value) {
-  const normalized = String(value || '').trim().replace(/^v/, '');
-  const match = normalized.match(STRICT_SEMVER);
-  if (!match) return null;
-  return {
-    raw: normalized,
-    major: Number(match[1]),
-    minor: Number(match[2]),
-    patch: Number(match[3]),
-    prerelease: match[4] ? match[4].split('.') : [],
-  };
-}
-
-function compareIdentifiers(left, right) {
-  const leftNumeric = /^\d+$/.test(left);
-  const rightNumeric = /^\d+$/.test(right);
-  if (leftNumeric && rightNumeric) return Number(left) - Number(right);
-  if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
-  return left.localeCompare(right);
-}
-
-export function compareVersions(left, right) {
-  const a = parseSemver(left);
-  const b = parseSemver(right);
-  if (!a || !b) throw new UpdateError('The registry returned an invalid semantic version.', 'INVALID_SEMVER');
-  for (const key of ['major', 'minor', 'patch']) {
-    if (a[key] !== b[key]) return Math.sign(a[key] - b[key]);
-  }
-  if (a.prerelease.length === 0 && b.prerelease.length === 0) return 0;
-  if (a.prerelease.length === 0) return 1;
-  if (b.prerelease.length === 0) return -1;
-  const max = Math.max(a.prerelease.length, b.prerelease.length);
-  for (let index = 0; index < max; index++) {
-    if (a.prerelease[index] === undefined) return -1;
-    if (b.prerelease[index] === undefined) return 1;
-    const compared = compareIdentifiers(a.prerelease[index], b.prerelease[index]);
-    if (compared !== 0) return Math.sign(compared);
-  }
-  return 0;
-}
-
-export function isValidUpdateTarget(value) {
-  const normalized = String(value || '').trim().toLowerCase();
-  return UPDATE_CHANNELS.includes(normalized) || Boolean(parseSemver(normalized));
-}
-
-export function normalizeUpdateTarget(value, fallback = 'latest') {
-  const normalized = String(value || fallback).trim().toLowerCase().replace(/^v(?=\d)/, '');
-  if (!isValidUpdateTarget(normalized)) {
-    throw new UpdateError(
-      'Invalid update target. Use latest, next, canary, or an exact version such as 1.2.3.',
-      'INVALID_TARGET'
-    );
-  }
-  return normalized;
-}
-
-function satisfiesComparator(version, comparator) {
-  const match = comparator.match(/^(>=|<=|>|<|=|\^|~)?\s*(v?\d+(?:\.\d+){0,2})(?:\.x)?$/i);
-  if (!match) return false;
-  const operator = match[1] || '=';
-  const numericParts = match[2].replace(/^v/, '').split('.').map(Number);
-  while (numericParts.length < 3) numericParts.push(0);
-  const target = numericParts.join('.');
-  const compared = compareVersions(version, target);
-  if (operator === '>=') return compared >= 0;
-  if (operator === '<=') return compared <= 0;
-  if (operator === '>') return compared > 0;
-  if (operator === '<') return compared < 0;
-  if (operator === '~') {
-    const parsed = parseSemver(version);
-    return compared >= 0 && parsed.major === numericParts[0] && parsed.minor === numericParts[1];
-  }
-  if (operator === '^') {
-    const parsed = parseSemver(version);
-    if (numericParts[0] > 0) return compared >= 0 && parsed.major === numericParts[0];
-    if (numericParts[1] > 0) return compared >= 0 && parsed.major === 0 && parsed.minor === numericParts[1];
-    return compared >= 0 && parsed.major === 0 && parsed.minor === 0 && parsed.patch === numericParts[2];
-  }
-  return compared === 0;
-}
-
-export function satisfiesNodeEngine(nodeVersion, range) {
-  if (!range || range === '*') return true;
-  const version = String(nodeVersion || '').replace(/^v/, '').split('-')[0];
-  if (!parseSemver(version)) return false;
-  return String(range).split('||').some(alternative => {
-    const comparators = alternative.trim().split(/\s+/).filter(Boolean);
-    return comparators.length > 0 && comparators.every(comparator => satisfiesComparator(version, comparator));
-  });
-}
-
-function defaultNpmInvocation() {
-  const nodeDir = path.dirname(process.execPath);
-  const candidates = [
-    path.join(nodeDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-    path.resolve(nodeDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-    process.env.npm_execpath,
-  ].filter(Boolean);
-  const npmCli = candidates.find(candidate => /npm-cli\.(?:c?js|mjs)$/i.test(candidate) && existsSync(candidate));
-  if (npmCli) return { command: process.execPath, prefixArgs: [npmCli] };
-  return { command: process.platform === 'win32' ? 'npm.cmd' : 'npm', prefixArgs: [] };
-}
-
-export function runNpm(args, options = {}) {
-  if (!Array.isArray(args) || args.some(arg => typeof arg !== 'string')) {
-    return Promise.reject(new UpdateError('Invalid npm arguments.', 'INVALID_NPM_ARGS'));
-  }
-  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
-  const invocation = options.invocation || defaultNpmInvocation();
-  return new Promise((resolve, reject) => {
-    let stdout = '';
-    let stderr = '';
-    let settled = false;
-    const child = spawn(invocation.command, [...invocation.prefixArgs, ...args], {
-      shell: false,
-      windowsHide: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
-    });
-    const finish = (error, result) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      if (error) reject(error);
-      else resolve(result);
-    };
-    const append = (stream, chunk) => {
-      const next = stream + chunk.toString('utf8');
-      if (next.length > MAX_NPM_OUTPUT) {
-        try { child.kill('SIGKILL'); } catch {}
-        finish(new UpdateError('npm returned more data than expected.', 'NPM_OUTPUT_LIMIT'));
-        return stream;
-      }
-      return next;
-    };
-    child.stdout.on('data', chunk => { stdout = append(stdout, chunk); });
-    child.stderr.on('data', chunk => {
-      stderr = append(stderr, chunk);
-      if (typeof options.onStderr === 'function') options.onStderr(cleanOutput(chunk, 1000));
-    });
-    child.once('error', error => finish(new UpdateError(
-      `Unable to run npm: ${cleanOutput(error.message)}`,
-      'NPM_UNAVAILABLE',
-      { cause: error.code }
-    )));
-    child.once('close', code => finish(null, { code, stdout: stdout.trim(), stderr: stderr.trim() }));
-    const timer = setTimeout(() => {
-      try { child.kill('SIGKILL'); } catch {}
-      finish(new UpdateError('npm did not respond before the timeout.', 'NPM_TIMEOUT'));
-    }, timeoutMs);
-  });
-}
-
-function safeJsonParse(raw, code) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    throw new UpdateError('npm returned an unreadable response.', code);
-  }
-}
-
-function isPathInside(candidate, parent) {
-  const relative = path.relative(path.resolve(parent), path.resolve(candidate));
-  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
-}
-
-function normalizeState(raw = {}) {
-  const channel = UPDATE_CHANNELS.includes(raw.channel) ? raw.channel : 'latest';
-  const installs = Array.isArray(raw.installs)
-    ? raw.installs.filter(item => parseSemver(item?.from) && parseSemver(item?.to)).slice(-20)
-    : [];
-  return { schemaVersion: 1, channel, installs, lastCheck: raw.lastCheck || null };
-}
-
-export class UpdateManager {
-  constructor(options = {}) {
-    this.packageName = options.packageName || PACKAGE_NAME;
-    this.currentVersion = options.currentVersion || PACKAGE_VERSION;
-    this.packageRoot = options.packageRoot || PACKAGE_ROOT;
-    this.stateFile = options.stateFile || UPDATE_STATE_FILE;
-    this.nodeVersion = options.nodeVersion || process.versions.node;
-    this.env = options.env || process.env;
-    this.runner = options.runner || ((args, runnerOptions) => runNpm(args, runnerOptions));
-  }
-
-  async readState() {
-    try {
-      return normalizeState(JSON.parse(await fs.readFile(this.stateFile, 'utf8')));
-    } catch (error) {
-      if (error.code === 'ENOENT' || error instanceof SyntaxError) return normalizeState();
-      throw new UpdateError('Unable to read update settings.', 'STATE_READ_FAILED', { cause: error.code });
-    }
-  }
-
-  async writeState(state) {
-    const normalized = normalizeState(state);
-    const directory = path.dirname(this.stateFile);
-    const temporary = path.join(directory, `.update-state-${process.pid}-${Date.now()}.tmp`);
-    try {
-      await fs.mkdir(directory, { recursive: true, mode: 0o700 });
-      await fs.writeFile(temporary, JSON.stringify(normalized, null, 2), { encoding: 'utf8', mode: 0o600 });
-      await fs.rename(temporary, this.stateFile);
-    } catch (error) {
-      try { await fs.unlink(temporary); } catch {}
-      throw new UpdateError('Unable to save update settings.', 'STATE_WRITE_FAILED', { cause: error.code });
-    }
-    return normalized;
-  }
-
-  async getChannel() {
-    return (await this.readState()).channel;
-  }
-
-  async setChannel(channel) {
-    const normalized = normalizeUpdateTarget(channel);
-    if (!UPDATE_CHANNELS.includes(normalized)) {
-      throw new UpdateError('Update channels are latest, next, or canary.', 'INVALID_CHANNEL');
-    }
-    const state = await this.readState();
-    state.channel = normalized;
-    await this.writeState(state);
-    return normalized;
-  }
-
-  async detectInstallMode() {
-    const normalizedRoot = path.resolve(this.packageRoot);
-    if (/[\\/]_npx[\\/]/i.test(normalizedRoot) || this.env.npm_command === 'exec') {
-      return { id: 'npx', label: 'npx / npm exec', automatic: false };
-    }
-    if (existsSync(path.join(normalizedRoot, '.git'))) {
-      return { id: 'source', label: 'Source checkout', automatic: false };
-    }
-    try {
-      const result = await this.runner(['root', '--global'], { timeoutMs: 5_000 });
-      if (result.code === 0 && result.stdout && isPathInside(normalizedRoot, result.stdout.trim())) {
-        return { id: 'global', label: 'Global npm', automatic: true };
-      }
-    } catch {}
-    if (/[\\/]node_modules[\\/]/i.test(normalizedRoot)) {
-      return { id: 'local', label: 'Local project dependency', automatic: false };
-    }
-    return { id: 'unknown', label: 'Unknown/manual installation', automatic: false };
-  }
-
-  async fetchRelease(target) {
-    const normalizedTarget = normalizeUpdateTarget(target);
-    const spec = `${this.packageName}@${normalizedTarget}`;
-    const result = await this.runner(['view', spec, '--json', '--prefer-online'], { timeoutMs: DEFAULT_TIMEOUT_MS });
-    if (result.code !== 0) {
-      const errText = String(result.stderr || '');
-      if (/E404|404\s+No match found|No match found for version|not found|404\s+Not\s+Found/i.test(errText)) {
-        if (UPDATE_CHANNELS.includes(normalizedTarget)) {
-          throw new UpdateError(
-            `No release is currently available for channel "${normalizedTarget}" on npm. (Only "latest" is currently published).`,
-            'CHANNEL_NOT_FOUND',
-            { target: normalizedTarget, exitCode: result.code }
-          );
-        }
-        throw new UpdateError(
-          `Version or tag "${normalizedTarget}" was not found on the npm registry.`,
-          'RELEASE_NOT_FOUND',
-          { target: normalizedTarget, exitCode: result.code }
-        );
-      }
-      throw new UpdateError(
-        cleanOutput(result.stderr) || 'npm could not find the requested release.',
-        'REGISTRY_LOOKUP_FAILED',
-        { exitCode: result.code }
-      );
-    }
-    const manifest = safeJsonParse(result.stdout, 'REGISTRY_RESPONSE_INVALID');
-    if (manifest.name !== this.packageName || !parseSemver(manifest.version)) {
-      throw new UpdateError('The registry response did not match kiku-agent.', 'REGISTRY_IDENTITY_MISMATCH');
-    }
-    if (parseSemver(normalizedTarget) && compareVersions(manifest.version, normalizedTarget) !== 0) {
-      throw new UpdateError('The registry resolved a different version than requested.', 'REGISTRY_VERSION_MISMATCH');
-    }
-    const metadata = manifest.kikuUpdate && typeof manifest.kikuUpdate === 'object' ? manifest.kikuUpdate : {};
-    const rawNotes = metadata.releaseSummary || metadata.releaseNotes || [];
-    const releaseNotes = (Array.isArray(rawNotes) ? rawNotes : [rawNotes])
-      .map(note => cleanOutput(note, 240))
-      .filter(Boolean)
-      .slice(0, 10);
-    return {
-      target: normalizedTarget,
-      version: manifest.version,
-      engines: manifest.engines || {},
-      deprecated: cleanOutput(manifest.deprecated, 300) || null,
-      integrity: cleanOutput(manifest.dist?.integrity, 300) || null,
-      releaseNotes,
-      releaseUrl: /^https:\/\//i.test(metadata.releaseUrl || '') ? cleanOutput(metadata.releaseUrl, 500) : null,
-    };
-  }
-
-  async check(target) {
-    const state = await this.readState();
-    const requestedTarget = normalizeUpdateTarget(target, state.channel);
-    const [release, installMode] = await Promise.all([
-      this.fetchRelease(requestedTarget),
-      this.detectInstallMode(),
-    ]);
-    const comparison = compareVersions(release.version, this.currentVersion);
-    const nodeRange = release.engines?.node || null;
-    const nodeCompatible = satisfiesNodeEngine(this.nodeVersion, nodeRange);
-    const current = parseSemver(this.currentVersion);
-    const next = parseSemver(release.version);
-    const status = {
-      packageName: this.packageName,
-      currentVersion: this.currentVersion,
-      targetVersion: release.version,
-      target: requestedTarget,
-      channel: UPDATE_CHANNELS.includes(requestedTarget) ? requestedTarget : state.channel,
-      comparison,
-      change: comparison > 0 ? 'upgrade' : comparison < 0 ? 'downgrade' : 'current',
-      updateAvailable: comparison > 0,
-      majorChange: current.major !== next.major,
-      nodeRange,
-      nodeCompatible,
-      installMode,
-      deprecated: release.deprecated,
-      integrity: release.integrity,
-      releaseNotes: release.releaseNotes,
-      releaseUrl: release.releaseUrl,
-    };
-    state.lastCheck = {
-      checkedAt: new Date().toISOString(),
-      currentVersion: status.currentVersion,
-      targetVersion: status.targetVersion,
-      target: status.target,
-    };
-    try { await this.writeState(state); } catch {}
-    return status;
-  }
-
-  manualCommand(installMode, version) {
-    if (installMode.id === 'npx') return `npx --yes --prefer-online ${this.packageName}@${version}`;
-    if (installMode.id === 'local') return `npm install ${this.packageName}@${version}`;
-    if (installMode.id === 'source') return 'git pull && npm install';
-    return `npm install --global ${this.packageName}@${version}`;
-  }
-
-  async install(target, options = {}) {
-    const status = await this.check(target);
-    if (status.deprecated && !options.allowDeprecated) {
-      throw new UpdateError(`This release is deprecated: ${status.deprecated}`, 'DEPRECATED_RELEASE');
-    }
-    if (!status.nodeCompatible) {
-      throw new UpdateError(
-        `Node ${this.nodeVersion} does not satisfy ${status.nodeRange}.`,
-        'NODE_INCOMPATIBLE'
-      );
-    }
-    if (status.majorChange && status.change === 'upgrade' && !options.allowMajor) {
-      throw new UpdateError(
-        `Version ${status.targetVersion} is a major update. Re-run with --allow-major after reviewing its release notes.`,
-        'MAJOR_CONFIRMATION_REQUIRED'
-      );
-    }
-    if (status.change === 'current') return { ...status, outcome: 'current' };
-    if (!status.installMode.automatic) {
-      return {
-        ...status,
-        outcome: 'manual',
-        command: this.manualCommand(status.installMode, status.targetVersion),
-      };
-    }
-
-    const exactSpec = `${this.packageName}@${status.targetVersion}`;
-    const result = await this.runner(
-      ['install', '--global', exactSpec, '--no-audit', '--no-fund'],
-      { timeoutMs: INSTALL_TIMEOUT_MS, onStderr: options.onProgress }
-    );
-    if (result.code !== 0) {
-      throw new UpdateError(
-        cleanOutput(result.stderr) || 'npm failed to install the update.',
-        'INSTALL_FAILED',
-        { exitCode: result.code, version: status.targetVersion }
-      );
-    }
-
-    const verification = await this.runner(
-      ['list', '--global', this.packageName, '--depth=0', '--json'],
-      { timeoutMs: DEFAULT_TIMEOUT_MS }
-    );
-    if (verification.code !== 0) {
-      throw new UpdateError('The update installed, but its version could not be verified.', 'VERIFY_FAILED');
-    }
-    const installed = safeJsonParse(verification.stdout, 'VERIFY_RESPONSE_INVALID')
-      ?.dependencies?.[this.packageName]?.version;
-    if (installed !== status.targetVersion) {
-      throw new UpdateError('npm reported a different installed version after updating.', 'VERIFY_VERSION_MISMATCH', {
-        expected: status.targetVersion,
-        installed,
-      });
-    }
-
-    let historyRecorded = true;
-    try {
-      const state = await this.readState();
-      state.installs.push({
-        from: this.currentVersion,
-        to: status.targetVersion,
-        target: status.target,
-        installedAt: new Date().toISOString(),
-      });
-      await this.writeState(state);
-    } catch {
-      historyRecorded = false;
-    }
-    return { ...status, outcome: 'installed', installedVersion: installed, historyRecorded };
-  }
-
-  async rollback(options = {}) {
-    const state = await this.readState();
-    const last = [...state.installs].reverse().find(item => item.to === this.currentVersion) || state.installs.at(-1);
-    if (!last) throw new UpdateError('No previous Kiku Agent version is recorded.', 'NO_ROLLBACK_VERSION');
-    return this.install(last.from, { ...options, allowMajor: true, rollback: true });
-  }
-}