dexbot 1.4.15 → 1.4.17

package/dist/scripts/update.js

@@ -2,11 +2,23 @@
 /**
  * DEXBot2 Auto-Update Script
  *
- * Manages pulling latest code from git repository with smart logic:
- * - Fetches from configured remote repository
- * - Detects if updates are available
- * - Handles branch switching if needed
- * - Reinstalls npm dependencies
+ * Supports two installation layouts:
+ *
+ * 1. Git checkout:
+ *    - Fetches from configured remote repository
+ *    - Detects if updates are available
+ *    - Handles branch switching if needed
+ *    - Reinstalls npm dependencies and rebuilds TypeScript sources
+ *
+ * 2. npm package install (e.g. `npm install -g dexbot`):
+ *    - Compares the installed version against the npm registry
+ *    - Runs `npm install -g <pkg>@<latest>` to fetch the newest release
+ *    - Skips the git and local build steps (published packages are pre-built)
+ *    - Requires the npm CLI and registry access; only global installs can be
+ *      updated in place (local `node_modules` deps must be updated from the
+ *      parent project with `npm update`)
+ *
+ * Shared tail for both layouts:
  * - Selectively restarts active runtime processes
  * - Gracefully handles missing files or PM2
  *
@@ -23,11 +35,12 @@
 import { execSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
+import { homedir } from 'node:os';
 import { sendControlCommand } from '../modules/launcher/supervisor_control.js';
 // Import update configuration from constants
 // Contains: REPOSITORY_URL, BRANCH, BUILD_DIR settings
 import { UPDATER, BUILD_DIR } from '../modules/constants.js';
-import { PATHS } from '../modules/paths.js';
+import { PATHS, isGlobalNpmPackageDir } from '../modules/paths.js';
 import { Config } from '../modules/config.js';
 import { getStorage } from '../modules/storage/index.js';
 const { readJSON } = getStorage();
@@ -60,24 +73,139 @@ function updateError(msg) {
     return colorUpdateOutput(msg, UPDATE_COLORS.error, process.stderr);
 }
 /**
- * run: Execute shell command with error handling
+ * runIn: Execute shell command in a given working directory with error handling
  *
  * Runs command with inherited stdio so user sees full output.
  * Throws error if command fails, breaking update process.
  *
+ * @param {string} cwd - Working directory for the command
  * @param {string} cmd - Shell command to execute
  * @throws {Error} If command exits with non-zero status
  */
-function run(cmd) {
+function runIn(cwd, cmd) {
     log(`Executing: ${cmd}`);
     try {
-        execSync(cmd, { stdio: 'inherit', cwd: PATHS.PROJECT_ROOT });
+        execSync(cmd, { stdio: 'inherit', cwd });
     }
     catch (err) {
         console.error(updateError(`[ERROR] Command failed: ${cmd}`));
         throw err;
     }
 }
+/**
+ * run: Execute shell command in the project root with error handling
+ *
+ * Runs command with inherited stdio so user sees full output.
+ * Throws error if command fails, breaking update process.
+ *
+ * @param {string} cmd - Shell command to execute
+ * @throws {Error} If command exits with non-zero status
+ */
+function run(cmd) {
+    runIn(PATHS.PROJECT_ROOT, cmd);
+}
+// ── npm-install helpers ──────────────────────────────────────────────
+function readPackageJson(root) {
+    try {
+        return readJSON(path.join(root, 'package.json'));
+    }
+    catch (_) {
+        return null;
+    }
+}
+function readPackageVersion(root) {
+    const pkg = readPackageJson(root);
+    return typeof pkg?.version === 'string' ? pkg.version : '';
+}
+function readPackageName(root) {
+    const pkg = readPackageJson(root);
+    return typeof pkg?.name === 'string' && pkg.name ? pkg.name : 'dexbot';
+}
+/**
+ * compareVersions: Minimal semver comparison for major.minor.patch strings.
+ *
+ * Returns a negative number when a < b, zero when equal, positive when a > b.
+ * Prerelease/build suffixes are ignored (sufficient for update detection).
+ */
+function compareVersions(a, b) {
+    const na = a.split('.').map((n) => parseInt(n, 10) || 0);
+    const nb = b.split('.').map((n) => parseInt(n, 10) || 0);
+    const len = Math.max(na.length, nb.length);
+    for (let i = 0; i < len; i++) {
+        const va = na[i] ?? 0;
+        const vb = nb[i] ?? 0;
+        if (va !== vb)
+            return va < vb ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * getNpmLatestVersion: Query the npm registry for the latest published version.
+ *
+ * Throws when the registry is unreachable so the update is treated as failed
+ * (exit 1) and the scheduler does not restart the daemon for a no-op.
+ */
+function getNpmLatestVersion(pkgName) {
+    try {
+        const version = execSync(`npm view ${pkgName} version`, { stdio: 'pipe' }).toString().trim();
+        if (!version)
+            throw new Error('npm returned an empty version.');
+        return version;
+    }
+    catch (err) {
+        throw new Error(`Could not reach the npm registry to check for updates (${getErrorMessage(err)}).`);
+    }
+}
+/**
+ * getGlobalNpmRoot: Resolve the npm global install root (e.g. <prefix>/lib/node_modules).
+ * Returns an empty string when npm is unavailable.
+ */
+function getGlobalNpmRoot() {
+    try {
+        // npm prints only the root to stdout, but notifications can land there
+        // in some setups — take the LAST non-empty line so a stray leading
+        // notice cannot produce a garbage path.
+        const lines = execSync('npm root -g', { stdio: 'pipe' }).toString().split('\n').filter((l) => l.trim());
+        return lines.length > 0 ? lines[lines.length - 1].trim() : '';
+    }
+    catch (_) {
+        return '';
+    }
+}
+/**
+ * Resolve a path to its real filesystem location, falling back to the
+ * lexical path when realpath fails (e.g. a missing intermediate component).
+ */
+function realpathSafe(p) {
+    try {
+        return fs.realpathSync.native(p);
+    }
+    catch {
+        try {
+            return fs.realpathSync(p);
+        }
+        catch {
+            return p;
+        }
+    }
+}
+/**
+ * True when the project root is a DIRECT child of the npm global install root
+ * (e.g. <prefix>/lib/node_modules/dexbot). Comparing the immediate parent —
+ * rather than a string prefix — rejects nested packages, custom `--prefix`
+ * layouts where the package lives deeper in the tree, and relative/absolute
+ * path mismatches. Both sides are realpath'd so a symlinked global prefix
+ * (e.g. a nvm/system prefix with a symlink component) is not falsely
+ * rejected: import.meta.url already realpaths PROJECT_ROOT, while `npm
+ * root -g` returns the un-resolved prefix. Symlinked layouts (e.g. `npm
+ * link`) resolve to the real package location, which is intentionally not a
+ * global-root child, so they fall through to the manual-update error below.
+ */
+function isDirectGlobalInstall(projectRoot, globalRoot) {
+    const resolvedRoot = realpathSafe(path.resolve(globalRoot));
+    const resolvedProject = realpathSafe(path.resolve(projectRoot));
+    return path.dirname(resolvedProject) === resolvedRoot;
+}
 function readLivePidFile(filePath) {
     if (!fs.existsSync(filePath))
         return 0;
@@ -236,21 +364,288 @@ async function restartActiveIsolatedProcesses() {
     await sendControlCommand({ cmd: 'restart-running' });
     return true;
 }
+// ── Shared update tail (both git and npm layouts) ────────────────────
+/**
+ * Snapshot pre-update runtime state BEFORE touching code (git pull or
+ * `npm install -g`). The daemon may shut down during the operation (e.g.
+ * a prepare hook or build), erasing its PID file. By capturing state up
+ * front, we can still restart it after the update completes.
+ */
+function snapshotMonolithicState() {
+    const monolithicWasRunning = !!detectMonolithicRuntime();
+    const hadMonolithicFiles = detectAnyMonolithicFiles();
+    if (monolithicWasRunning) {
+        log('Monolithic daemon detected running before update. Will restart after update.');
+    }
+    else if (hadMonolithicFiles) {
+        log('Monolithic PID/file artifacts found but daemon is not alive. Will attempt restart after update.');
+    }
+    return { monolithicWasRunning, hadMonolithicFiles };
+}
+/**
+ * Regenerate the PM2 ecosystem config so profiles/ecosystem.config.cjs
+ * reflects the current bots.json state (including dexbot-adapter and
+ * dexbot-update service apps). Uses the freshly compiled dist/pm2.js.
+ */
+async function regenerateEcosystemConfig() {
+    log('Regenerating PM2 ecosystem config...');
+    try {
+        // Try loading from compiled dist/ first, then fall back to source dir
+        const distPath = path.join(PATHS.PROJECT_ROOT, BUILD_DIR, 'pm2.js');
+        const pm2Module = fs.existsSync(distPath)
+            ? await import(distPath)
+            : await import(path.join(PATHS.PROJECT_ROOT, 'pm2.js'));
+        pm2Module.generateEcosystemConfig({ clawOnly: false, exitOnError: false });
+        log('Ecosystem config regenerated successfully.');
+    }
+    catch (err) {
+        log(`Warning: Ecosystem config regeneration failed (${getErrorMessage(err)}). Continuing with existing config.`);
+    }
+}
+/**
+ * Restart active runtime processes after an update so the new code is picked
+ * up. Handles, in order of preference:
+ * - Monolithic daemon (SIGUSR2 restart)
+ * - Isolated supervisor (control-command restart)
+ * - PM2 selective restart from bots.json
+ * - Fallback auto-start of a monolithic daemon that died during the update
+ * Never touches dexbot-cred through bulk PM2 actions.
+ */
+async function restartActiveRuntimes({ monolithicWasRunning, hadMonolithicFiles }) {
+    let restarted = false;
+    log('Restarting active runtime processes...');
+    try {
+        if (Config.DEXBOT_UPDATE_SKIP_RELOAD) {
+            log('Restart skipped (managed by launcher).');
+            restarted = true;
+        }
+        else {
+            const monolithic = detectMonolithicRuntime();
+            if (monolithic) {
+                restartMonolithicRuntime(monolithic);
+                restarted = true;
+            }
+            else if (await restartActiveIsolatedProcesses()) {
+                log('Isolated supervisor runtime restarted.');
+                restarted = true;
+            }
+            else {
+                const BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
+                if (fs.existsSync(BOTS_FILE)) {
+                    const raw = fs.readFileSync(BOTS_FILE, 'utf8');
+                    const stripped = raw.replace(/\/\*(?:.|[\r\n])*?\*\//g, '').replace(/(^|\s*)\/\/.*$/gm, '');
+                    const config = JSON.parse(stripped);
+                    const activeInConfig = (config.bots || [])
+                        .filter((b) => b.active !== false)
+                        .map((b) => b.name)
+                        .filter((name) => !!name);
+                    if (activeInConfig.length > 0) {
+                        let runningProcesses = [];
+                        try {
+                            const output = execSync('pm2 jlist').toString().trim();
+                            const jsonStart = output.indexOf('[');
+                            if (jsonStart !== -1) {
+                                const jsonPart = output.substring(jsonStart);
+                                const parsed = JSON.parse(jsonPart);
+                                runningProcesses = parsed.map((p) => p.name);
+                            }
+                            else {
+                                log('Warning: PM2 jlist output did not contain JSON array.');
+                            }
+                        }
+                        catch (e) {
+                            log('Warning: Could not fetch PM2 process list. Falling back to config-only detection.');
+                            runningProcesses = activeInConfig;
+                        }
+                        const botsToRestart = activeInConfig.filter((name) => runningProcesses.includes(name));
+                        const activeBots = (config.bots || []).filter((b) => b.active !== false);
+                        const runningActiveBots = activeBots.filter((b) => runningProcesses.includes(b.name));
+                        const maPath = path.join(PATHS.PROJECT_ROOT, BUILD_DIR, 'pm2.js');
+                        const pm2Module = fs.existsSync(maPath)
+                            ? await import(maPath)
+                            : await import(path.join(PATHS.PROJECT_ROOT, 'pm2.js'));
+                        const marketAdapterRequired = pm2Module.needsMarketAdapter(runningActiveBots);
+                        const serviceAppsToRestart = marketAdapterRequired ? ['dexbot-adapter'] : [];
+                        const servicesToRestart = serviceAppsToRestart.filter((name) => runningProcesses.includes(name));
+                        const allToRestart = [...botsToRestart, ...servicesToRestart];
+                        if (allToRestart.length > 0) {
+                            log(`Active processes detected: ${allToRestart.join(', ')}`);
+                            for (const name of allToRestart) {
+                                try {
+                                    run(`pm2 restart "${name}"`);
+                                }
+                                catch (e) {
+                                    log(`Warning: Failed to restart process "${name}" (it might not be running).`);
+                                }
+                            }
+                            restarted = true;
+                        }
+                        else {
+                            log('No active processes currently running in PM2. Skipping restart.');
+                        }
+                        if (marketAdapterRequired && !runningProcesses.includes('dexbot-adapter')) {
+                            log('dexbot-adapter is required by an AMA-grid bot but not running. Starting from ecosystem...');
+                            try {
+                                run(`pm2 start "${PATHS.PROFILES.ECOSYSTEM_CONFIG_JS}" --only dexbot-adapter`);
+                            }
+                            catch (e) {
+                                log('Warning: Failed to start dexbot-adapter from ecosystem config.');
+                            }
+                        }
+                    }
+                    else {
+                        log('No active bots found in config.');
+                    }
+                }
+                else {
+                    log('Warning: profiles/bots.json not found, skipping selective restart.');
+                }
+            }
+        }
+    }
+    catch (err) {
+        log(`Warning: runtime restart logic failed (${getErrorMessage(err)}). Skipping bulk restart to avoid touching dexbot-cred.`);
+    }
+    // Fallback restart for monolithic daemon that died during the update
+    if (!restarted && !Config.DEXBOT_UPDATE_SKIP_RELOAD) {
+        if (monolithicWasRunning || hadMonolithicFiles) {
+            log('Monolithic daemon was detected before update but is no longer running. Auto-starting...');
+            if (startMonolithicRuntime()) {
+                restarted = true;
+            }
+            else {
+                log('Auto-start did not succeed; the manual-start instructions below apply.');
+            }
+        }
+    }
+    if (!restarted) {
+        console.log(colorUpdateOutput('\n⚠️  No active runtime was restarted.\n' +
+            '   If the daemon was running before, start it manually from a terminal:\n' +
+            '     dexbot start\n' +
+            '   (will prompt for master password; add --foreground for interactive mode)\n' +
+            '   For non-interactive automation:\n' +
+            '     dexbot start --headless --password-file <path>\n', UPDATE_COLORS.warn));
+    }
+}
+// ── npm-install update flow ──────────────────────────────────────────
+/**
+ * Update a globally installed npm package to the latest published version.
+ *
+ * Steps:
+ * 1. Compare installed package.json version against the npm registry.
+ * 2. Exit cleanly (0) when already up to date — no restart needed.
+ * 3. Verify this is a global install (only that layout can be replaced in place).
+ * 4. Snapshot runtime state, then run `npm install -g <pkg>@<latest>` from a
+ *    neutral cwd (home dir) so npm can freely swap the package directory the
+ *    currently running process executes from.
+ * 5. Regenerate the ecosystem config and restart active runtimes using the
+ *    new code — the published package ships a pre-built dist/, so there is
+ *    no local TypeScript build step.
+ */
+async function runNpmUpdateFlow() {
+    log('Detected npm package installation. Checking npm registry for updates...');
+    const pkgName = readPackageName(PATHS.PROJECT_ROOT);
+    const currentVersion = readPackageVersion(PATHS.PROJECT_ROOT);
+    if (!currentVersion) {
+        throw new Error(`Could not read a version from package.json at ${PATHS.PROJECT_ROOT}.`);
+    }
+    log(`Current installed version: ${currentVersion}`);
+    // Verify the npm CLI is available and this is a genuine global install
+    // BEFORE querying the registry. Only a global layout can be replaced in
+    // place by `npm install -g`; a local (project) dependency must be updated
+    // from its own package tree instead.
+    const globalRoot = getGlobalNpmRoot();
+    if (!globalRoot) {
+        throw new Error('DEXBot2 auto-update requires the npm CLI with registry access (it runs `npm view` and ' +
+            '`npm install -g`). npm could not be found on PATH or returned no global root. ' +
+            'Install Node.js/npm or update the package manually.');
+    }
+    if (!isDirectGlobalInstall(PATHS.PROJECT_ROOT, globalRoot)) {
+        // A genuine local (non-global) dependency resolves to a different real
+        // parent; a symlinked prefix or version-manager/pnpm store lands the
+        // package somewhere `npm root -g` does not point at. Either way the
+        // package cannot be swapped in place.
+        throw new Error('DEXBot2 is installed at ' + PATHS.PROJECT_ROOT + ' but `npm root -g` reports ' + globalRoot + '. ' +
+            'Auto-update cannot replace the package in place; the install root differs from `npm root -g` ' +
+            '(a symlinked prefix, pnpm/yarn global store, or a different Node version manager prefix). ' +
+            'Run `npm update ' + pkgName + '` in the parent project directory, or fix the mismatch and re-run `dexbot update`.');
+    }
+    const latestVersion = getNpmLatestVersion(pkgName);
+    log(`Latest published version: ${latestVersion}`);
+    if (compareVersions(currentVersion, latestVersion) >= 0) {
+        log('DEXBot2 is already up to date (installed version matches or exceeds the latest published version).');
+        process.exit(0);
+    }
+    log(`${currentVersion} -> ${latestVersion} update available. Proceeding with npm update...`);
+    // Snapshot pre-update runtime state BEFORE npm replaces the package files.
+    const snapshot = snapshotMonolithicState();
+    // Run from a neutral cwd: npm's reify swaps the package directory this
+    // process is executing from, so the working directory may briefly not exist.
+    runIn(homedir(), `npm install -g ${pkgName}@${latestVersion}`);
+    // Post-install sanity checks: the published package is pre-built, so a
+    // successful `npm install -g` MUST leave the requested version and a
+    // usable dist/ bundle behind. Refuse to restart runtimes against a broken
+    // install (mirrors the git flow's staleness guard).
+    const installedAfter = readPackageVersion(PATHS.PROJECT_ROOT);
+    log(`Installed version after update: ${installedAfter || 'unknown'}`);
+    if (!installedAfter) {
+        throw new Error(`Update completed but the package version could not be read at ${PATHS.PROJECT_ROOT}. ` +
+            `The global install may be broken; inspect it with \`npm ls -g ${pkgName}\`.`);
+    }
+    if (compareVersions(installedAfter, latestVersion) < 0) {
+        throw new Error(`Update completed but the installed version (${installedAfter}) is older than the requested ` +
+            `${latestVersion}. Run \`npm install -g ${pkgName}@${latestVersion}\` manually and inspect the npm output.`);
+    }
+    // Verify the pre-built bundle is complete: the `dexbot` bin entry plus the
+    // runtime files this script and the launcher depend on. Published packages
+    // ship a pre-built dist/, so a missing file here means the publish is
+    // broken and restarting runtimes against it would strand them on a dead
+    // install.
+    const distEntries = [
+        path.join(PATHS.PROJECT_ROOT, BUILD_DIR, 'dexbot.js'),
+        path.join(PATHS.PROJECT_ROOT, BUILD_DIR, 'scripts', 'update.js'),
+        path.join(PATHS.PROJECT_ROOT, BUILD_DIR, 'unlock.js'),
+    ];
+    const missingDist = distEntries.filter((entry) => !fs.existsSync(entry));
+    if (missingDist.length > 0) {
+        throw new Error(`Update completed but ${BUILD_DIR}/ is missing required files (${missingDist.join(', ')}). ` +
+            `The published package appears to ship no pre-built bundle; refusing to restart runtimes against ` +
+            `a broken install.`);
+    }
+    log(`${BUILD_DIR}/ verified after update.`);
+    await regenerateEcosystemConfig();
+    await restartActiveRuntimes(snapshot);
+}
 (async () => {
     try {
         // Change to project root for all git operations
         process.chdir(PATHS.PROJECT_ROOT);
         log('Starting DEXBot2 update process...');
-        // Get configured repository URL and target branch
-        const repoUrl = UPDATER.REPOSITORY_URL;
-        let branch = UPDATER.BRANCH;
         /**
-         * STEP 1: Validate Git Repository
-         * Ensures .git directory exists so we can perform git operations
+         * STEP 0: Detect Installation Layout
+         *
+         * Two supported layouts:
+         * 1. Git checkout (has a .git dir) -> git pull + npm install + build
+         * 2. Global npm package install (path under a node_modules tree) ->
+         *    `npm install -g <pkg>@<latest>` (pre-built dist, no local build)
+         *
+         * A git checkout wins over the npm path so a repo that was npm-linked is
+         * still updated through git. Neither layout -> fail with a clear message.
          */
-        if (!fs.existsSync(path.join(PATHS.PROJECT_ROOT, '.git'))) {
-            throw new Error('Not a git repository. If installed from npm, run: npm update -g dexbot');
+        const isGitRepo = fs.existsSync(path.join(PATHS.PROJECT_ROOT, '.git'));
+        const isNpmInstall = isGlobalNpmPackageDir(PATHS.PROJECT_ROOT);
+        if (!isGitRepo && isNpmInstall) {
+            await runNpmUpdateFlow();
+            logSuccess('DEXBot2 update completed successfully.');
+            process.exit(0);
+        }
+        if (!isGitRepo) {
+            throw new Error('DEXBot2 is neither a git checkout nor an npm package install. ' +
+                'Auto-update is not available for this installation.');
         }
+        // Get configured repository URL and target branch
+        const repoUrl = UPDATER.REPOSITORY_URL;
+        let branch = UPDATER.BRANCH;
         /**
          * STEP 2: Detect Current Branch
          * Gets the current checked-out branch name
@@ -350,14 +745,9 @@ async function restartActiveIsolatedProcesses() {
          * hook or build), erasing its PID file. By capturing state up front,
          * we can still restart it after the build completes.
          */
-        const monolithicWasRunning = !!detectMonolithicRuntime();
-        const hadMonolithicFiles = detectAnyMonolithicFiles();
-        if (monolithicWasRunning) {
-            log('Monolithic daemon detected running before update. Will restart after build.');
-        }
-        else if (hadMonolithicFiles) {
-            log('Monolithic PID/file artifacts found but daemon is not alive. Will attempt restart after build.');
-        }
+        const snapshot = snapshotMonolithicState();
+        const monolithicWasRunning = snapshot.monolithicWasRunning;
+        const hadMonolithicFiles = snapshot.hadMonolithicFiles;
         /**
          * STEP 6b: Prepare Working Directory
          * Stashes local changes to ensure a clean pull.
@@ -489,157 +879,15 @@ async function restartActiveIsolatedProcesses() {
          * state, including service apps like dexbot-adapter and dexbot-update.
          * Uses the compiled dist/pm2.js (after TS build) for correct dist/ paths.
          */
-        log('Regenerating PM2 ecosystem config...');
-        try {
-            // Try loading from compiled dist/ first, then fall back to source dir
-            const distPath = path.join(PATHS.PROJECT_ROOT, BUILD_DIR, 'pm2.js');
-            const pm2Module = fs.existsSync(distPath)
-                ? await import(distPath)
-                : await import(path.join(PATHS.PROJECT_ROOT, 'pm2.js'));
-            pm2Module.generateEcosystemConfig({ clawOnly: false, exitOnError: false });
-            log('Ecosystem config regenerated successfully.');
-        }
-        catch (err) {
-            log(`Warning: Ecosystem config regeneration failed (${getErrorMessage(err)}). Continuing with existing config.`);
-        }
+        await regenerateEcosystemConfig();
         /**
-         * STEP 9: Restart Active Runtime Processes
+         * STEP 9/9b: Restart Active Runtime Processes
          * Intelligently restarts only the bots that were active before update
-         * This approach:
-         * - Preserves PM2 state if not running
-         * - Restarts active bots to pick up code changes
-         * - Handles missing bots.json gracefully
-         * - Never restarts dexbot-cred through bulk PM2 actions
-         *
-         * Uses the pre-update snapshot (monolithicWasRunning) as a fallback:
-         * if the daemon shut down during git/npm ops and its PID file is gone,
-         * we still attempt to restart it.
-         */
-        let restarted = false;
-        log('Restarting active runtime processes...');
-        try {
-            if (Config.DEXBOT_UPDATE_SKIP_RELOAD) {
-                log('Restart skipped (managed by launcher).');
-                restarted = true;
-            }
-            else {
-                const monolithic = detectMonolithicRuntime();
-                if (monolithic) {
-                    restartMonolithicRuntime(monolithic);
-                    restarted = true;
-                }
-                else if (await restartActiveIsolatedProcesses()) {
-                    log('Isolated supervisor runtime restarted.');
-                    restarted = true;
-                }
-                else {
-                    const BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
-                    if (fs.existsSync(BOTS_FILE)) {
-                        const raw = fs.readFileSync(BOTS_FILE, 'utf8');
-                        const stripped = raw.replace(/\/\*(?:.|[\r\n])*?\*\//g, '').replace(/(^|\s*)\/\/.*$/gm, '');
-                        const config = JSON.parse(stripped);
-                        const activeInConfig = (config.bots || [])
-                            .filter((b) => b.active !== false)
-                            .map((b) => b.name)
-                            .filter((name) => !!name);
-                        if (activeInConfig.length > 0) {
-                            let runningProcesses = [];
-                            try {
-                                const output = execSync('pm2 jlist').toString().trim();
-                                const jsonStart = output.indexOf('[');
-                                if (jsonStart !== -1) {
-                                    const jsonPart = output.substring(jsonStart);
-                                    const parsed = JSON.parse(jsonPart);
-                                    runningProcesses = parsed.map((p) => p.name);
-                                }
-                                else {
-                                    log('Warning: PM2 jlist output did not contain JSON array.');
-                                }
-                            }
-                            catch (e) {
-                                log('Warning: Could not fetch PM2 process list. Falling back to config-only detection.');
-                                runningProcesses = activeInConfig;
-                            }
-                            const botsToRestart = activeInConfig.filter((name) => runningProcesses.includes(name));
-                            const activeBots = (config.bots || []).filter((b) => b.active !== false);
-                            const runningActiveBots = activeBots.filter((b) => runningProcesses.includes(b.name));
-                            const maPath = path.join(PATHS.PROJECT_ROOT, BUILD_DIR, 'pm2.js');
-                            const pm2Module = fs.existsSync(maPath)
-                                ? await import(maPath)
-                                : await import(path.join(PATHS.PROJECT_ROOT, 'pm2.js'));
-                            const marketAdapterRequired = pm2Module.needsMarketAdapter(runningActiveBots);
-                            const serviceAppsToRestart = marketAdapterRequired ? ['dexbot-adapter'] : [];
-                            const servicesToRestart = serviceAppsToRestart.filter((name) => runningProcesses.includes(name));
-                            const allToRestart = [...botsToRestart, ...servicesToRestart];
-                            if (allToRestart.length > 0) {
-                                log(`Active processes detected: ${allToRestart.join(', ')}`);
-                                for (const name of allToRestart) {
-                                    try {
-                                        run(`pm2 restart "${name}"`);
-                                    }
-                                    catch (e) {
-                                        log(`Warning: Failed to restart process "${name}" (it might not be running).`);
-                                    }
-                                }
-                                restarted = true;
-                            }
-                            else {
-                                log('No active processes currently running in PM2. Skipping restart.');
-                            }
-                            if (marketAdapterRequired && !runningProcesses.includes('dexbot-adapter')) {
-                                log('dexbot-adapter is required by an AMA-grid bot but not running. Starting from ecosystem...');
-                                try {
-                                    run('pm2 start profiles/ecosystem.config.cjs --only dexbot-adapter');
-                                }
-                                catch (e) {
-                                    log('Warning: Failed to start dexbot-adapter from ecosystem config.');
-                                }
-                            }
-                        }
-                        else {
-                            log('No active bots found in config.');
-                        }
-                    }
-                    else {
-                        log('Warning: profiles/bots.json not found, skipping selective restart.');
-                    }
-                }
-            }
-        }
-        catch (err) {
-            log(`Warning: runtime restart logic failed (${getErrorMessage(err)}). Skipping bulk restart to avoid touching dexbot-cred.`);
-        }
-        /**
-         * STEP 9b: Fallback restart for monolithic daemon
-         *
-         * If the monolithic daemon was running (or had state files) before the
-         * update but is no longer alive (common when the daemon is killed during
-         * git/npm operations like the prepare hook), try to auto-start it.
-         * This prevents the "bot updated but is not running" failure mode.
-         *
-         * Only mark `restarted` true when startMonolithicRuntime reports
-         * success — otherwise fall through to the manual-start instructions
-         * below so the operator knows the daemon did not actually come back.
+         * (monolithic, isolated supervisor, or PM2 selective restart), with a
+         * fallback auto-start for a monolithic daemon that died during the update.
+         * Never restarts dexbot-cred through bulk PM2 actions.
          */
-        if (!restarted && !Config.DEXBOT_UPDATE_SKIP_RELOAD) {
-            if (monolithicWasRunning || hadMonolithicFiles) {
-                log('Monolithic daemon was detected before update but is no longer running. Auto-starting...');
-                if (startMonolithicRuntime()) {
-                    restarted = true;
-                }
-                else {
-                    log('Auto-start did not succeed; the manual-start instructions below apply.');
-                }
-            }
-        }
-        if (!restarted) {
-            console.log(colorUpdateOutput('\n⚠️  No active runtime was restarted.\n' +
-                '   If the daemon was running before, start it manually from a terminal:\n' +
-                '     dexbot start\n' +
-                '   (will prompt for master password; add --foreground for interactive mode)\n' +
-                '   For non-interactive automation:\n' +
-                '     dexbot start --headless --password-file <path>\n', UPDATE_COLORS.warn));
-        }
+        await restartActiveRuntimes({ monolithicWasRunning, hadMonolithicFiles });
         logSuccess('DEXBot2 update completed successfully.');
         process.exit(0);
     }