@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/services/UpdateNotifier.js

@@ -0,0 +1,572 @@
+import { spawn } from 'node:child_process';
+import { mkdirSync, openSync, readFileSync, realpathSync, renameSync, writeFileSync, } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Context, Effect, Layer } from 'effect';
+import { satisfies, validRange } from 'semver';
+import { UpdateDevEnvironment, UpdateNodeIncompatible, UpdatePermissionDenied, UpdatePmUnknown, UpdateRegistryUnreachable, UpdateSpawnFailed, UpdateTransientInstall, } from '../domain/errors';
+export const PACKAGE_NAME = '@mx-space/cli';
+export const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+const CACHE_FILE = 'update-check.json';
+const THROTTLE_MS = 24 * 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 3000;
+const PM_FRAGMENTS = [
+    {
+        pm: 'pnpm',
+        markers: [
+            '/pnpm/global/',
+            '/library/pnpm/global/',
+            '/.local/share/pnpm/global/',
+            '\\pnpm\\global\\',
+        ],
+    },
+    { pm: 'bun', markers: ['/.bun/install/global/', '\\bun\\install\\global\\'] },
+    {
+        pm: 'yarn',
+        markers: ['/.config/yarn/global/', '/.yarn/global/', '\\yarn\\global\\'],
+    },
+];
+const TRANSIENT_FRAGMENTS = [
+    { cache: 'npx', markers: ['/_npx/', '\\_npx\\'] },
+    { cache: 'pnpm-dlx', markers: ['/.pnpm-store/dlx/', '/dlx-', '\\dlx-'] },
+    {
+        cache: 'bunx',
+        markers: ['/.bun/install/cache/', '\\bun\\install\\cache\\'],
+    },
+];
+const DEV_FRAGMENTS = [
+    {
+        reason: 'monorepo-source',
+        markers: ['/packages/cli/src/', '\\packages\\cli\\src\\'],
+    },
+    {
+        reason: 'monorepo-dist',
+        markers: ['/packages/cli/dist/', '\\packages\\cli\\dist\\'],
+    },
+];
+const normalizePath = (p) => p.replaceAll('\\', '/').toLowerCase();
+export function detectPackageManager(argv1) {
+    let real = argv1;
+    try {
+        real = realpathSync(argv1);
+    }
+    catch {
+        // keep original; fs.realpath may fail for synthetic paths
+    }
+    const normalized = normalizePath(real);
+    const matches = (m) => normalized.includes(m.replaceAll('\\', '/').toLowerCase());
+    for (const d of DEV_FRAGMENTS) {
+        if (d.markers.some(matches)) {
+            return { kind: 'dev', reason: d.reason, realPath: real };
+        }
+    }
+    for (const t of TRANSIENT_FRAGMENTS) {
+        if (t.markers.some(matches)) {
+            return { kind: 'transient', cache: t.cache, realPath: real };
+        }
+    }
+    for (const p of PM_FRAGMENTS) {
+        if (p.markers.some(matches)) {
+            return { kind: 'global', pm: p.pm, realPath: real };
+        }
+    }
+    if (/\/node_modules\/@mx-space\/cli\b/.test(normalized) ||
+        /\/lib\/node_modules\/@mx-space\/cli\b/.test(normalized) ||
+        /\/appdata\/roaming\/npm\/node_modules\/@mx-space\/cli\b/.test(normalized)) {
+        return { kind: 'global', pm: 'npm', realPath: real };
+    }
+    return { kind: 'unknown', realPath: real };
+}
+export async function fetchLatestVersion(channel, opts = {}) {
+    const registry = (opts.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, '');
+    const distTag = channel === 'next' ? 'next' : 'latest';
+    const url = `${registry}/${encodeURIComponent(PACKAGE_NAME).replace('%40', '@')}/${distTag}`;
+    const headers = { accept: 'application/json' };
+    if (opts.etag)
+        headers['if-none-match'] = opts.etag;
+    const fetchImpl = opts.fetchImpl ?? ((u, init) => globalThis.fetch(u, init));
+    const res = await fetchImpl(url, { headers, signal: opts.signal });
+    if (res.status === 304) {
+        return { notModified: true, etag: opts.etag };
+    }
+    if (!res.ok) {
+        throw new Error(`registry returned status ${res.status}`);
+    }
+    const body = (await res.json());
+    return {
+        version: body.version,
+        engines: body.engines,
+        tarball: body.dist?.tarball,
+        etag: res.headers.get('etag') ?? undefined,
+    };
+}
+export function compareSemver(a, b) {
+    const pa = parseSemver(a);
+    const pb = parseSemver(b);
+    if (!pa || !pb)
+        return a === b ? 0 : a < b ? -1 : 1;
+    for (let i = 0; i < 3; i++) {
+        if (pa.main[i] !== pb.main[i])
+            return pa.main[i] < pb.main[i] ? -1 : 1;
+    }
+    if (!pa.pre && !pb.pre)
+        return 0;
+    if (!pa.pre && pb.pre)
+        return 1;
+    if (pa.pre && !pb.pre)
+        return -1;
+    const ap = pa.pre;
+    const bp = pb.pre;
+    const n = Math.max(ap.length, bp.length);
+    for (let i = 0; i < n; i++) {
+        const x = ap[i];
+        const y = bp[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        const xn = /^\d+$/.test(x) ? Number(x) : null;
+        const yn = /^\d+$/.test(y) ? Number(y) : null;
+        if (xn !== null && yn !== null) {
+            if (xn !== yn)
+                return xn < yn ? -1 : 1;
+            continue;
+        }
+        if (xn !== null)
+            return -1;
+        if (yn !== null)
+            return 1;
+        if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    return 0;
+}
+function parseSemver(v) {
+    const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([\d.A-Za-z-]+))?(?:\+[\d.A-Za-z-]+)?$/.exec(v.trim());
+    if (!m)
+        return null;
+    return {
+        main: [Number(m[1]), Number(m[2]), Number(m[3])],
+        pre: m[4] ? m[4].split('.') : null,
+    };
+}
+export function satisfiesNodeEngine(currentVersion, range) {
+    if (!range)
+        return true;
+    const trimmed = range.trim();
+    if (!trimmed)
+        return true;
+    if (!validRange(trimmed, { loose: true }))
+        return true;
+    return satisfies(currentVersion, trimmed, { loose: true });
+}
+export function buildUpgradeCommand(pm, channel) {
+    const target = channel === 'next' ? `${PACKAGE_NAME}@next` : `${PACKAGE_NAME}@latest`;
+    switch (pm) {
+        case 'npm': {
+            return { cmd: 'npm', args: ['install', '-g', target] };
+        }
+        case 'pnpm': {
+            return { cmd: 'pnpm', args: ['add', '-g', target] };
+        }
+        case 'yarn': {
+            return { cmd: 'yarn', args: ['global', 'add', target] };
+        }
+        case 'bun': {
+            return { cmd: 'bun', args: ['add', '-g', target] };
+        }
+    }
+}
+async function defaultSpawnUpgrade(cmd, args) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            stdio: ['ignore', 'inherit', 'pipe'],
+            cwd: process.cwd(),
+            shell: os.platform() === 'win32',
+        });
+        let stderr = '';
+        child.stderr?.on('data', (chunk) => {
+            const str = chunk.toString();
+            stderr += str;
+            process.stderr.write(chunk);
+        });
+        child.on('error', (err) => {
+            stderr += String(err.message ?? err);
+            resolve({ status: 1, stderr });
+        });
+        child.on('exit', (code) => {
+            resolve({ status: code ?? 1, stderr });
+        });
+    });
+}
+function defaultSpawnDetached(cmd, args, logPath) {
+    try {
+        mkdirSync(path.dirname(logPath), { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+    let out;
+    try {
+        out = openSync(logPath, 'a');
+    }
+    catch {
+        out = openSync(os.platform() === 'win32' ? 'NUL' : '/dev/null', 'a');
+    }
+    try {
+        const child = spawn(cmd, args, {
+            stdio: ['ignore', out, out],
+            cwd: process.cwd(),
+            shell: os.platform() === 'win32',
+            detached: true,
+            env: { ...process.env, MXS_NO_UPDATE_CHECK: '1' },
+        });
+        child.on('error', () => {
+            // Best-effort: child failed to spawn (e.g. pm not on PATH). Next mxs
+            // invocation will emit the legacy notify line again after the 24h
+            // throttle expires.
+        });
+        child.unref();
+    }
+    catch {
+        // ignore: detached spawn is best-effort.
+    }
+}
+function defaultConfigDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const base = xdg && xdg.length > 0 ? xdg : path.join(os.homedir(), '.config');
+    return path.join(base, 'mxs');
+}
+function cachePath(configDir) {
+    return path.join(configDir, CACHE_FILE);
+}
+export function readCache(configDir) {
+    try {
+        const raw = readFileSync(cachePath(configDir), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.last_check_ts !== 'number')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCacheAtomic(state, configDir) {
+    const target = cachePath(configDir);
+    const dir = path.dirname(target);
+    try {
+        mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+    const tmp = `${target}.tmp`;
+    writeFileSync(tmp, JSON.stringify(state));
+    renameSync(tmp, target);
+}
+export function shouldSkipNotify(opts) {
+    const env = opts.env ?? process.env;
+    if (opts.quiet || opts.json)
+        return true;
+    if (opts.output === 'json')
+        return true;
+    if (env.CI && env.CI !== '' && env.CI !== '0' && env.CI !== 'false')
+        return true;
+    if (env.MXS_NO_UPDATE_CHECK === '1')
+        return true;
+    if (opts.isTTY === false)
+        return true;
+    if (opts.commandName === 'update')
+        return true;
+    if (opts.parentName === 'update')
+        return true;
+    return false;
+}
+function readChannelFromEnv(env) {
+    return env.MXS_UPDATE_CHANNEL === 'next' ? 'next' : 'stable';
+}
+const AUTO_UPDATE_LOG = 'auto-update.log';
+const isAutoUpdateDisabled = (env) => env.MXS_NO_AUTO_UPDATE === '1' ||
+    env.MXS_NO_AUTO_UPDATE === 'true' ||
+    env.MXS_NO_AUTO_UPDATE === 'yes';
+const planAutoUpdate = (entry, channel) => {
+    const detection = detectPackageManager(entry);
+    if (detection.kind !== 'global')
+        return null;
+    const { cmd, args } = buildUpgradeCommand(detection.pm, channel);
+    return { pm: detection.pm, cmd, args };
+};
+const KNOWN_PMS = new Set([
+    'npm',
+    'pnpm',
+    'yarn',
+    'bun',
+]);
+export const make = (deps = {}) => {
+    const now = () => (deps.now ? deps.now() : Date.now());
+    const fetchImpl = deps.fetchImpl;
+    const spawnImpl = deps.spawnImpl ?? defaultSpawnUpgrade;
+    const spawnDetached = deps.spawnDetached ?? defaultSpawnDetached;
+    const emitInfo = deps.emitInfo ?? ((msg) => process.stderr.write(`${msg}\n`));
+    const baseConfigDir = deps.configDir;
+    const resolvedConfigDir = (opts) => opts.configDir ?? baseConfigDir ?? defaultConfigDir();
+    const triggerAutoUpdate = (opts, latest, cache, dir, ts) => {
+        const env = opts.env ?? process.env;
+        if (isAutoUpdateDisabled(env))
+            return false;
+        if (cache?.last_auto_update_ts !== undefined &&
+            ts - cache.last_auto_update_ts < THROTTLE_MS) {
+            return false;
+        }
+        const channel = opts.channel ?? readChannelFromEnv(env);
+        const entry = deps.entrypoint ?? process.argv[1] ?? '';
+        const plan = planAutoUpdate(entry, channel);
+        if (!plan)
+            return false;
+        try {
+            spawnDetached(plan.cmd, plan.args, path.join(dir, AUTO_UPDATE_LOG));
+        }
+        catch {
+            return false;
+        }
+        writeCacheAtomic({
+            last_check_ts: ts,
+            latest_version: latest,
+            etag: cache?.etag,
+            last_auto_update_ts: ts,
+        }, dir);
+        return true;
+    };
+    const maybeNotify = (opts) => Effect.tryPromise({
+        try: async () => {
+            if (shouldSkipNotify(opts))
+                return;
+            const dir = resolvedConfigDir(opts);
+            const ts = now();
+            const cache = readCache(dir);
+            const channel = opts.channel ?? readChannelFromEnv(opts.env ?? process.env);
+            const emit = opts.emit ?? ((msg) => process.stderr.write(`${msg}\n`));
+            if (cache && !opts.force && ts - cache.last_check_ts < THROTTLE_MS) {
+                if (cache.latest_version &&
+                    compareSemver(opts.currentVersion, cache.latest_version) < 0) {
+                    const triggered = triggerAutoUpdate(opts, cache.latest_version, cache, dir, ts);
+                    emit(triggered
+                        ? `mxs: auto-updating ${opts.currentVersion} → ${cache.latest_version} in background (set MXS_NO_AUTO_UPDATE=1 to disable)`
+                        : `mxs update available: ${opts.currentVersion} → ${cache.latest_version}   run 'mxs update' to upgrade`);
+                }
+                return;
+            }
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+            if (typeof timer.unref === 'function') {
+                ;
+                timer.unref();
+            }
+            try {
+                const hit = await fetchLatestVersion(channel, {
+                    etag: cache?.etag,
+                    signal: controller.signal,
+                    fetchImpl,
+                });
+                clearTimeout(timer);
+                if ('notModified' in hit && hit.notModified) {
+                    writeCacheAtomic({
+                        last_check_ts: ts,
+                        latest_version: cache?.latest_version,
+                        etag: cache?.etag,
+                    }, dir);
+                    return;
+                }
+                writeCacheAtomic({
+                    last_check_ts: ts,
+                    latest_version: hit.version,
+                    etag: hit.etag,
+                    last_auto_update_ts: cache?.last_auto_update_ts,
+                }, dir);
+                if (compareSemver(opts.currentVersion, hit.version) < 0) {
+                    const triggered = triggerAutoUpdate(opts, hit.version, {
+                        last_check_ts: ts,
+                        latest_version: hit.version,
+                        etag: hit.etag,
+                        last_auto_update_ts: cache?.last_auto_update_ts,
+                    }, dir, ts);
+                    if (triggered) {
+                        emit(`mxs: auto-updating ${opts.currentVersion} → ${hit.version} in background (set MXS_NO_AUTO_UPDATE=1 to disable)`);
+                    }
+                }
+            }
+            catch {
+                clearTimeout(timer);
+                writeCacheAtomic({
+                    last_check_ts: ts,
+                    latest_version: cache?.latest_version,
+                    etag: cache?.etag,
+                }, dir);
+            }
+        },
+        catch: () => undefined,
+    }).pipe(Effect.catchAll(() => Effect.void), Effect.catchAllDefect(() => Effect.void));
+    const runUpdate = (opts) => Effect.gen(function* () {
+        const channel = opts.prerelease
+            ? 'next'
+            : (opts.channel ?? 'stable');
+        // 1. Detect package manager
+        const entry = opts.entrypoint ?? process.argv[1] ?? '';
+        const detection = detectPackageManager(entry);
+        let pm;
+        if (opts.pm) {
+            if (!KNOWN_PMS.has(opts.pm)) {
+                return yield* Effect.fail(new UpdatePmUnknown({
+                    message: `unknown package manager '${opts.pm}'`,
+                    hint: 'supported values: npm | pnpm | yarn | bun',
+                }));
+            }
+            pm = opts.pm;
+        }
+        else {
+            switch (detection.kind) {
+                case 'dev': {
+                    return yield* Effect.fail(new UpdateDevEnvironment({
+                        message: 'dev install detected; mxs is running from the monorepo source tree',
+                        hint: 'pull the repo with `git pull` and rebuild instead of self-updating',
+                    }));
+                }
+                case 'transient': {
+                    return yield* Effect.fail(new UpdateTransientInstall({
+                        message: `mxs is running from a transient ${detection.cache} cache`,
+                        hint: 'install mxs globally first, e.g. `npm i -g @mx-space/cli` or `pnpm add -g @mx-space/cli`',
+                    }));
+                }
+                case 'unknown': {
+                    return yield* Effect.fail(new UpdatePmUnknown({
+                        message: 'unable to detect the package manager that installed mxs',
+                        hint: 'pass --pm <npm|pnpm|yarn|bun> to override detection',
+                        details: { realPath: detection.realPath },
+                    }));
+                }
+                case 'global': {
+                    pm = detection.pm;
+                    break;
+                }
+            }
+        }
+        // 2. Fetch latest
+        const hit = yield* Effect.tryPromise({
+            try: async () => {
+                const result = await fetchLatestVersion(channel, { fetchImpl });
+                if ('notModified' in result && result.notModified) {
+                    throw new Error('unexpected 304 without an etag');
+                }
+                return result;
+            },
+            catch: (cause) => new UpdateRegistryUnreachable({
+                message: 'unable to reach the npm registry',
+                hint: 'check your network connection or set MXS_NO_UPDATE_CHECK=1 to silence the notifier',
+                details: { cause: cause instanceof Error ? cause.message : cause },
+            }),
+        });
+        const cmp = compareSemver(opts.currentVersion, hit.version);
+        if (cmp >= 0) {
+            return {
+                fromVersion: opts.currentVersion,
+                toVersion: hit.version,
+                pm,
+                channel,
+                status: 0,
+                upgraded: false,
+                dryRun: true,
+                upToDate: true,
+            };
+        }
+        // 3. Node engine compatibility
+        const nodeVersion = opts.nodeVersion ?? process.versions.node;
+        if (hit.engines?.node &&
+            !satisfiesNodeEngine(nodeVersion, hit.engines.node)) {
+            return yield* Effect.fail(new UpdateNodeIncompatible({
+                message: `mxs ${hit.version} requires Node ${hit.engines.node} (current: v${nodeVersion})`,
+                hint: 'upgrade Node first, then re-run `mxs update`',
+            }));
+        }
+        // 4. Announce
+        if (!opts.json) {
+            emitInfo(`mxs: ${opts.currentVersion} → ${hit.version}  (channel: ${channel}, pm: ${pm})`);
+        }
+        if (opts.check) {
+            return {
+                fromVersion: opts.currentVersion,
+                toVersion: hit.version,
+                pm,
+                channel,
+                status: 0,
+                upgraded: false,
+                dryRun: true,
+                upToDate: false,
+            };
+        }
+        const { cmd, args } = buildUpgradeCommand(pm, channel);
+        const shown = `${cmd} ${args.join(' ')}`;
+        if (opts.dryRun) {
+            if (!opts.json)
+                emitInfo(`mxs: would run: ${shown}`);
+            return {
+                fromVersion: opts.currentVersion,
+                toVersion: hit.version,
+                pm,
+                channel,
+                status: 0,
+                upgraded: false,
+                dryRun: true,
+                upToDate: false,
+                command: shown,
+            };
+        }
+        // 5. Spawn (auto-install — the legacy confirm prompt was removed when
+        //    `mxs update` became automatic; `opts.yes` is now a no-op kept for
+        //    backward compat with older invocations).
+        if (!opts.json)
+            emitInfo(`mxs: running ${shown}`);
+        const result = yield* Effect.tryPromise({
+            try: () => spawnImpl(cmd, args),
+            catch: (cause) => new UpdateSpawnFailed({
+                message: `failed to spawn ${cmd}`,
+                details: { cause: cause instanceof Error ? cause.message : cause },
+            }),
+        });
+        if (result.status === 0) {
+            if (!opts.json) {
+                emitInfo(`mxs: upgraded to ${hit.version}. Restart any long-running mxs process.`);
+            }
+            return {
+                fromVersion: opts.currentVersion,
+                toVersion: hit.version,
+                pm,
+                channel,
+                status: 0,
+                upgraded: true,
+                dryRun: false,
+                upToDate: false,
+                command: shown,
+            };
+        }
+        if (/eacces|permission denied/i.test(result.stderr)) {
+            return yield* Effect.fail(new UpdatePermissionDenied({
+                message: 'package manager could not write to the global install directory',
+                hint: `rerun with elevated permissions, e.g. \`sudo ${shown}\``,
+            }));
+        }
+        return yield* Effect.fail(new UpdateSpawnFailed({
+            message: `${cmd} exited with status ${result.status}`,
+            hint: `rerun with \`mxs update --dry-run\` to inspect the exact command`,
+        }));
+    });
+    return { maybeNotify, runUpdate };
+};
+// ---------------------------------------------------------------------------
+// Tag + Layer
+// ---------------------------------------------------------------------------
+export class UpdateNotifier extends Context.Tag('UpdateNotifier')() {
+    static Default = Layer.succeed(UpdateNotifier, make());
+}
+/** Build a custom UpdateNotifier layer (tests). */
+export const layer = (deps = {}) => Layer.succeed(UpdateNotifier, make(deps));

package/dist/test/cli/ai/ai.test.d.ts

@@ -0,0 +1 @@
+export {};