dominds 1.25.13 → 1.25.15

package/dist/server/dominds-self-update.js

@@ -21,7 +21,7 @@ const LATEST_VERSION_CHECK_TIMEOUT_MS = 60000;
 const RESTART_PORT_RELEASE_TIMEOUT_MS = 15000;
 const RESTART_PORT_PROBE_INTERVAL_MS = 150;
 const RESTART_EXIT_GRACE_MS = 1000;
-const RESTART_FORCE_KILL_AFTER_MS = 3000;
+const RESTART_FORCE_KILL_AFTER_MS = 30000;
 const COMMAND_OUTPUT_LOG_LIMIT = 2000;
 const PROXY_URL_ENV_KEYS = new Set([
     'HTTP_PROXY',
@@ -32,12 +32,14 @@ const PROXY_URL_ENV_KEYS = new Set([
     'npm_config_https_proxy',
 ]);
 const IDLE_RESTART_STATE = { kind: 'idle' };
+const PROCESS_START_CWD = process.cwd();
 let runtimeConfig = null;
 let latestObservation = { kind: 'unknown' };
 let backgroundCheckTimer = null;
 let installPromise = null;
 let restartPromise = null;
 let restartState = IDLE_RESTART_STATE;
+let installFailureObservation = null;
 let broadcastStatusUpdate = null;
 function normalizeVersionString(value) {
     return value.trim().replace(/^v/i, '');
@@ -76,9 +78,9 @@ function detectRunKind(mode) {
         return 'disabled';
     const scriptPath = (process.argv[1] ?? '').replace(/\\/g, '/');
     if (scriptPath.includes('/_npx/') && scriptPath.includes('/node_modules/dominds/')) {
-        return 'npx_latest';
+        return 'npx';
     }
-    return 'npm_global';
+    return 'global';
 }
 function hasInteractiveConsole() {
     return Boolean(process.stdin.isTTY || process.stdout.isTTY || process.stderr.isTTY);
@@ -93,6 +95,94 @@ function getRestartPortProbeHost(host) {
         return '::1';
     return host;
 }
+function normalizeComparablePath(value) {
+    const normalized = path_1.default.normalize(value);
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+async function getComparableRealPath(absPath) {
+    try {
+        return normalizeComparablePath(await promises_1.default.realpath(absPath));
+    }
+    catch (error) {
+        const code = getStringErrorProp(error, 'code');
+        if (code === 'ENOENT')
+            return normalizeComparablePath(path_1.default.resolve(absPath));
+        throw error;
+    }
+}
+function getCurrentProcessEntrypoint() {
+    const entrypoint = process.argv[1];
+    if (typeof entrypoint !== 'string' || entrypoint.trim() === '') {
+        throw new Error('Cannot restart Dominds because the current process entrypoint is unavailable');
+    }
+    return entrypoint;
+}
+function buildCurrentProcessRestartArgs() {
+    getCurrentProcessEntrypoint();
+    return [...process.execArgv, ...process.argv.slice(1)];
+}
+function buildCurrentDomindsCliArgs() {
+    return process.argv.slice(2);
+}
+function getNpxWorkspaceDirAbs() {
+    const entrypoint = getCurrentProcessEntrypoint().replace(/\\/g, '/');
+    const marker = '/node_modules/dominds/';
+    const markerIndex = entrypoint.indexOf(marker);
+    if (markerIndex < 0)
+        return null;
+    const nodeModulesPrefix = entrypoint.slice(0, markerIndex);
+    const nodeModulesSuffix = '/node_modules';
+    if (!nodeModulesPrefix.endsWith(nodeModulesSuffix))
+        return null;
+    const workspaceDir = nodeModulesPrefix.slice(0, -nodeModulesSuffix.length);
+    if (workspaceDir.trim() === '')
+        return null;
+    return path_1.default.resolve(PROCESS_START_CWD, workspaceDir);
+}
+function parseNpxDomindsPackageSpec(spec) {
+    if (spec === 'dominds@latest')
+        return { kind: 'latest' };
+    if (spec === 'dominds')
+        return { kind: 'versionless' };
+    if (spec.startsWith('dominds@'))
+        return { kind: 'fixed', spec };
+    return null;
+}
+async function readNpxDomindsSpec() {
+    const workspaceDir = getNpxWorkspaceDirAbs();
+    if (workspaceDir === null)
+        return null;
+    const packageJsonPath = path_1.default.join(workspaceDir, 'package.json');
+    const raw = await promises_1.default.readFile(packageJsonPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed))
+        throw new Error(`Invalid npx package metadata at ${packageJsonPath}`);
+    const npxValue = parsed['_npx'];
+    const packagesValue = isRecord(npxValue) ? npxValue['packages'] : undefined;
+    if (!Array.isArray(packagesValue))
+        return null;
+    for (const packageSpec of packagesValue) {
+        if (typeof packageSpec !== 'string')
+            continue;
+        const parsedSpec = parseNpxDomindsPackageSpec(packageSpec.trim());
+        if (parsedSpec !== null)
+            return parsedSpec;
+    }
+    return null;
+}
+async function buildNpxLatestRestartLaunchSpec() {
+    const npm = await resolveNpmCommandSpec();
+    return {
+        command: npm.command,
+        args: [...npm.args, 'exec', '-y', '--', 'dominds@latest', ...buildCurrentDomindsCliArgs()],
+    };
+}
+function buildCurrentProcessRestartLaunchSpec() {
+    return {
+        command: process.execPath,
+        args: buildCurrentProcessRestartArgs(),
+    };
+}
 function truncateCommandOutput(value) {
     const raw = typeof value === 'string' ? value.trim() : '';
     if (raw.length <= COMMAND_OUTPUT_LOG_LIMIT)
@@ -136,7 +226,7 @@ function redactProxyUrl(proxyUrl) {
         return proxyUrl.replace(/\/\/[^@/]+@/g, '//***@');
     }
 }
-function buildNpmCommandEnv() {
+function buildPackageManagerCommandEnv() {
     const env = { ...process.env };
     const httpProxy = getEnvValue(env, 'HTTP_PROXY', 'http_proxy');
     const httpsProxy = getEnvValue(env, 'HTTPS_PROXY', 'https_proxy');
@@ -195,7 +285,7 @@ async function resolveNpmCommandSpec() {
             return {
                 command: process.execPath,
                 args: [candidate],
-                display: `${process.execPath} ${candidate}`,
+                display: process.execPath + ' ' + candidate,
             };
         }
         catch {
@@ -203,10 +293,55 @@ async function resolveNpmCommandSpec() {
         }
     }
     if (process.platform === 'win32') {
-        throw new Error(`Cannot find bundled npm CLI at ${candidates.join(', ')}. Dominds self-update avoids npm.cmd so the Windows console title is not hijacked.`);
+        throw new Error('Cannot find bundled npm CLI at ' +
+            candidates.join(', ') +
+            '. Dominds self-update avoids npm.cmd so the Windows console title is not hijacked.');
     }
     return { command: 'npm', args: [], display: 'npm' };
 }
+async function resolveCorepackPnpmCommandSpec() {
+    const nodeDir = path_1.default.dirname(process.execPath);
+    const candidates = process.platform === 'win32'
+        ? [path_1.default.join(nodeDir, 'node_modules', 'corepack', 'dist', 'corepack.js')]
+        : [
+            path_1.default.join(nodeDir, '..', 'lib', 'node_modules', 'corepack', 'dist', 'corepack.js'),
+            path_1.default.join(nodeDir, '..', 'share', 'nodejs', 'corepack', 'dist', 'corepack.js'),
+        ];
+    for (const candidate of candidates) {
+        try {
+            await promises_1.default.access(candidate);
+            return {
+                command: process.execPath,
+                args: [candidate, 'pnpm'],
+                display: process.execPath + ' ' + candidate + ' pnpm',
+            };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function resolvePnpmCommandSpec() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (typeof userAgent === 'string' && userAgent.startsWith('pnpm/')) {
+        const npmExecpath = process.env.npm_execpath;
+        if (typeof npmExecpath === 'string' && npmExecpath.trim() !== '') {
+            return {
+                command: process.execPath,
+                args: [npmExecpath],
+                display: process.execPath + ' ' + npmExecpath,
+            };
+        }
+    }
+    const corepackPnpm = await resolveCorepackPnpmCommandSpec();
+    if (corepackPnpm !== null)
+        return corepackPnpm;
+    if (process.platform === 'win32') {
+        throw new Error('Cannot resolve pnpm CLI without pnpm npm_execpath or bundled Corepack on Windows');
+    }
+    return { command: 'pnpm', args: [], display: 'pnpm' };
+}
 function getStringOrNumberErrorProp(error, key) {
     const value = getErrorProp(error, key);
     return typeof value === 'string' || typeof value === 'number' ? value : null;
@@ -244,36 +379,13 @@ function createCommandFailureError(params) {
     error.domindsProxyEnvSummary = params.proxyEnvSummary;
     return error;
 }
-async function runNpmCommand(args, params) {
-    const env = buildNpmCommandEnv();
+async function runPackageManagerCommand(commandSpec, args, params) {
+    const env = buildPackageManagerCommandEnv();
     const startedAtMs = Date.now();
-    let npm;
-    try {
-        npm = await resolveNpmCommandSpec();
-    }
-    catch (error) {
-        const fallbackCmd = ['npm', ...args].join(' ');
-        throw createCommandFailureError({
-            cmd: fallbackCmd,
-            durationMs: Date.now() - startedAtMs,
-            timeoutMs: params.timeoutMs,
-            timedOut: false,
-            outputExceeded: false,
-            capturedOutputChars: 0,
-            maxBuffer: params.maxBuffer,
-            code: null,
-            signal: null,
-            killed: null,
-            stdout: '',
-            stderr: '',
-            proxyEnvSummary: summarizeNpmProxyEnv(env),
-            cause: error,
-        });
-    }
-    const cmd = [npm.display, ...args].join(' ');
+    const cmd = [commandSpec.display, ...args].join(' ');
     return await new Promise((resolve, reject) => {
-        const child = (0, child_process_1.spawn)(npm.command, [...npm.args, ...args], {
-            cwd: process.cwd(),
+        const child = (0, child_process_1.spawn)(commandSpec.command, [...commandSpec.args, ...args], {
+            cwd: PROCESS_START_CWD,
             env,
             stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: true,
@@ -361,6 +473,56 @@ async function runNpmCommand(args, params) {
         });
     });
 }
+async function runCurrentDomindsVersionProbe() {
+    const startedAtMs = Date.now();
+    const timeoutMs = 15000;
+    return await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(process.execPath, [getCurrentProcessEntrypoint(), '--version'], {
+            cwd: PROCESS_START_CWD,
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: false,
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let timedOut = false;
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            fn();
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+        }, timeoutMs);
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+        });
+        child.once('error', (error) => {
+            clearTimeout(timer);
+            finish(() => reject(error));
+        });
+        child.once('close', (code, signal) => {
+            clearTimeout(timer);
+            finish(() => {
+                if (code === 0) {
+                    resolve({ stdout, stderr });
+                    return;
+                }
+                const detail = timedOut
+                    ? `timed out after ${String(Date.now() - startedAtMs)}ms`
+                    : `exited with code=${String(code)} signal=${String(signal)}`;
+                reject(new Error(`current Dominds entrypoint --version probe ${detail}; stdout=${truncateCommandOutput(stdout)} stderr=${truncateCommandOutput(stderr)}`));
+            });
+        });
+    });
+}
 function getErrorProp(error, key) {
     if (typeof error !== 'object' || error === null)
         return undefined;
@@ -475,7 +637,7 @@ function formatCommandFailureForUi(diagnostics) {
 async function queryLatestVersion() {
     const checkedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
     try {
-        const { stdout } = await runNpmCommand(['view', 'dominds', 'version', '--json'], {
+        const { stdout } = await runPackageManagerCommand(await resolveNpmCommandSpec(), ['view', 'dominds', 'version', '--json'], {
             maxBuffer: 1024 * 1024,
             timeoutMs: LATEST_VERSION_CHECK_TIMEOUT_MS,
         });
@@ -520,20 +682,225 @@ async function queryLatestVersion() {
         };
     }
 }
-async function resolveGlobalDomindsCommandAbs() {
-    const { stdout } = await runNpmCommand(['prefix', '-g'], {
+async function findRunningDomindsPackageRootAbs() {
+    const scriptPath = process.argv[1];
+    if (typeof scriptPath !== 'string' || scriptPath.trim() === '')
+        return null;
+    const scriptPathAbs = path_1.default.isAbsolute(scriptPath)
+        ? scriptPath
+        : path_1.default.resolve(PROCESS_START_CWD, scriptPath);
+    let currentDir = path_1.default.dirname(scriptPathAbs);
+    for (let depth = 0; depth < 8; depth++) {
+        const packageJsonPath = path_1.default.join(currentDir, 'package.json');
+        try {
+            const raw = await promises_1.default.readFile(packageJsonPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (isRecord(parsed) && parsed.name === 'dominds')
+                return currentDir;
+        }
+        catch (error) {
+            const code = getStringErrorProp(error, 'code');
+            if (code !== 'ENOENT')
+                throw error;
+        }
+        const parentDir = path_1.default.dirname(currentDir);
+        if (parentDir === currentDir)
+            return null;
+        currentDir = parentDir;
+    }
+    return null;
+}
+async function readPackageVersionFromPackageJson(packageJsonPath) {
+    try {
+        const raw = await promises_1.default.readFile(packageJsonPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed) || typeof parsed.version !== 'string' || parsed.version.trim() === '') {
+            throw new Error(`Invalid Dominds package metadata at ${packageJsonPath}`);
+        }
+        return parsed.version.trim();
+    }
+    catch (error) {
+        const code = getStringErrorProp(error, 'code');
+        if (code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function readCurrentDomindsPackageRootAbs() {
+    const runningPackageRoot = await findRunningDomindsPackageRootAbs();
+    if (runningPackageRoot === null) {
+        throw new Error('Cannot find package.json for the current Dominds process entrypoint');
+    }
+    return runningPackageRoot;
+}
+async function readCurrentDomindsPackageVersion() {
+    const runningPackageRoot = await readCurrentDomindsPackageRootAbs();
+    const packageJsonPath = path_1.default.join(runningPackageRoot, 'package.json');
+    const version = await readPackageVersionFromPackageJson(packageJsonPath);
+    if (version === null) {
+        throw new Error(`Cannot read current Dominds package metadata at ${packageJsonPath}`);
+    }
+    return version;
+}
+function parsePackageManagerRoot(stdout) {
+    const lines = stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line !== '');
+    const npmRoot = lines[lines.length - 1];
+    if (npmRoot === undefined) {
+        throw new Error('package manager root -g returned empty stdout');
+    }
+    return npmRoot;
+}
+async function readSymlinkTargetAbs(absPath) {
+    try {
+        const stat = await promises_1.default.lstat(absPath);
+        if (!stat.isSymbolicLink())
+            return null;
+        const target = await promises_1.default.readlink(absPath);
+        return path_1.default.isAbsolute(target) ? target : path_1.default.resolve(path_1.default.dirname(absPath), target);
+    }
+    catch (error) {
+        const code = getStringErrorProp(error, 'code');
+        if (code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+function isSameOrInsidePath(childAbs, parentAbs) {
+    const childComparable = normalizeComparablePath(path_1.default.resolve(childAbs));
+    const parentComparable = normalizeComparablePath(path_1.default.resolve(parentAbs));
+    if (childComparable === parentComparable)
+        return true;
+    const relative = path_1.default.relative(parentComparable, childComparable);
+    return relative !== '' && !relative.startsWith('..') && !path_1.default.isAbsolute(relative);
+}
+async function readGlobalRootAbs(commandSpec) {
+    const rootResult = await runPackageManagerCommand(commandSpec, ['root', '-g'], {
         maxBuffer: 1024 * 1024,
         timeoutMs: 15000,
     });
-    const prefix = stdout.trim();
-    if (prefix === '') {
-        throw new Error('npm prefix -g returned empty output');
+    return path_1.default.resolve(PROCESS_START_CWD, parsePackageManagerRoot(rootResult.stdout));
+}
+async function verifyGlobalInstallTargetsCurrentPackage() {
+    let currentPackageRootAbs = null;
+    const checkedTargets = [];
+    try {
+        currentPackageRootAbs = await readCurrentDomindsPackageRootAbs();
+        const currentComparable = await getComparableRealPath(currentPackageRootAbs);
+        const managers = ['npm', 'pnpm'];
+        for (const manager of managers) {
+            try {
+                const commandSpec = manager === 'pnpm' ? await resolvePnpmCommandSpec() : await resolveNpmCommandSpec();
+                const managerGlobalRootAbs = await readGlobalRootAbs(commandSpec);
+                const managerPackageRootAbs = path_1.default.join(managerGlobalRootAbs, 'dominds');
+                checkedTargets.push(manager + ':' + managerPackageRootAbs);
+                const symlinkTargetAbs = await readSymlinkTargetAbs(managerPackageRootAbs);
+                if (symlinkTargetAbs !== null &&
+                    !isSameOrInsidePath(symlinkTargetAbs, managerGlobalRootAbs)) {
+                    checkedTargets.push(manager + ':linked:' + symlinkTargetAbs);
+                    continue;
+                }
+                const managerComparable = await getComparableRealPath(managerPackageRootAbs);
+                if (currentComparable === managerComparable) {
+                    return {
+                        kind: 'ok',
+                        manager,
+                        currentPackageRootAbs,
+                        managerPackageRootAbs,
+                    };
+                }
+            }
+            catch (error) {
+                checkedTargets.push(manager + ':error:' + formatErrorForUi(error));
+            }
+        }
+        return {
+            kind: 'unsupported',
+            currentPackageRootAbs,
+            checkedTargets,
+            message: 'Automatic global update is disabled because neither npm nor pnpm global install target safely matches the current Dominds process at ' +
+                currentPackageRootAbs +
+                '. Checked: ' +
+                checkedTargets.join('; ') +
+                '.',
+        };
+    }
+    catch (error) {
+        return {
+            kind: 'unsupported',
+            currentPackageRootAbs,
+            checkedTargets,
+            message: 'Automatic global update is disabled because the global install target could not be verified: ' +
+                formatErrorForUi(error),
+        };
+    }
+}
+function buildGlobalInstallArgs(manager) {
+    return manager === 'pnpm' ? ['add', '-g', 'dominds@latest'] : ['i', '-g', 'dominds@latest'];
+}
+async function buildGlobalInstallCommandSpec(manager) {
+    return manager === 'pnpm' ? await resolvePnpmCommandSpec() : await resolveNpmCommandSpec();
+}
+function parseDomindsVersionProbe(stdout, stderr) {
+    const combined = `${stdout}\n${stderr}`;
+    const match = /dominds\s+v([^\s]+)/i.exec(combined) ??
+        /\bv(\d+(?:\.\d+){1,3}(?:[-+][^\s]+)?)\b/i.exec(combined);
+    if (match === null)
+        return null;
+    return match[1].trim();
+}
+function formatErrorForUi(error) {
+    const diagnostics = extractCommandFailureDiagnostics(error);
+    if (diagnostics.cmd !== null || diagnostics.stdout !== '' || diagnostics.stderr !== '') {
+        return formatCommandFailureForUi(diagnostics);
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+async function verifyInstalledDominds(targetVersion) {
+    let packageVersion = null;
+    let probeVersion = null;
+    try {
+        packageVersion = await readCurrentDomindsPackageVersion();
+        const probe = await runCurrentDomindsVersionProbe();
+        probeVersion = parseDomindsVersionProbe(probe.stdout, probe.stderr);
+        if (probeVersion === null) {
+            return {
+                kind: 'failed',
+                message: `Current Dominds entrypoint did not report a parseable version; stdout=${truncateCommandOutput(probe.stdout)} stderr=${truncateCommandOutput(probe.stderr)}`,
+                packageVersion,
+                probeVersion,
+            };
+        }
+        const packageProbeComparison = compareVersions(packageVersion, probeVersion);
+        const versionsMatch = packageProbeComparison !== null
+            ? packageProbeComparison === 0
+            : packageVersion === probeVersion;
+        const packageTargetComparison = compareVersions(packageVersion, targetVersion);
+        const probeTargetComparison = compareVersions(probeVersion, targetVersion);
+        const packageAtLeastTarget = packageTargetComparison !== null
+            ? packageTargetComparison >= 0
+            : packageVersion === targetVersion;
+        const probeAtLeastTarget = probeTargetComparison !== null ? probeTargetComparison >= 0 : probeVersion === targetVersion;
+        if (!versionsMatch || !packageAtLeastTarget || !probeAtLeastTarget) {
+            return {
+                kind: 'failed',
+                message: `Current Dominds entrypoint version verification failed; target=${targetVersion} package=${packageVersion} probe=${probeVersion}`,
+                packageVersion,
+                probeVersion,
+            };
+        }
+        return { kind: 'ok', packageVersion, probeVersion };
+    }
+    catch (error) {
+        return {
+            kind: 'failed',
+            message: error instanceof Error ? error.message : String(error),
+            packageVersion,
+            probeVersion,
+        };
     }
-    const commandAbs = process.platform === 'win32'
-        ? path_1.default.join(prefix, 'dominds.cmd')
-        : path_1.default.join(prefix, 'bin', 'dominds');
-    await promises_1.default.access(commandAbs);
-    return commandAbs;
 }
 function clearBackgroundCheckTimer() {
     if (backgroundCheckTimer === null)
@@ -593,6 +960,7 @@ async function checkLatestDomindsVersionNow() {
     if (restartState.kind === 'restart_required' || restartState.kind === 'restarting') {
         return await getDomindsSelfUpdateStatus();
     }
+    installFailureObservation = null;
     latestObservation = await queryLatestVersion();
     publishStatusUpdateSoon();
     scheduleBackgroundCheck(BACKGROUND_CHECK_INTERVAL_MS);
@@ -630,6 +998,7 @@ function configureDomindsSelfUpdate(params) {
     };
     latestObservation = { kind: 'unknown' };
     restartState = IDLE_RESTART_STATE;
+    installFailureObservation = null;
     clearBackgroundCheckTimer();
     if (params.mode === 'production') {
         scheduleBackgroundCheck(BACKGROUND_CHECK_INTERVAL_MS);
@@ -669,8 +1038,8 @@ async function getDomindsSelfUpdateStatus() {
             runKind,
             action: 'restart',
             busy: 'idle',
-            reason: 'restart_required',
-            message: 'Latest Dominds is installed and waiting for restart',
+            reason: restartState.reason,
+            message: restartState.installReport ?? 'Latest Dominds is installed and waiting for restart',
             targetVersion: restartState.installedVersion,
         });
     }
@@ -704,6 +1073,21 @@ async function getDomindsSelfUpdateStatus() {
             targetVersion: latestObservation.kind === 'ok' ? latestObservation.latestVersion : null,
         });
     }
+    if (installFailureObservation !== null) {
+        return buildStatus({
+            currentVersion: runningVersion,
+            installedVersion: runningVersion,
+            latestVersion: latestObservation.kind === 'ok' ? latestObservation.latestVersion : null,
+            checkedAt: installFailureObservation.failedAt,
+            mode: cfg.mode,
+            runKind,
+            action: latestObservation.kind === 'ok' ? 'install' : 'none',
+            busy: 'idle',
+            reason: 'install_failed',
+            message: installFailureObservation.errorText,
+            targetVersion: latestObservation.kind === 'ok' ? latestObservation.latestVersion : null,
+        });
+    }
     if (restartPromise !== null) {
         return buildStatus({
             currentVersion: runningVersion,
@@ -766,7 +1150,27 @@ async function getDomindsSelfUpdateStatus() {
             targetVersion: null,
         });
     }
-    if (runKind === 'npx_latest') {
+    if (runKind === 'npx') {
+        const npxSpec = await readNpxDomindsSpec();
+        if (npxSpec?.kind === 'latest') {
+            return buildStatus({
+                currentVersion: runningVersion,
+                installedVersion: runningVersion,
+                latestVersion: latestObservation.latestVersion,
+                checkedAt: latestObservation.checkedAt,
+                mode: cfg.mode,
+                runKind,
+                action: 'restart',
+                busy: 'idle',
+                reason: 'restart_required',
+                message: 'Restart to relaunch Dominds via npx dominds@latest',
+                targetVersion: latestObservation.latestVersion,
+            });
+        }
+        const reason = npxSpec?.kind === 'fixed' ? 'npx_fixed_version_unsupported' : 'npx_versionless_unsupported';
+        const message = npxSpec?.kind === 'fixed'
+            ? `A newer Dominds version is available, but this npx session was launched with ${npxSpec.spec}; use dominds@latest to enable automatic restart updates.`
+            : 'A newer Dominds version is available, but this npx session was launched without a verified dominds@latest spec; use dominds@latest to enable automatic restart updates.';
         return buildStatus({
             currentVersion: runningVersion,
             installedVersion: runningVersion,
@@ -774,10 +1178,26 @@ async function getDomindsSelfUpdateStatus() {
             checkedAt: latestObservation.checkedAt,
             mode: cfg.mode,
             runKind,
-            action: 'restart',
+            action: 'none',
             busy: 'idle',
-            reason: 'restart_available_via_npx',
-            message: 'Restart to relaunch Dominds via npx latest',
+            reason,
+            message,
+            targetVersion: latestObservation.latestVersion,
+        });
+    }
+    const globalTargetVerification = await verifyGlobalInstallTargetsCurrentPackage();
+    if (globalTargetVerification.kind === 'unsupported') {
+        return buildStatus({
+            currentVersion: runningVersion,
+            installedVersion: runningVersion,
+            latestVersion: latestObservation.latestVersion,
+            checkedAt: latestObservation.checkedAt,
+            mode: cfg.mode,
+            runKind,
+            action: 'none',
+            busy: 'idle',
+            reason: 'global_install_target_unsupported',
+            message: globalTargetVerification.message,
             targetVersion: latestObservation.latestVersion,
         });
     }
@@ -801,7 +1221,7 @@ async function installLatestDominds() {
         throw new Error('Dominds self-update install is disabled in development mode');
     }
     const runKind = detectRunKind(cfg.mode);
-    if (runKind !== 'npm_global') {
+    if (runKind !== 'global') {
         throw new Error(`Install action is not supported for runKind=${runKind}`);
     }
     if (restartState.kind === 'restart_required') {
@@ -814,49 +1234,100 @@ async function installLatestDominds() {
         return await getDomindsSelfUpdateStatus();
     }
     installPromise = (async () => {
+        installFailureObservation = null;
         const runningVersion = getRunningVersion();
+        const previouslyKnownLatest = latestObservation.kind === 'ok' ? latestObservation : null;
         const latest = await queryLatestVersion();
-        latestObservation = latest;
-        if (latest.kind === 'error') {
+        let targetVersion;
+        if (latest.kind === 'ok') {
+            latestObservation = latest;
+            targetVersion = latest.latestVersion;
+        }
+        else if (previouslyKnownLatest === null) {
+            latestObservation = latest;
             throw new Error(latest.errorText);
         }
-        const comparison = compareVersions(runningVersion, latest.latestVersion);
-        const hasUpdate = comparison !== null ? comparison < 0 : runningVersion !== latest.latestVersion;
+        else {
+            targetVersion = previouslyKnownLatest.latestVersion;
+            log.warn('Dominds install latest-version refresh failed; continuing with previously known update target', undefined, {
+                previousLatestVersion: previouslyKnownLatest.latestVersion,
+                previousCheckedAt: previouslyKnownLatest.checkedAt,
+                refreshErrorText: latest.errorText,
+                refreshCheckedAt: latest.checkedAt,
+            });
+        }
+        const comparison = compareVersions(runningVersion, targetVersion);
+        const hasUpdate = comparison !== null ? comparison < 0 : runningVersion !== targetVersion;
         if (!hasUpdate) {
             throw new Error('No installable Dominds update is currently available');
         }
-        await runNpmCommand(['i', '-g', 'dominds@latest'], {
-            maxBuffer: 20 * 1024 * 1024,
-            timeoutMs: 10 * 60 * 1000,
-        });
-        const globalCommandAbs = await resolveGlobalDomindsCommandAbs();
+        const globalTargetVerification = await verifyGlobalInstallTargetsCurrentPackage();
+        if (globalTargetVerification.kind === 'unsupported') {
+            throw new Error(globalTargetVerification.message);
+        }
+        let installCommandError = null;
+        try {
+            await runPackageManagerCommand(await buildGlobalInstallCommandSpec(globalTargetVerification.manager), buildGlobalInstallArgs(globalTargetVerification.manager), {
+                maxBuffer: 20 * 1024 * 1024,
+                timeoutMs: 10 * 60 * 1000,
+            });
+        }
+        catch (error) {
+            installCommandError = error;
+            log.warn('Dominds install command failed; verifying installed files before reporting failure', error, {
+                currentVersion: runningVersion,
+                targetVersion,
+            });
+        }
+        const installedVerification = await verifyInstalledDominds(targetVersion);
+        if (installedVerification.kind === 'failed') {
+            if (installCommandError !== null) {
+                throw new Error(`npm install failed and installed Dominds verification failed. npm: ${formatErrorForUi(installCommandError)} verification: ${installedVerification.message}`);
+            }
+            throw new Error(installedVerification.message);
+        }
+        if (installCommandError !== null) {
+            log.warn('Dominds install command failed but installed files passed verification', installCommandError, {
+                targetVersion,
+                packageVersion: installedVerification.packageVersion,
+                probeVersion: installedVerification.probeVersion,
+            });
+        }
+        const installReport = installCommandError === null
+            ? null
+            : `Dominds install command reported failure, but the current entrypoint version probe confirmed v${installedVerification.probeVersion}. Restart is available.`;
         restartState = {
             kind: 'restart_required',
-            installedVersion: latest.latestVersion,
-            globalCommandAbs,
+            installedVersion: installedVerification.probeVersion,
+            installReport,
+            reason: installCommandError === null
+                ? 'restart_required'
+                : 'install_verified_after_command_failure',
         };
+        installFailureObservation = null;
         return await getDomindsSelfUpdateStatus();
     })()
         .catch((error) => {
         const latestVersion = latestObservation.kind === 'ok' ? latestObservation.latestVersion : null;
         const checkedAt = latestObservation.kind === 'unknown' ? null : latestObservation.checkedAt;
+        installFailureObservation = {
+            errorText: formatErrorForUi(error),
+            failedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        };
         log.error('Dominds version install failed', error, {
             runKind,
             currentVersion: getRunningVersion(),
             latestVersion,
             checkedAt,
         });
-        throw error;
+        return getDomindsSelfUpdateStatus();
     })
         .finally(() => {
         installPromise = null;
         publishStatusUpdateSoon();
     });
     publishStatusUpdateSoon();
-    return await installPromise;
-}
-function buildRestartArgs(cfg) {
-    return ['webui', '-p', String(cfg.port), '-h', cfg.host, '--mode', 'prod', '--nobrowser'];
+    return await getDomindsSelfUpdateStatus();
 }
 function spawnDetachedRestartHelper(params) {
     const stdioMode = getRestartHelperStdio();
@@ -876,7 +1347,7 @@ function spawnDetachedRestartHelper(params) {
         "const net = require('net');",
         "const { spawn } = require('child_process');",
         'const payload = JSON.parse(process.argv[1]);',
-        'const detached = payload.stdioMode !== "inherit" || process.platform === "win32";',
+        'const detached = payload.stdioMode !== "inherit";',
         'function isPortBusy() {',
         '  return new Promise((resolve) => {',
         '    const socket = net.createConnection({ host: payload.host, port: payload.port });',
@@ -915,13 +1386,18 @@ function spawnDetachedRestartHelper(params) {
         '    throw error;',
         '  }',
         '}',
-        'async function waitForRestartReadiness(timeoutMs) {',
+        'async function waitForRetiringProcessExit(timeoutMs) {',
         '  const deadline = Date.now() + timeoutMs;',
+        '  while (Date.now() < deadline) {',
+        '    if (!isRetiringProcessAlive()) return true;',
+        '    await new Promise((resolve) => setTimeout(resolve, payload.probeIntervalMs));',
+        '  }',
+        '  return false;',
+        '}',
+        'async function waitForPortReleaseUntil(deadline) {',
         '  let consecutiveReady = 0;',
         '  while (Date.now() < deadline) {',
-        '    const processAlive = isRetiringProcessAlive();',
-        '    const portBusy = await isPortBusy();',
-        '    if (!processAlive && !portBusy) {',
+        '    if (!(await isPortBusy())) {',
         '      consecutiveReady += 1;',
         '      if (consecutiveReady >= 2) return true;',
         '    } else {',
@@ -933,7 +1409,7 @@ function spawnDetachedRestartHelper(params) {
         '}',
         'function runBestEffortKiller(command, args) {',
         '  return new Promise((resolve) => {',
-        '    const killer = spawn(command, args, { stdio: payload.stdioMode });',
+        '    const killer = spawn(command, args, { stdio: payload.stdioMode, windowsHide: payload.stdioMode !== "inherit" });',
         "    killer.once('error', () => resolve());",
         "    killer.once('exit', () => resolve());",
         '  });',
@@ -953,16 +1429,26 @@ function spawnDetachedRestartHelper(params) {
         '}',
         '(async () => {',
         '  try {',
-        '    const readyGracefully = await waitForRestartReadiness(payload.forceKillAfterMs);',
-        '    if (!readyGracefully) {',
+        '    const forceKillDeadline = Date.now() + payload.forceKillAfterMs;',
+        '    const exitedGracefully = await waitForRetiringProcessExit(payload.forceKillAfterMs);',
+        '    if (!exitedGracefully) {',
         '      await forceKillRetiringProcess();',
-        '      const readyAfterKill = await waitForRestartReadiness(payload.portReleaseTimeoutMs);',
-        '      if (!readyAfterKill) {',
-        '        throw new Error(`Dominds restart target is still not ready after force-killing pid ${String(payload.retiringPid)}; port=${String(payload.host)}:${String(payload.port)}`);',
+        '      const exitedAfterKill = await waitForRetiringProcessExit(payload.portReleaseTimeoutMs);',
+        '      if (!exitedAfterKill) {',
+        '        throw new Error(`Dominds retiring process is still alive after force-killing pid ${String(payload.retiringPid)}`);',
         '      }',
         '    }',
-        "    const child = spawn(payload.command, payload.args, { cwd: payload.cwd, env: process.env, detached, stdio: payload.stdioMode, shell: process.platform === 'win32' });",
+        '    const portReleaseDeadline = Math.max(forceKillDeadline, Date.now() + payload.portReleaseTimeoutMs);',
+        '    const portReleased = await waitForPortReleaseUntil(portReleaseDeadline);',
+        '    if (!portReleased) {',
+        '      throw new Error(`Dominds restart port is still busy after retiring pid ${String(payload.retiringPid)} exited; port=${String(payload.host)}:${String(payload.port)}`);',
+        '    }',
+        '    const child = spawn(payload.command, payload.args, { cwd: payload.cwd, env: process.env, detached, stdio: payload.stdioMode, shell: false, windowsHide: payload.stdioMode !== "inherit" });',
         '    if (detached) child.unref();',
+        '    await new Promise((resolve, reject) => {',
+        "      child.once('error', reject);",
+        "      child.once('spawn', resolve);",
+        '    });',
         '    process.exit(0);',
         '  } catch (error) {',
         '    console.error(error instanceof Error ? error.message : String(error));',
@@ -973,10 +1459,11 @@ function spawnDetachedRestartHelper(params) {
     const helper = (0, child_process_1.spawn)(process.execPath, ['-e', helperScript, helperPayload], {
         cwd: params.cwd,
         env: process.env,
-        detached: stdioMode !== 'inherit' || process.platform === 'win32',
+        detached: stdioMode !== 'inherit',
         stdio: stdioMode,
+        windowsHide: stdioMode !== 'inherit',
     });
-    if (stdioMode !== 'inherit' || process.platform === 'win32') {
+    if (stdioMode !== 'inherit') {
         helper.unref();
     }
 }
@@ -1023,50 +1510,41 @@ async function restartDomindsIntoLatest() {
             throw new Error('No restartable Dominds update is currently available');
         }
         const runKind = detectRunKind(cfg.mode);
-        const args = buildRestartArgs(cfg);
-        let command;
+        let launchSpec;
         const previousRestartRequiredState = restartState.kind === 'restart_required' ? restartState : null;
-        if (runKind === 'npx_latest') {
-            command = 'npx';
-            args.unshift('dominds@latest');
-            args.unshift('-y');
+        if (previousRestartRequiredState !== null) {
+            launchSpec = buildCurrentProcessRestartLaunchSpec();
         }
-        else if (previousRestartRequiredState !== null) {
-            command = previousRestartRequiredState.globalCommandAbs;
+        else if (runKind === 'npx') {
+            const npxSpec = await readNpxDomindsSpec();
+            if (npxSpec?.kind !== 'latest') {
+                throw new Error('Dominds npx restart requires launching Dominds with dominds@latest');
+            }
+            launchSpec = await buildNpxLatestRestartLaunchSpec();
         }
         else {
-            throw new Error('Dominds restart requires a completed install or an npx latest session');
+            throw new Error('Dominds restart requires a completed install or a restartable session');
         }
         restartState = { kind: 'restarting', targetVersion: status.targetVersion };
         publishStatusUpdateSoon();
         try {
             spawnDetachedRestartHelper({
-                command,
-                args,
-                cwd: process.cwd(),
+                command: launchSpec.command,
+                args: launchSpec.args,
+                cwd: PROCESS_START_CWD,
                 host: cfg.host,
                 port: cfg.port,
             });
             setImmediate(() => {
                 void stopAndExitForRestart().catch((error) => {
                     log.error('Failed to stop Dominds server during restart', error);
-                    if (runKind === 'npm_global' && previousRestartRequiredState !== null) {
-                        restartState = previousRestartRequiredState;
-                        publishStatusUpdateSoon();
-                        return;
-                    }
-                    restartState = IDLE_RESTART_STATE;
+                    restartState = previousRestartRequiredState ?? IDLE_RESTART_STATE;
                     publishStatusUpdateSoon();
                 });
             });
         }
         catch (error) {
-            if (previousRestartRequiredState !== null) {
-                restartState = previousRestartRequiredState;
-            }
-            else {
-                restartState = IDLE_RESTART_STATE;
-            }
+            restartState = previousRestartRequiredState ?? IDLE_RESTART_STATE;
             publishStatusUpdateSoon();
             throw error;
         }