nexrall-code 0.5.107 → 0.5.108

package/dist/commands/plugin.js

@@ -0,0 +1,393 @@
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { installPlugin, removePlugin, updatePlugin, readReceipt, loadPlugins, searchRegistry, getRegistryPlugin, reportInstall, inspectPluginDir, loadDeclaredSources, resolveSourceAlias, writeDeclaredSource, removeDeclaredSource, sourcesFileFor, allowedSourcePatterns, isSourceAllowed, parsePluginSource, } from '@nexrall/code-core';
+// ─── nex plugin <install|remove|update|list> ─────────────────────────────────
+//
+// GitHub-first plugin distribution (no registry server):
+//   nex plugin install owner/repo
+//   nex plugin install owner/repo#v1.0.0
+//   nex plugin install owner/repo/plugins/foo
+//   nex plugin install https://github.com/owner/repo
+//   nex plugin install ./local/dir
+//
+// SAFETY: plugins that ship hooks.json or mcp.json can execute arbitrary
+// commands on this machine. We surface a loud warning and require explicit
+// confirmation before completing such installs (unless --yes).
+function describeInspection(i, name, ctx) {
+    console.log();
+    console.log(chalk.bold(`  Plugin: ${name}`) + (i.meta.version ? chalk.dim(`  v${i.meta.version}`) : ''));
+    if (i.meta.description)
+        console.log(chalk.dim(`  ${i.meta.description}`));
+    // Show WHICH code this is. On an update the change of commit is the single most
+    // decision-relevant fact: the same trusted name can point at wholly different
+    // contents, and "updating plugin X" alone hides that entirely.
+    if (ctx?.sha) {
+        const short = (s) => s.slice(0, 7);
+        if (ctx.previousSha && ctx.previousSha !== ctx.sha) {
+            console.log(chalk.dim('  commit:  ') + chalk.yellow(`${short(ctx.previousSha)} → ${short(ctx.sha)}`));
+        }
+        else if (ctx.previousSha === ctx.sha) {
+            console.log(chalk.dim(`  commit:  ${short(ctx.sha)} (already up to date)`));
+        }
+        else {
+            console.log(chalk.dim(`  commit:  ${short(ctx.sha)}`));
+        }
+    }
+    else if (ctx?.isUpdate) {
+        console.log(chalk.dim('  commit:  unknown (could not reach the GitHub API)'));
+    }
+    if (i.commands.length)
+        console.log(`  ${chalk.cyan('commands:')} ${i.commands.map((c) => '/' + c).join(', ')}`);
+    if (i.agents.length)
+        console.log(`  ${chalk.cyan('agents:')}   ${i.agents.join(', ')}`);
+    if (i.hasHooks)
+        console.log(`  ${chalk.yellow('hooks:')}    yes`);
+    if (i.hasMcp)
+        console.log(`  ${chalk.yellow('mcp:')}      yes`);
+}
+async function confirmInstall(i, name, autoYes, ctx) {
+    describeInspection(i, name, ctx);
+    const dangerous = i.hasHooks || i.hasMcp;
+    if (dangerous) {
+        // An UPDATE that introduces hooks/MCP is the sharpest case: the user already
+        // trusts this plugin by name, and a routine `nex plugin update` would
+        // otherwise be the moment it gains the ability to run commands. Call that out
+        // separately from the standing warning below.
+        if (ctx?.isUpdate) {
+            console.log();
+            console.log(chalk.red.bold('  ⚠ THIS UPDATE SHIPS CODE EXECUTION'));
+            console.log(chalk.red('  A version of this plugin you already trust is being replaced by one'));
+            console.log(chalk.red('  that runs commands. Review the diff before continuing.'));
+        }
+        console.log();
+        console.log(chalk.red.bold('  ⚠ SECURITY WARNING'));
+        if (i.hasHooks) {
+            console.log(chalk.red('  This plugin ships hooks.json — hooks RUN SHELL COMMANDS on your'));
+            console.log(chalk.red('  machine automatically during agent turns.'));
+        }
+        if (i.hasMcp) {
+            console.log(chalk.red('  This plugin ships mcp.json — MCP servers are LOCAL PROCESSES'));
+            console.log(chalk.red('  started with the commands the plugin specifies.'));
+        }
+        console.log(chalk.red('  Only continue if you trust the author. Review the source first.'));
+    }
+    if (autoYes && !dangerous)
+        return true;
+    if (autoYes && dangerous) {
+        // --yes never silently approves code execution — that would defeat the gate.
+        console.log(chalk.yellow('\n  --yes does not apply to plugins with hooks/MCP; confirmation required.'));
+    }
+    // Non-interactive with no way to ask: fail loudly instead of hanging.
+    //
+    // `prompts` on a non-TTY stdin never resolves — it renders the question and
+    // waits forever for input that cannot arrive. In CI, a Dockerfile or any piped
+    // script that reached this point (no --yes, or a hooks/MCP plugin where --yes
+    // deliberately does not apply) the install just stopped dead until something
+    // killed it, and because nothing threw, the process could exit 0 having
+    // installed nothing at all — a silent failure in exactly the setting where it
+    // is hardest to notice.
+    if (!process.stdin.isTTY) {
+        console.log();
+        console.log(chalk.red('  ✗ Cannot ask for confirmation: stdin is not a terminal.'));
+        console.log(chalk.dim(dangerous
+            ? '    This plugin ships hooks/MCP, which always require an interactive confirmation.'
+            : '    Re-run with --yes to install non-interactively.'));
+        return false;
+    }
+    console.log();
+    const { ok } = await prompts({
+        type: 'confirm',
+        name: 'ok',
+        message: dangerous ? 'Install anyway?' : 'Install this plugin?',
+        initial: !dangerous,
+    });
+    return ok === true;
+}
+export async function pluginInstallCommand(spec, opts) {
+    const scope = opts.project ? 'project' : 'global';
+    try {
+        // Short name (no slash, not a path) → a declared source alias first, then
+        // the registry.
+        //
+        // Aliases win because they are the more specific, locally-declared intent: a
+        // team that wrote `"deploy": "acme/deploy-tools"` in their settings means THAT
+        // repo, and silently resolving to a same-named registry entry instead would be
+        // the more surprising and more dangerous outcome of the two.
+        let source = spec;
+        let registryName;
+        const isShortName = /^[\w.-]+$/.test(spec.trim()) && !spec.includes('/');
+        if (isShortName) {
+            // Project-declared sources count only once the workspace is trusted; the
+            // chat session establishes that, and `nex plugin install` is itself an
+            // explicit, human-initiated act against the folder the user chose.
+            const alias = resolveSourceAlias(spec.trim(), process.cwd(), { includeProject: true });
+            if (alias) {
+                source = alias.spec;
+                console.log(chalk.dim(`  Source: ${alias.name} (${alias.tier}) ← ${alias.spec}`));
+            }
+        }
+        if (isShortName && source === spec) {
+            const entry = await getRegistryPlugin(spec.trim()).catch(() => null);
+            if (entry) {
+                source = entry.source;
+                registryName = entry.name;
+                const badge = entry.official ? chalk.magenta(' [official]') : entry.verified ? chalk.green(' [verified]') : '';
+                console.log(chalk.dim(`  Registry: ${entry.display_name}${badge} ← ${entry.source}`));
+            }
+            else {
+                console.error(chalk.red(`  ✗ "${spec}" is not a declared source or a registry plugin.`));
+                console.error(chalk.dim('    Search:    nex plugin search <keyword>'));
+                console.error(chalk.dim('    From GitHub:  nex plugin install owner/repo'));
+                console.error(chalk.dim('    Declare it:   nex plugin source add ' + spec.trim() + ' owner/repo'));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const res = await installPlugin(source, {
+            scope,
+            workDir: process.cwd(),
+            name: opts.name ?? registryName,
+            force: opts.force,
+            confirm: (i, name, ctx) => confirmInstall(i, name, opts.yes === true, ctx),
+        });
+        if (registryName)
+            reportInstall(registryName);
+        console.log();
+        console.log(chalk.green(`  ✓ Installed "${res.name}" (${res.scope}) → ${res.dir}`)
+            + (res.sha ? chalk.dim(`  @ ${res.sha.slice(0, 7)}`) : ''));
+        if (res.inspection.commands.length) {
+            console.log(chalk.dim(`    Try: ${res.inspection.commands.map((c) => '/' + c).join(', ')}`));
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red(`  ✗ ${err.message}`));
+        process.exitCode = 1;
+    }
+}
+export function pluginRemoveCommand(name, opts) {
+    try {
+        const dir = removePlugin(name, {
+            scope: opts.project ? 'project' : undefined, // no flag → search both scopes
+            workDir: process.cwd(),
+        });
+        console.log(chalk.green(`  ✓ Removed "${name}" (${dir})`));
+    }
+    catch (err) {
+        console.error(chalk.red(`  ✗ ${err.message}`));
+        process.exitCode = 1;
+    }
+}
+export async function pluginUpdateCommand(name, opts) {
+    const workDir = process.cwd();
+    const targets = name
+        ? [name]
+        : loadPlugins(workDir).filter((p) => readReceipt(p.dir)?.kind === 'github').map((p) => p.name);
+    if (!targets.length) {
+        console.log(chalk.dim('  No updatable plugins (only GitHub-installed plugins with receipts can update).'));
+        return;
+    }
+    for (const t of targets) {
+        try {
+            const res = await updatePlugin(t, {
+                workDir,
+                confirm: (i, n, ctx) => confirmInstall(i, n, opts.yes === true, ctx),
+            });
+            const moved = res.sha && res.previousSha && res.sha !== res.previousSha
+                ? chalk.dim(`  ${res.previousSha.slice(0, 7)} → ${res.sha.slice(0, 7)}`)
+                : res.sha && res.previousSha === res.sha
+                    ? chalk.dim('  (unchanged)')
+                    : '';
+            console.log(chalk.green(`  ✓ Updated "${res.name}"`) + moved);
+        }
+        catch (err) {
+            console.error(chalk.red(`  ✗ ${t}: ${err.message}`));
+            process.exitCode = 1;
+        }
+    }
+}
+function badgeFor(p) {
+    return p.official ? chalk.magenta(' official') : p.verified ? chalk.green(' verified') : '';
+}
+export async function pluginSearchCommand(query) {
+    try {
+        const results = await searchRegistry(query);
+        if (!results.length) {
+            console.log(chalk.dim(query ? `  No plugins matching "${query}".` : '  Registry is empty.'));
+            return;
+        }
+        console.log();
+        console.log(chalk.bold(query ? `  Plugins matching "${query}":` : '  Available plugins:'));
+        for (const p of results) {
+            const warn = p.has_hooks || p.has_mcp ? chalk.yellow(' ⚠ runs code') : '';
+            console.log('  ' + chalk.cyan(p.name.padEnd(20)) +
+                p.description.slice(0, 70) +
+                badgeFor(p) + warn +
+                chalk.dim(`  ↓${p.install_count}`));
+        }
+        console.log(chalk.dim('\n  nex plugin info <name>     details'));
+        console.log(chalk.dim('  nex plugin install <name>  install'));
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red(`  ✗ ${err.message}`));
+        process.exitCode = 1;
+    }
+}
+export async function pluginInfoCommand(name) {
+    try {
+        const p = await getRegistryPlugin(name);
+        if (!p) {
+            console.error(chalk.red(`  ✗ "${name}" not found in the registry.`));
+            process.exitCode = 1;
+            return;
+        }
+        console.log();
+        console.log(chalk.bold(`  ${p.display_name}`) + badgeFor(p) + chalk.dim(`  ↓${p.install_count} installs`));
+        console.log(`  ${p.description}`);
+        console.log();
+        console.log(chalk.dim('  author:   ') + p.author);
+        console.log(chalk.dim('  source:   ') + p.source);
+        if (p.homepage)
+            console.log(chalk.dim('  homepage: ') + p.homepage);
+        if (p.keywords?.length)
+            console.log(chalk.dim('  keywords: ') + p.keywords.join(', '));
+        const ships = [];
+        if (p.has_commands)
+            ships.push('commands');
+        if (p.has_agents)
+            ships.push('agents');
+        if (p.has_hooks)
+            ships.push(chalk.yellow('hooks (runs shell commands!)'));
+        if (p.has_mcp)
+            ships.push(chalk.yellow('MCP servers (spawns processes!)'));
+        if (ships.length)
+            console.log(chalk.dim('  ships:    ') + ships.join(', '));
+        console.log();
+        console.log(chalk.dim(`  Install:  nex plugin install ${p.name}`));
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red(`  ✗ ${err.message}`));
+        process.exitCode = 1;
+    }
+}
+export function pluginListCommand() {
+    const plugins = loadPlugins(process.cwd());
+    if (!plugins.length) {
+        console.log(chalk.dim('  No plugins installed.'));
+        console.log(chalk.dim('  Install one:  nex plugin install owner/repo'));
+        return;
+    }
+    console.log();
+    console.log(chalk.bold('  Installed plugins:'));
+    for (const p of plugins) {
+        const receipt = readReceipt(p.dir);
+        const src = receipt ? chalk.dim(`  ← ${receipt.source}`) : chalk.dim('  (manual)');
+        // The commit is what makes an install auditable — "which code is actually
+        // sitting in my plugins dir" cannot be answered by a name and a version
+        // string the author chose.
+        const at = receipt?.sha ? chalk.dim(` @ ${receipt.sha.slice(0, 7)}`) : '';
+        // Flag the executable surfaces at a glance: these are decided at install
+        // time but live on forever, and `list` is where a user audits them.
+        const insp = inspectPluginDir(p.dir);
+        const runs = insp.hasHooks || insp.hasMcp
+            ? chalk.yellow(`  ⚠ ${[insp.hasHooks && 'hooks', insp.hasMcp && 'mcp'].filter(Boolean).join('+')}`)
+            : '';
+        console.log('  ' + chalk.cyan(p.name.padEnd(24)) +
+            chalk.dim(`${(p.version ?? '').padEnd(10)}${p.scope.padEnd(9)}`) + src + at + runs);
+    }
+    console.log();
+}
+// ─── nex plugin source <list|add|remove> ─────────────────────────────────────
+//
+// A declared source binds a short alias to a plugin repo, so a team can commit
+// "these are our plugins" instead of telling each developer a URL to type.
+//
+// Declaring is NOT installing. Nothing is fetched and no code runs until someone
+// runs an install, which still passes the usual confirmation gate. That
+// separation is deliberate: project-tier entries come from the repository, so if
+// a declaration could install by itself, cloning a hostile repo would be enough
+// to execute its code — the exact attack the workspace trust prompt exists for.
+export function pluginSourceListCommand() {
+    const workDir = process.cwd();
+    const sources = loadDeclaredSources(workDir, { includeProject: true });
+    const patterns = allowedSourcePatterns();
+    if (patterns) {
+        console.log();
+        console.log(chalk.bold('  Organisation policy: ') + chalk.dim(`installs restricted to ${patterns.join(', ')}`));
+    }
+    if (!sources.length) {
+        console.log(chalk.dim('\n  No plugin sources declared.'));
+        console.log(chalk.dim('  Add one:  nex plugin source add <alias> owner/repo'));
+        console.log();
+        return;
+    }
+    console.log();
+    console.log(chalk.bold('  Declared plugin sources:'));
+    for (const s of sources) {
+        // The tier is the trust story, so it is never hidden: `project` means the
+        // repository chose this, which is a different claim from the user choosing it.
+        const tier = s.tier === 'project'
+            ? chalk.yellow(s.tier.padEnd(9))
+            : chalk.dim(s.tier.padEnd(9));
+        const blocked = !isSourceAllowed(s.spec, patterns) ? chalk.red('  ✗ blocked by policy') : '';
+        console.log('  ' + chalk.cyan(s.name.padEnd(20)) + tier + chalk.white(s.spec) + blocked);
+    }
+    console.log();
+    console.log(chalk.dim('  Install from one:  nex plugin install <alias>'));
+    console.log(chalk.dim('  Declaring a source does not install anything.'));
+    console.log();
+}
+export function pluginSourceAddCommand(name, spec, opts) {
+    try {
+        // Validate the spec NOW rather than at install time: a typo caught while the
+        // author is looking at it costs a second, and one committed into a shared
+        // settings file costs every teammate a confusing failure later.
+        parsePluginSource(spec);
+        const patterns = allowedSourcePatterns();
+        if (patterns && !isSourceAllowed(spec, patterns)) {
+            console.error(chalk.red(`  ✗ "${spec}" is not permitted by your organisation's policy.`));
+            console.error(chalk.dim(`    Allowed: ${patterns.join(', ')}`));
+            process.exitCode = 1;
+            return;
+        }
+        const scope = opts.project ? 'project' : 'user';
+        const file = sourcesFileFor(scope, process.cwd());
+        writeDeclaredSource(file, name, spec);
+        console.log();
+        console.log(chalk.green(`  ✓ Declared "${name}" → ${spec}`) + chalk.dim(`  (${scope})`));
+        console.log(chalk.dim(`    ${file}`));
+        console.log(chalk.dim(`    Nothing installed yet — run:  nex plugin install ${name}`));
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red(`  ✗ ${err.message}`));
+        process.exitCode = 1;
+    }
+}
+export function pluginSourceRemoveCommand(name, opts) {
+    const workDir = process.cwd();
+    const scope = opts.project ? 'project' : 'user';
+    const file = sourcesFileFor(scope, workDir);
+    if (removeDeclaredSource(file, name)) {
+        console.log(chalk.green(`  ✓ Removed source "${name}" (${scope})`));
+        console.log(chalk.dim('    Plugins already installed from it are untouched — remove them with  nex plugin remove <name>'));
+        return;
+    }
+    // Point at where it actually lives instead of a flat "not found": the most
+    // common cause is removing a project source while defaulting to user scope.
+    const found = resolveSourceAlias(name, workDir, { includeProject: true });
+    if (found) {
+        console.error(chalk.red(`  ✗ "${name}" is declared in the ${found.tier} tier, not ${scope}.`));
+        console.error(chalk.dim(`    ${found.file}`));
+        if (found.tier === 'project')
+            console.error(chalk.dim('    Retry with --project'));
+        if (found.tier === 'managed')
+            console.error(chalk.dim('    Managed sources are set by your organisation and cannot be removed here.'));
+    }
+    else {
+        console.error(chalk.red(`  ✗ No source named "${name}".`));
+    }
+    process.exitCode = 1;
+}

package/dist/commands/sessions.js

@@ -0,0 +1,62 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// NEXRALL_CLI_SESSIONS_DIR overrides the store root — used by tests to avoid
+// touching the real ~/.nexrall/cli-sessions directory on the dev/CI machine
+// (same pattern as core's NEXRALL_CHECKPOINT_DIR).
+export const SESSIONS_DIR = process.env.NEXRALL_CLI_SESSIONS_DIR || path.join(os.homedir(), '.nexrall', 'cli-sessions');
+function ensureDir() {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+export function sessionPath(id) {
+    return path.join(SESSIONS_DIR, `${id}.json`);
+}
+export function listSessions() {
+    try {
+        ensureDir();
+        return fs.readdirSync(SESSIONS_DIR)
+            .filter(f => f.endsWith('.json'))
+            .map(f => {
+            try {
+                return JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((s) => s !== null)
+            .sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    catch {
+        return [];
+    }
+}
+export function loadSession(id) {
+    try {
+        return JSON.parse(fs.readFileSync(sessionPath(id), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveSession(id, title, workDir, messages) {
+    try {
+        ensureDir();
+        const session = { id, title, updatedAt: Date.now(), workDir, messages };
+        fs.writeFileSync(sessionPath(id), JSON.stringify(session), 'utf-8');
+    }
+    catch { /* non-fatal */ }
+}
+export function deleteSession(id) {
+    try {
+        fs.unlinkSync(sessionPath(id));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function lastSession() {
+    const all = listSessions();
+    return all.length ? all[0] : null;
+}

package/dist/commands/update.js

@@ -0,0 +1,174 @@
+import * as fs from 'fs';
+import * as https from 'https';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+// This file is bundled to ESM (see build.js) — there is no `__dirname` in
+// ESM, referencing it throws ReferenceError, and that error was being
+// silently swallowed by getCurrentVersion()'s try/catch, so the CLI always
+// reported its own version as '0.0.0'. Deriving it from `import.meta.url`
+// instead is the ESM-correct equivalent of `__dirname`.
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// npm's registry is the single source of truth for "what is the latest
+// version" — it always reflects whatever `npm publish` actually shipped, with
+// no separate metadata to keep in sync. An earlier version of this file asked
+// our own backend for that answer via a custom CDN, whose "latest version"
+// was a hardcoded fallback that had drifted 5 months stale in production
+// (every `nex update` would have silently done nothing, or worse, reported
+// "up to date" while running a broken build). Delegating to npm removes that
+// class of bug entirely.
+const NPM_REGISTRY_LATEST = 'https://registry.npmjs.org/nexrall-code/latest';
+function get(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { headers: { 'User-Agent': 'nexrall-cli-updater', Accept: 'application/json' } }, res => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+                return get(res.headers.location).then(resolve).catch(reject);
+            }
+            if (res.statusCode !== 200) {
+                res.resume();
+                return reject(new Error(`npm registry returned HTTP ${res.statusCode}`));
+            }
+            let raw = '';
+            res.on('data', (c) => raw += c.toString());
+            res.on('end', () => resolve(raw));
+        }).on('error', reject);
+    });
+}
+function getCurrentVersion() {
+    try {
+        // The published npm package lays out as `nexrall-code/dist/index.js` +
+        // `nexrall-code/package.json` (verified via `npm pack --dry-run`), so
+        // from this bundled file's __dirname (= dist/) package.json is one level
+        // up, not two. The previous `../../package.json` resolved OUTSIDE the
+        // installed package entirely, so this always silently fell through to
+        // the '0.0.0' fallback — `nex update`/`checkForUpdate` never printed the
+        // real current version and never correctly reported "already up to
+        // date" once a `latest` genuinely matched what was installed.
+        const pkg = path.resolve(__dirname, '../package.json');
+        return JSON.parse(fs.readFileSync(pkg, 'utf-8')).version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function semverGt(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) > (pb[i] ?? 0))
+            return true;
+        if ((pa[i] ?? 0) < (pb[i] ?? 0))
+            return false;
+    }
+    return false;
+}
+async function fetchLatestVersion() {
+    const raw = await get(NPM_REGISTRY_LATEST);
+    const meta = JSON.parse(raw);
+    return meta.version ?? '0.0.0';
+}
+/** Re-exec `npm install -g nexrall-code` to pick up whatever is currently
+ * published — npm handles platform/arch/permissions itself, so there is no
+ * bespoke download-and-replace logic to maintain here. */
+function npmInstallGlobal() {
+    return new Promise(resolve => {
+        const { spawn } = require('child_process');
+        const child = spawn('npm', ['install', '-g', 'nexrall-code'], { stdio: 'pipe' });
+        let stderr = '';
+        child.stderr?.on('data', (c) => { stderr += c.toString(); });
+        child.on('close', (code) => {
+            if (code === 0)
+                return resolve({ ok: true, usedSudo: false });
+            // Permission errors (EACCES) are the common case for a system Node
+            // without a user-writable global prefix — retry once with sudo.
+            if (/EACCES|permission denied/i.test(stderr)) {
+                const sudo = spawn('sudo', ['npm', 'install', '-g', 'nexrall-code'], { stdio: 'inherit' });
+                sudo.on('close', (sudoCode) => resolve({ ok: sudoCode === 0, usedSudo: true }));
+            }
+            else {
+                console.error(chalk.dim(stderr.trim()));
+                resolve({ ok: false, usedSudo: false });
+            }
+        });
+    });
+}
+// ─── Check ────────────────────────────────────────────────────────────────────
+export async function checkForUpdate() {
+    const current = getCurrentVersion();
+    let latest;
+    try {
+        latest = await fetchLatestVersion();
+    }
+    catch {
+        console.log(chalk.dim('  Could not reach npm registry.'));
+        return;
+    }
+    if (semverGt(latest, current)) {
+        console.log('\n' + chalk.yellow('  ◆ Update available!') +
+            chalk.dim(` v${current} → `) + chalk.cyan(`v${latest}`) +
+            '\n' + chalk.dim('  Run ') + chalk.bold('nex update') + chalk.dim(' to install.\n'));
+    }
+    else {
+        console.log(chalk.dim(`  Already on latest: v${current}`));
+    }
+}
+// ─── Update ───────────────────────────────────────────────────────────────────
+export async function updateCommand(opts) {
+    const current = getCurrentVersion();
+    console.log();
+    console.log(chalk.bold('  Nexrall CLI — Updater'));
+    console.log(chalk.dim('  ─────────────────────────────────────'));
+    console.log(chalk.dim(`  Current version: v${current}`));
+    console.log();
+    // ── Fetch latest version info ─────────────────────────────────────────────
+    process.stdout.write(chalk.dim('  → Checking latest version…'));
+    let latest;
+    try {
+        latest = await fetchLatestVersion();
+        process.stdout.write('\r\x1b[K');
+    }
+    catch (e) {
+        process.stdout.write('\r\x1b[K');
+        console.error(chalk.red('  ✗ Could not reach npm registry: ') + String(e.message));
+        process.exit(1);
+    }
+    if (!semverGt(latest, current)) {
+        console.log(chalk.green(`  ✓ Already up to date — v${current}`));
+        console.log();
+        return;
+    }
+    console.log(chalk.cyan(`  New version available: v${latest}`) +
+        chalk.dim(` (current: v${current})`));
+    console.log();
+    // ── --check only ──────────────────────────────────────────────────────────
+    if (opts.check) {
+        console.log(chalk.dim('  Run ') + chalk.bold('nex update') + chalk.dim(' to install.'));
+        console.log();
+        return;
+    }
+    // ── Confirm (unless --yes) ────────────────────────────────────────────────
+    if (!opts.yes) {
+        const readline = await import('readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise(resolve => rl.question(chalk.bold('  Update now?') + chalk.dim(' [y/n] > '), a => { rl.close(); resolve(a.trim()); }));
+        if (answer !== 'y' && answer !== 'yes') {
+            console.log(chalk.dim('\n  Cancelled.\n'));
+            return;
+        }
+        console.log();
+    }
+    // ── npm install -g nexrall-code ───────────────────────────────────────────
+    process.stdout.write(chalk.dim(`  → Running npm install -g nexrall-code…`));
+    const { ok, usedSudo } = await npmInstallGlobal();
+    process.stdout.write('\r\x1b[K');
+    if (!ok) {
+        console.error(chalk.red('  ✗ Update failed. Run manually:'));
+        console.error(chalk.dim('  npm install -g nexrall-code'));
+        process.exit(1);
+    }
+    console.log(chalk.green(`  ✓ Updated → v${latest}${usedSudo ? ' (via sudo)' : ''}`));
+    console.log();
+    console.log(chalk.bold(`  Nexrall CLI v${latest} installed!`));
+    console.log(chalk.dim('  Restart your terminal or run: exec $SHELL'));
+    console.log();
+}