@sammorrowdrums/mcpi 0.70.9 → 0.85.0

package/dist/package-manager-cli.js

@@ -1,8 +1,17 @@
+import { join } from "node:path";
 import chalk from "chalk";
 import { selectConfig } from "./cli/config-selector.js";
-import { APP_NAME, getAgentDir } from "./config.js";
+import { createProjectTrustContext } from "./cli/project-trust.js";
+import { APP_NAME, CONFIG_DIR_NAME, detectInstallMethod, getAgentDir, getPackageDir, getSelfUpdateCommand, getSelfUpdateUnavailableInstruction, getSettingsPath, PACKAGE_NAME, VERSION, } from "./config.js";
+import { ModelRuntime } from "./core/model-runtime.js";
 import { DefaultPackageManager } from "./core/package-manager.js";
+import { resolveProjectTrusted } from "./core/project-trust.js";
+import { DefaultResourceLoader } from "./core/resource-loader.js";
 import { SettingsManager } from "./core/settings-manager.js";
+import { hasTrustRequiringProjectResources, ProjectTrustStore } from "./core/trust-manager.js";
+import { spawnProcess } from "./utils/child-process.js";
+import { formatVersionCheckError, getLatestPiRelease, isNewerPackageVersion } from "./utils/version-check.js";
+import { cleanupWindowsSelfUpdateQuarantine, quarantineWindowsNativeDependencies, } from "./utils/windows-self-update.js";
 function reportSettingsErrors(settingsManager, context) {
     const errors = settingsManager.drainErrors();
     for (const { scope, error } of errors) {
@@ -15,15 +24,30 @@ function reportSettingsErrors(settingsManager, context) {
 function getPackageCommandUsage(command) {
     switch (command) {
         case "install":
-            return `${APP_NAME} install <source> [-l]`;
+            return `${APP_NAME} install <source> [-l] [--approve|--no-approve]`;
         case "remove":
-            return `${APP_NAME} remove <source> [-l]`;
+            return `${APP_NAME} remove <source> [-l] [--approve|--no-approve]`;
         case "update":
-            return `${APP_NAME} update [source]`;
+            return `${APP_NAME} update [source|self|mcpi] [--self|--extensions|--models|--all] [--extension <source>] [--approve|--no-approve] [--force]`;
         case "list":
-            return `${APP_NAME} list`;
+            return `${APP_NAME} list [--approve|--no-approve]`;
     }
 }
+const CONFIG_COMMAND_USAGE = `${APP_NAME} config [-l] [--approve|--no-approve]`;
+function printConfigCommandHelp() {
+    console.log(`${chalk.bold("Usage:")}
+  ${CONFIG_COMMAND_USAGE}
+
+Open the resource configuration TUI to enable or disable package resources.
+Without -l, starts in global settings (${getSettingsPath()}).
+Press Tab in the TUI to switch between global and project-local modes.
+
+Options:
+  -l, --local       Edit project overrides (${CONFIG_DIR_NAME}/settings.json)
+  -a, --approve     Trust project-local files for this command with -l
+  -na, --no-approve Ignore project-local files for this command with -l
+`);
+}
 function printPackageCommandHelp(command) {
     switch (command) {
         case "install":
@@ -33,7 +57,9 @@ function printPackageCommandHelp(command) {
 Install a package and add it to settings.
 
 Options:
-  -l, --local    Install project-locally (.pi/settings.json)
+  -l, --local       Install project-locally (${CONFIG_DIR_NAME}/settings.json)
+  -a, --approve     Trust project-local files for this command
+  -na, --no-approve Ignore project-local files for this command
 
 Examples:
   ${APP_NAME} install npm:@foo/bar
@@ -52,7 +78,9 @@ Remove a package and its source from settings.
 Alias: ${APP_NAME} uninstall <source> [-l]
 
 Options:
-  -l, --local    Remove from project settings (.pi/settings.json)
+  -l, --local       Remove from project settings (${CONFIG_DIR_NAME}/settings.json)
+  -a, --approve     Trust project-local files for this command
+  -na, --no-approve Ignore project-local files for this command
 
 Examples:
   ${APP_NAME} remove npm:@foo/bar
@@ -63,8 +91,24 @@ Examples:
             console.log(`${chalk.bold("Usage:")}
   ${getPackageCommandUsage("update")}
 
-Update installed packages.
-If <source> is provided, only that package is updated.
+Update mcpi, installed packages, or model catalogs.
+
+Options:
+  --self                  Update mcpi only (default when no target is given)
+  --extensions            Update installed packages only
+  --models                Refresh model catalogs only
+  --all                   Update mcpi and installed packages
+  --extension <source>    Update one package only
+  -a, --approve           Trust project-local files for this command
+  -na, --no-approve       Ignore project-local files for this command
+  --force                 Reinstall mcpi even if the current version is latest
+
+Short forms:
+  ${APP_NAME} update                Update mcpi only
+  ${APP_NAME} update --all          Update mcpi and all extensions
+  ${APP_NAME} update --models       Refresh model catalogs only
+  ${APP_NAME} update <source>       Update one package
+  ${APP_NAME} update mcpi           Update mcpi only (self works as an alias)
 `);
             return;
         case "list":
@@ -72,6 +116,10 @@ If <source> is provided, only that package is updated.
   ${getPackageCommandUsage("list")}
 
 List installed packages from user and project settings.
+
+Options:
+  -a, --approve      Trust project-local files for this command
+  -na, --no-approve  Ignore project-local files for this command
 `);
             return;
     }
@@ -89,10 +137,21 @@ function parsePackageCommand(args) {
         return undefined;
     }
     let local = false;
+    let force = false;
+    let projectTrustOverride;
     let help = false;
     let invalidOption;
+    let invalidArgument;
+    let missingOptionValue;
+    let conflictingOptions;
     let source;
-    for (const arg of rest) {
+    let selfFlag = false;
+    let extensionsFlag = false;
+    let modelsFlag = false;
+    let allFlag = false;
+    let extensionFlagSource;
+    for (let index = 0; index < rest.length; index++) {
+        const arg = rest[index];
         if (arg === "-h" || arg === "--help") {
             help = true;
             continue;
@@ -106,6 +165,78 @@ function parsePackageCommand(args) {
             }
             continue;
         }
+        if (arg === "--self") {
+            if (command === "update") {
+                selfFlag = true;
+            }
+            else {
+                invalidOption = invalidOption ?? arg;
+            }
+            continue;
+        }
+        if (arg === "--extensions") {
+            if (command === "update") {
+                extensionsFlag = true;
+            }
+            else {
+                invalidOption = invalidOption ?? arg;
+            }
+            continue;
+        }
+        if (arg === "--models") {
+            if (command === "update") {
+                modelsFlag = true;
+            }
+            else {
+                invalidOption = invalidOption ?? arg;
+            }
+            continue;
+        }
+        if (arg === "--all") {
+            if (command === "update") {
+                allFlag = true;
+            }
+            else {
+                invalidOption = invalidOption ?? arg;
+            }
+            continue;
+        }
+        if (arg === "--approve" || arg === "-a") {
+            projectTrustOverride = true;
+            continue;
+        }
+        if (arg === "--no-approve" || arg === "-na") {
+            projectTrustOverride = false;
+            continue;
+        }
+        if (arg === "--force") {
+            if (command === "update") {
+                force = true;
+            }
+            else {
+                invalidOption = invalidOption ?? arg;
+            }
+            continue;
+        }
+        if (arg === "--extension") {
+            if (command !== "update") {
+                invalidOption = invalidOption ?? arg;
+                continue;
+            }
+            const value = rest[index + 1];
+            if (!value || value.startsWith("-")) {
+                missingOptionValue = missingOptionValue ?? arg;
+            }
+            else if (extensionFlagSource) {
+                conflictingOptions = conflictingOptions ?? "--extension can only be provided once";
+                index++;
+            }
+            else {
+                extensionFlagSource = value;
+                index++;
+            }
+            continue;
+        }
         if (arg.startsWith("-")) {
             invalidOption = invalidOption ?? arg;
             continue;
@@ -113,28 +244,308 @@ function parsePackageCommand(args) {
         if (!source) {
             source = arg;
         }
+        else {
+            invalidArgument = invalidArgument ?? arg;
+        }
+    }
+    let updateTarget;
+    let showExtensionsSkippedNote = false;
+    if (command === "update") {
+        if (allFlag && (selfFlag || extensionsFlag || modelsFlag || extensionFlagSource)) {
+            conflictingOptions =
+                conflictingOptions ?? "--all cannot be combined with --self, --extensions, --models, or --extension";
+        }
+        if (allFlag && source) {
+            conflictingOptions = conflictingOptions ?? "--all cannot be combined with a positional source";
+        }
+        if (modelsFlag) {
+            if (selfFlag || extensionsFlag || allFlag || extensionFlagSource) {
+                conflictingOptions =
+                    conflictingOptions ?? "--models cannot be combined with --self, --extensions, --all, or --extension";
+            }
+            if (source) {
+                conflictingOptions = conflictingOptions ?? "--models cannot be combined with a positional source";
+            }
+            updateTarget = { type: "models" };
+        }
+        else if (extensionFlagSource) {
+            if (selfFlag || extensionsFlag || allFlag) {
+                conflictingOptions =
+                    conflictingOptions ?? "--extension cannot be combined with --self, --extensions, or --all";
+            }
+            if (source) {
+                conflictingOptions = conflictingOptions ?? "--extension cannot be combined with a positional source";
+            }
+            updateTarget = { type: "extensions", source: extensionFlagSource };
+        }
+        else if (source) {
+            const sourceIsSelf = source === "self" || source === "mcpi";
+            if (sourceIsSelf) {
+                updateTarget = extensionsFlag ? { type: "all" } : { type: "self" };
+            }
+            else {
+                if (extensionsFlag || selfFlag || allFlag) {
+                    conflictingOptions =
+                        conflictingOptions ??
+                            "positional update targets cannot be combined with --self, --extensions, or --all";
+                }
+                updateTarget = { type: "extensions", source };
+            }
+        }
+        else if (allFlag) {
+            updateTarget = { type: "all" };
+        }
+        else if (selfFlag && extensionsFlag) {
+            updateTarget = { type: "all" };
+        }
+        else if (selfFlag) {
+            updateTarget = { type: "self" };
+        }
+        else if (extensionsFlag) {
+            updateTarget = { type: "extensions" };
+        }
+        else {
+            updateTarget = { type: "self" };
+            showExtensionsSkippedNote = true;
+        }
     }
-    return { command, source, local, help, invalidOption };
+    return {
+        command,
+        source,
+        updateTarget,
+        showExtensionsSkippedNote,
+        local,
+        force,
+        projectTrustOverride,
+        help,
+        invalidOption,
+        invalidArgument,
+        missingOptionValue,
+        conflictingOptions,
+    };
+}
+function updateTargetIncludesSelf(target) {
+    return target.type === "all" || target.type === "self";
+}
+function updateTargetIncludesExtensions(target) {
+    return target.type === "all" || target.type === "extensions";
 }
-export async function handleConfigCommand(args) {
-    if (args[0] !== "config") {
+async function refreshModelCatalogs(agentDir) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15_000);
+    try {
+        const modelRuntime = await ModelRuntime.create({
+            authPath: join(agentDir, "auth.json"),
+            modelsPath: join(agentDir, "models.json"),
+            allowModelNetwork: false,
+            signal: controller.signal,
+        });
+        const result = await modelRuntime.refresh({
+            allowNetwork: true,
+            force: true,
+            signal: controller.signal,
+        });
+        if (result.aborted) {
+            throw new Error("Model catalog refresh timed out.");
+        }
+        if (result.errors.size > 0) {
+            const details = Array.from(result.errors, ([provider, error]) => `${provider}: ${error.message}`).join("; ");
+            throw new Error(`Could not refresh model catalogs: ${details}`);
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    console.log(chalk.green("Model catalogs refreshed"));
+}
+function printSelfUpdateUnavailable(npmCommand, updatePackageTarget = PACKAGE_NAME) {
+    console.error(`error: ${APP_NAME} cannot self-update this installation.`);
+    console.error(getSelfUpdateUnavailableInstruction(PACKAGE_NAME, npmCommand, updatePackageTarget));
+    const entrypoint = process.argv[1];
+    if (entrypoint) {
+        console.error("");
+        console.error(`Location of ${APP_NAME} executable: ${entrypoint}`);
+    }
+}
+function printSelfUpdateFallback(command) {
+    console.error(chalk.dim(`If this keeps failing, run this command yourself: ${command.display}`));
+}
+function printPnpmSelfUpdateMetadataHint() {
+    console.error(chalk.yellow("If pnpm reports missing package versions, its cached registry metadata may be stale."));
+    console.error(chalk.yellow(`Run \`pnpm store prune\` and retry \`${APP_NAME} update --self\`.`));
+}
+async function getSelfUpdatePlan(force) {
+    let latestRelease;
+    try {
+        latestRelease = await getLatestPiRelease(VERSION, { retry: true });
+    }
+    catch (error) {
+        throw new Error(`Could not determine latest ${APP_NAME} version: ${formatVersionCheckError(error)}`, {
+            cause: error,
+        });
+    }
+    if (!latestRelease) {
+        throw new Error(`Could not determine latest ${APP_NAME} version.`);
+    }
+    const installSpec = `${PACKAGE_NAME}@${latestRelease.version}`;
+    if (force || isNewerPackageVersion(latestRelease.version, VERSION)) {
+        return {
+            packageName: PACKAGE_NAME,
+            installSpec,
+            version: latestRelease.version,
+            shouldRun: true,
+        };
+    }
+    console.log(chalk.green(`${APP_NAME} is already up to date (v${VERSION})`));
+    return { packageName: PACKAGE_NAME, installSpec, version: latestRelease.version, shouldRun: false };
+}
+async function runSelfUpdate(command) {
+    console.log(chalk.dim(`Updating ${APP_NAME} with ${command.display}...`));
+    for (const step of command.steps ?? [command]) {
+        await new Promise((resolve, reject) => {
+            const child = spawnProcess(step.command, step.args, {
+                stdio: "inherit",
+            });
+            child.on("error", (error) => {
+                reject(error);
+            });
+            child.on("close", (code, signal) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else if (signal) {
+                    reject(new Error(`${step.display} terminated by signal ${signal}`));
+                }
+                else {
+                    reject(new Error(`${step.display} exited with code ${code ?? "unknown"}`));
+                }
+            });
+        });
+    }
+}
+function prepareWindowsNpmSelfUpdate() {
+    if (process.platform !== "win32") {
+        return;
+    }
+    const packageDir = getPackageDir();
+    cleanupWindowsSelfUpdateQuarantine(packageDir);
+    quarantineWindowsNativeDependencies(packageDir);
+}
+function getCommandAppMode() {
+    return process.stdin.isTTY && process.stdout.isTTY ? "interactive" : "print";
+}
+function reportProjectTrustWarnings(warnings) {
+    for (const warning of warnings) {
+        console.error(chalk.yellow(`Warning: ${warning}`));
+    }
+}
+async function createCommandSettingsManager(options) {
+    const settingsManager = SettingsManager.create(options.cwd, options.agentDir, { projectTrusted: false });
+    const projectTrustWarnings = [];
+    const trustStore = new ProjectTrustStore(options.agentDir);
+    if (options.useSavedProjectTrustOnly) {
+        const savedProjectTrusted = trustStore.get(options.cwd) === true;
+        settingsManager.setProjectTrusted(options.projectTrustOverride ?? savedProjectTrusted);
+        return { settingsManager, projectTrustWarnings };
+    }
+    const appMode = getCommandAppMode();
+    const extensionsResult = options.projectTrustOverride === undefined && hasTrustRequiringProjectResources(options.cwd)
+        ? await new DefaultResourceLoader({
+            cwd: options.cwd,
+            agentDir: options.agentDir,
+            settingsManager,
+            extensionFactories: options.extensionFactories,
+        }).loadProjectTrustExtensions()
+        : undefined;
+    for (const error of extensionsResult?.errors ?? []) {
+        projectTrustWarnings.push(`Failed to load extension "${error.path}": ${error.error}`);
+    }
+    const projectTrusted = await resolveProjectTrusted({
+        cwd: options.cwd,
+        trustStore,
+        trustOverride: options.projectTrustOverride,
+        defaultProjectTrust: settingsManager.getDefaultProjectTrust(),
+        extensionsResult,
+        projectTrustContext: createProjectTrustContext({
+            cwd: options.cwd,
+            mode: appMode,
+            settingsManager,
+            hasUI: appMode === "interactive",
+        }),
+        onExtensionError: (message) => projectTrustWarnings.push(message),
+    });
+    settingsManager.setProjectTrusted(projectTrusted);
+    return { settingsManager, projectTrustWarnings };
+}
+export async function handleConfigCommand(args, runtimeOptions = {}) {
+    const [command, ...rest] = args;
+    if (command !== "config") {
         return false;
     }
+    if (rest.includes("-h") || rest.includes("--help")) {
+        printConfigCommandHelp();
+        return true;
+    }
+    let local = false;
+    let projectTrustOverride;
+    for (const arg of rest) {
+        if (arg === "-l" || arg === "--local") {
+            local = true;
+        }
+        else if (arg === "-a" || arg === "--approve") {
+            projectTrustOverride = true;
+        }
+        else if (arg === "-na" || arg === "--no-approve") {
+            projectTrustOverride = false;
+        }
+        else if (arg.startsWith("-")) {
+            console.error(chalk.red(`Unknown option ${arg} for "config".`));
+            console.error(chalk.dim(`Use "${APP_NAME} --help" or "${CONFIG_COMMAND_USAGE}".`));
+            process.exitCode = 1;
+            return true;
+        }
+        else {
+            console.error(chalk.red(`Unexpected argument ${arg}.`));
+            console.error(chalk.dim(`Usage: ${CONFIG_COMMAND_USAGE}`));
+            process.exitCode = 1;
+            return true;
+        }
+    }
     const cwd = process.cwd();
     const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
+    const { settingsManager, projectTrustWarnings } = await createCommandSettingsManager({
+        cwd,
+        agentDir,
+        projectTrustOverride,
+        extensionFactories: runtimeOptions.extensionFactories,
+    });
+    reportProjectTrustWarnings(projectTrustWarnings);
+    if (local && !settingsManager.isProjectTrusted()) {
+        console.error(chalk.red("Project is not trusted. Use --approve to modify local resource config."));
+        process.exitCode = 1;
+        return true;
+    }
     reportSettingsErrors(settingsManager, "config command");
-    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-    const resolvedPaths = await packageManager.resolve();
+    const globalSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
+    const globalResolvedPaths = await new DefaultPackageManager({
+        cwd,
+        agentDir,
+        settingsManager: globalSettingsManager,
+    }).resolve();
+    const projectResolvedPaths = settingsManager.isProjectTrusted()
+        ? await new DefaultPackageManager({ cwd, agentDir, settingsManager }).resolve()
+        : globalResolvedPaths;
     await selectConfig({
-        resolvedPaths,
+        resolvedPaths: { global: globalResolvedPaths, project: projectResolvedPaths },
         settingsManager,
         cwd,
         agentDir,
+        writeScope: local ? "project" : "global",
+        projectModeAvailable: settingsManager.isProjectTrusted(),
     });
     process.exit(0);
 }
-export async function handlePackageCommand(args) {
+export async function handlePackageCommand(args, runtimeOptions = {}) {
     const options = parsePackageCommand(args);
     if (!options) {
         return false;
@@ -149,6 +560,24 @@ export async function handlePackageCommand(args) {
         process.exitCode = 1;
         return true;
     }
+    if (options.missingOptionValue) {
+        console.error(chalk.red(`Missing value for ${options.missingOptionValue}.`));
+        console.error(chalk.dim(`Usage: ${getPackageCommandUsage(options.command)}`));
+        process.exitCode = 1;
+        return true;
+    }
+    if (options.invalidArgument) {
+        console.error(chalk.red(`Unexpected argument ${options.invalidArgument}.`));
+        console.error(chalk.dim(`Usage: ${getPackageCommandUsage(options.command)}`));
+        process.exitCode = 1;
+        return true;
+    }
+    if (options.conflictingOptions) {
+        console.error(chalk.red(options.conflictingOptions));
+        console.error(chalk.dim(`Usage: ${getPackageCommandUsage(options.command)}`));
+        process.exitCode = 1;
+        return true;
+    }
     const source = options.source;
     if ((options.command === "install" || options.command === "remove") && !source) {
         console.error(chalk.red(`Missing ${options.command} source.`));
@@ -156,10 +585,35 @@ export async function handlePackageCommand(args) {
         process.exitCode = 1;
         return true;
     }
+    if (options.command === "update" && options.updateTarget?.type === "models") {
+        try {
+            await refreshModelCatalogs(getAgentDir());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown model catalog refresh error";
+            console.error(chalk.red(`Error: ${message}`));
+            process.exitCode = 1;
+        }
+        return true;
+    }
     const cwd = process.cwd();
     const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
+    const writesProjectPackageConfig = (options.command === "install" || options.command === "remove") && options.local;
+    const { settingsManager, projectTrustWarnings } = await createCommandSettingsManager({
+        cwd,
+        agentDir,
+        projectTrustOverride: options.projectTrustOverride,
+        useSavedProjectTrustOnly: options.command === "update",
+        extensionFactories: runtimeOptions.extensionFactories,
+    });
+    reportProjectTrustWarnings(projectTrustWarnings);
+    if (!settingsManager.isProjectTrusted() && writesProjectPackageConfig) {
+        console.error(chalk.red("Project is not trusted. Use --approve to modify local package config."));
+        process.exitCode = 1;
+        return true;
+    }
     reportSettingsErrors(settingsManager, "package command");
+    const selfUpdateNpmCommand = settingsManager.getGlobalSettings().npmCommand;
     const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
     packageManager.setProgressCallback((event) => {
         if (event.type === "start") {
@@ -213,15 +667,63 @@ export async function handlePackageCommand(args) {
                 }
                 return true;
             }
-            case "update":
-                await packageManager.update(source);
-                if (source) {
-                    console.log(chalk.green(`Updated ${source}`));
+            case "update": {
+                const target = options.updateTarget ?? { type: "self" };
+                if (options.showExtensionsSkippedNote) {
+                    console.log(chalk.dim(`Extensions are skipped. Run ${APP_NAME} update --extensions to update extensions.`));
                 }
-                else {
-                    console.log(chalk.green("Updated packages"));
+                if (updateTargetIncludesExtensions(target)) {
+                    const updateSource = target.type === "extensions" ? target.source : undefined;
+                    await packageManager.update(updateSource);
+                    if (updateSource) {
+                        console.log(chalk.green(`Updated ${updateSource}`));
+                    }
+                    else {
+                        console.log(chalk.green("Updated packages"));
+                    }
+                }
+                if (updateTargetIncludesSelf(target)) {
+                    const selfUpdatePlan = await getSelfUpdatePlan(options.force);
+                    if (!selfUpdatePlan.shouldRun) {
+                        return true;
+                    }
+                    const installMethod = detectInstallMethod();
+                    if (process.platform === "win32" && installMethod !== "npm" && installMethod !== "pnpm") {
+                        console.error(chalk.red(`${APP_NAME} self-update on Windows is only supported for npm and pnpm installs.`));
+                        console.error(chalk.dim(`Detected install method: ${installMethod}. Update ${APP_NAME} manually.`));
+                        process.exitCode = 1;
+                        return true;
+                    }
+                    const selfUpdateTarget = {
+                        packageName: selfUpdatePlan.packageName,
+                        installSpec: selfUpdatePlan.installSpec,
+                    };
+                    const selfUpdateCommand = getSelfUpdateCommand(PACKAGE_NAME, selfUpdateNpmCommand, selfUpdateTarget);
+                    if (!selfUpdateCommand) {
+                        printSelfUpdateUnavailable(selfUpdateNpmCommand, selfUpdateTarget);
+                        process.exitCode = 1;
+                        return true;
+                    }
+                    try {
+                        if (installMethod === "npm") {
+                            prepareWindowsNpmSelfUpdate();
+                        }
+                        await runSelfUpdate(selfUpdateCommand);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : "Unknown package command error";
+                        console.error(chalk.red(`Error: ${message}`));
+                        if (installMethod === "pnpm") {
+                            printPnpmSelfUpdateMetadataHint();
+                        }
+                        printSelfUpdateFallback(selfUpdateCommand);
+                        process.exitCode = 1;
+                        return true;
+                    }
+                    console.log(chalk.green(`Updated ${APP_NAME} from ${VERSION} to ${selfUpdatePlan.version}`));
                 }
                 return true;
+            }
         }
     }
     catch (error) {