@memberjunction/open-app-engine 5.45.1 → 5.47.0

package/dist/install/install-orchestrator.js

@@ -1,6 +1,6 @@
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { mkdirSync, readFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, rmSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { ParseAndValidateManifest } from '../manifest/manifest-loader.js';
@@ -9,13 +9,40 @@ import { ResolveDependencyGraph } from '../dependency/dependency-graph-builder.j
 import { FetchManifestFromGitHub, DownloadMigrations, GetLatestVersion, ListGitHubReleases, ListGitHubTags, ValidateGitHubTag, ParseGitHubUrl } from '../github/github-client.js';
 import semver from 'semver';
 import { CreateAppSchema, DropAppSchema, SchemaExists, EscapeSqlString } from './schema-manager.js';
+import { RunFkGraphTeardown, buildRootDoomedPredicate } from './entity-teardown.js';
+import { extractApplicationIds } from './migration-application-ids.js';
 import { RunAppMigrations } from './migration-runner.js';
 import { AddAppPackages, RemoveAppPackages, RunPackageInstall, BumpPrefixedDependencies } from './package-manager.js';
 import { AddServerDynamicPackages, AddClientDynamicPackages, RemoveServerDynamicPackages, ToggleServerDynamicPackages, AddEntityPackageMapping, RemoveEntityPackageMapping } from './config-manager.js';
 import { AngularConfigManager } from './angular-config-manager.js';
 import { Metadata, RunView } from '@memberjunction/core';
 import { NormalizeUUID } from '@memberjunction/global';
-import { RecordAppInstallation, RecordInstallHistoryEntry, RecordAppDependencies, ReplaceAppDependenciesAtomically, SetAppStatus, FindInstalledApp, CheckSchemaSharedByOtherApps, FindDependentApps, ListInstalledApps, UpdateAppRecord, } from './history-recorder.js';
+import { RecordAppInstallation, RecordInstallHistoryEntry, RecordAppDependencies, DeleteAppDependencies, ReplaceAppDependenciesAtomically, SetAppStatus, FindInstalledApp, CheckSchemaSharedByOtherApps, FindDependentApps, ListInstalledApps, UpdateAppRecord, SetAppStep, } from './history-recorder.js';
+const INSTALL_STEP_ORDER = ['RecordCreated', 'PackagesInstalled', 'ConfigUpdated', 'AngularExcludesUpdated', 'Finalized', 'HooksRun'];
+const UPGRADE_STEP_ORDER = ['MigrationsApplied', 'PackagesInstalled', 'ConfigUpdated', 'AngularExcludesUpdated', 'RecordUpdated', 'HooksRun', 'DependenciesReplaced'];
+const REMOVE_STEP_ORDER = ['DbCleanupDone', 'FilesRemoved'];
+function IsStepDone(order, checkpoint, step) {
+    if (!checkpoint) {
+        return false;
+    }
+    const checkpointIndex = order.indexOf(checkpoint);
+    const stepIndex = order.indexOf(step);
+    return checkpointIndex >= 0 && checkpointIndex >= stepIndex;
+}
+function IsOwnCheckpoint(order, checkpoint) {
+    return !!checkpoint && order.includes(checkpoint);
+}
+const SETTLED_STATUSES = new Set(['Active', 'Disabled']);
+function BuildMutexConflictResult(action, appName, version, startTime, currentStatus, displayVerb) {
+    const verb = displayVerb ?? action.toLowerCase();
+    const guidance = {
+        Installing: `finish it with 'mj app install <source>' (it will resume automatically)`,
+        Upgrading: `finish it with 'mj app upgrade ${appName}' (it will resume automatically)`,
+        Removing: `finish it with 'mj app remove ${appName}' (it will resume automatically)`,
+        Error: `resolve it — 'mj app install <source>' to retry a failed install, 'mj app upgrade ${appName}' to retry a failed upgrade, or 'mj app remove ${appName}' to remove it`,
+    };
+    return BuildFailureResult(action, appName, version, 'Schema', startTime, `Cannot ${verb} '${appName}' while it is '${currentStatus}' — another operation is still in progress or failed partway. ${guidance[currentStatus] ?? 'Resolve the in-progress operation first.'}`);
+}
 class OpenAppPhaseError extends Error {
     constructor(Phase, message) {
         super(message);
@@ -73,83 +100,120 @@ export async function InstallApp(options, context) {
         }
         const existingApp = await FindInstalledApp(context.ContextUser, manifest.name);
         const isReinstall = existingApp != null && (existingApp.Status === 'Removed' || existingApp.Status === 'Error');
-        if (existingApp && !isReinstall) {
-            return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, `App '${manifest.name}' is already installed with status '${existingApp.Status}'. Use 'mj app upgrade' to update it.`);
+        const isResume = existingApp != null && existingApp.Status === 'Installing' && existingApp.Version === manifest.version;
+        if (existingApp && !isReinstall && !isResume) {
+            const guidance = {
+                Active: `Use 'mj app upgrade ${manifest.name}' to update it.`,
+                Disabled: `Use 'mj app upgrade ${manifest.name}' to update it.`,
+                Upgrading: `An upgrade is already in progress — finish it with 'mj app upgrade ${manifest.name}' (it will resume automatically), then re-run this install if still needed.`,
+                Removing: `A removal is already in progress — finish it with 'mj app remove ${manifest.name}' (it will resume automatically), then re-run this install once it's fully removed.`,
+            };
+            return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, `App '${manifest.name}' is already installed with status '${existingApp.Status}'. ${guidance[existingApp.Status] ?? `Resolve the '${existingApp.Status}' state first.`}`);
+        }
+        const resumeCheckpoint = isResume ? (existingApp.LastCompletedStep ?? null) : null;
+        const phase1Complete = isResume && resumeCheckpoint != null;
+        if (isResume) {
+            Callbacks?.OnProgress?.('Resume', `Resuming install of ${manifest.name} v${manifest.version}${resumeCheckpoint ? ` from step '${resumeCheckpoint}'` : ''}...`);
         }
-        Callbacks?.OnProgress?.('Install', `Installing ${manifest.name} v${manifest.version}...`);
         let schemaCreated = false;
-        if (manifest.schema) {
-            const schemaResult = await HandleSchemaCreation(manifest, context, isReinstall, options.AllowDoubleUnderscoreSchema === true);
-            if (!schemaResult.Success) {
-                return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, schemaResult.ErrorMessage ?? 'Schema creation failed');
-            }
-            schemaCreated = schemaResult.Created === true;
-            await PersistCanonicalSchemaName(manifest, context);
+        if (phase1Complete) {
+            createdAppId = existingApp.ID;
         }
-        if (manifest.migrations && manifest.schema) {
-            const migrationResult = await HandleMigrations(manifest, context, subpath);
-            if (!migrationResult.Success) {
+        else {
+            Callbacks?.OnProgress?.('Install', `Installing ${manifest.name} v${manifest.version}...`);
+            if (existingApp?.LastCompletedStep) {
+                await SetAppStep(context.ContextUser, existingApp.ID, null);
+            }
+            if (manifest.schema) {
+                const schemaResult = await HandleSchemaCreation(manifest, context, isReinstall || isResume, options.AllowDoubleUnderscoreSchema === true);
+                if (!schemaResult.Success) {
+                    return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, schemaResult.ErrorMessage ?? 'Schema creation failed');
+                }
+                schemaCreated = schemaResult.Created === true;
+                await PersistCanonicalSchemaName(manifest, context);
+            }
+            if (manifest.migrations && manifest.schema) {
+                const migrationResult = await HandleMigrations(manifest, context, subpath);
+                if (!migrationResult.Success) {
+                    await CompensateSchemaOnFailure(manifest, context, schemaCreated, options.AllowDoubleUnderscoreSchema === true, Callbacks);
+                    return BuildFailureResult('Install', manifest.name, manifest.version, 'Migration', startTime, migrationResult.ErrorMessage ?? 'Migration failed');
+                }
+            }
+            Callbacks?.OnProgress?.('Record', 'Recording app installation...');
+            const recordResult = await RecordInstallationAtomically(context.ContextUser, manifest, Callbacks, undefined, subpath);
+            if (!recordResult.Success) {
                 await CompensateSchemaOnFailure(manifest, context, schemaCreated, options.AllowDoubleUnderscoreSchema === true, Callbacks);
-                return BuildFailureResult('Install', manifest.name, manifest.version, 'Migration', startTime, migrationResult.ErrorMessage ?? 'Migration failed');
+                return BuildFailureResult('Install', manifest.name, manifest.version, 'Record', startTime, recordResult.ErrorMessage ?? 'Failed to record installation');
             }
+            createdAppId = recordResult.AppId;
+            await SetAppStep(context.ContextUser, createdAppId, 'RecordCreated');
         }
-        Callbacks?.OnProgress?.('Record', 'Recording app installation...');
-        const recordResult = await RecordInstallationAtomically(context.ContextUser, manifest, Callbacks, undefined, subpath);
-        if (!recordResult.Success) {
-            await CompensateSchemaOnFailure(manifest, context, schemaCreated, options.AllowDoubleUnderscoreSchema === true, Callbacks);
-            return BuildFailureResult('Install', manifest.name, manifest.version, 'Record', startTime, recordResult.ErrorMessage ?? 'Failed to record installation');
-        }
-        createdAppId = recordResult.AppId;
         Callbacks?.OnProgress?.('Config', 'Updating configuration files...');
-        const pkgResult = await HandlePackageInstallation(manifest, context, effectivePackageVersion, effectiveVersionStrategy, options.Verbose);
         let npmInstallWarning;
-        if (!pkgResult.Success) {
-            if (pkgResult.PackageJsonUpdated) {
-                npmInstallWarning = pkgResult.ErrorMessage;
-                Callbacks?.OnWarn?.('Packages', `npm install failed — package.json entries were added but dependencies were not resolved. Run 'npm install' manually after fixing npm auth.\n  Detail: ${pkgResult.ErrorMessage}`);
+        if (!IsStepDone(INSTALL_STEP_ORDER, resumeCheckpoint, 'PackagesInstalled')) {
+            const pkgResult = await HandlePackageInstallation(manifest, context, effectivePackageVersion, effectiveVersionStrategy, options.Verbose);
+            if (!pkgResult.Success) {
+                if (pkgResult.PackageJsonUpdated) {
+                    npmInstallWarning = pkgResult.ErrorMessage;
+                    Callbacks?.OnWarn?.('Packages', `npm install failed — package.json entries were added but dependencies were not resolved. Run 'npm install' manually after fixing npm auth.\n  Detail: ${pkgResult.ErrorMessage}`);
+                }
+                else {
+                    await SetAppStatus(context.ContextUser, createdAppId, 'Error');
+                    await RecordFailureHistory(context.ContextUser, createdAppId, 'Install', manifest, 'Packages', pkgResult.ErrorMessage ?? 'Package installation failed', startTime);
+                    return BuildFailureResult('Install', manifest.name, manifest.version, 'Packages', startTime, pkgResult.ErrorMessage ?? 'Package installation failed');
+                }
             }
             else {
+                await SetAppStep(context.ContextUser, createdAppId, 'PackagesInstalled');
+            }
+        }
+        if (!IsStepDone(INSTALL_STEP_ORDER, resumeCheckpoint, 'ConfigUpdated')) {
+            const configResult = HandleServerConfig(manifest, context);
+            if (!configResult.Success) {
                 await SetAppStatus(context.ContextUser, createdAppId, 'Error');
-                await RecordFailureHistory(context.ContextUser, createdAppId, 'Install', manifest, 'Packages', pkgResult.ErrorMessage ?? 'Package installation failed', startTime);
-                return BuildFailureResult('Install', manifest.name, manifest.version, 'Packages', startTime, pkgResult.ErrorMessage ?? 'Package installation failed');
+                await RecordFailureHistory(context.ContextUser, createdAppId, 'Install', manifest, 'Config', configResult.ErrorMessage ?? 'Config update failed', startTime);
+                return BuildFailureResult('Install', manifest.name, manifest.version, 'Config', startTime, configResult.ErrorMessage ?? 'Config update failed');
             }
+            await SetAppStep(context.ContextUser, createdAppId, 'ConfigUpdated');
         }
-        const configResult = HandleServerConfig(manifest, context);
-        if (!configResult.Success) {
-            await SetAppStatus(context.ContextUser, createdAppId, 'Error');
-            await RecordFailureHistory(context.ContextUser, createdAppId, 'Install', manifest, 'Config', configResult.ErrorMessage ?? 'Config update failed', startTime);
-            return BuildFailureResult('Install', manifest.name, manifest.version, 'Config', startTime, configResult.ErrorMessage ?? 'Config update failed');
+        if (!IsStepDone(INSTALL_STEP_ORDER, resumeCheckpoint, 'AngularExcludesUpdated')) {
+            HandleAngularPrebundleExcludes(manifest, context);
+            await SetAppStep(context.ContextUser, createdAppId, 'AngularExcludesUpdated');
         }
-        HandleAngularPrebundleExcludes(manifest, context);
         Callbacks?.OnProgress?.('Record', 'Finalizing installation...');
         const finalStatus = npmInstallWarning ? 'Disabled' : 'Active';
         await SetAppStatus(context.ContextUser, createdAppId, finalStatus);
         if (finalStatus !== 'Active') {
             ToggleServerDynamicPackages(context.RepoRoot, manifest.name, false, context.ServerPackagePath);
         }
-        if (manifest.hooks?.postInstall) {
-            Callbacks?.OnProgress?.('Hooks', 'Running postInstall hook...');
-            await ExecuteHook(manifest.hooks.postInstall, context.RepoRoot);
-        }
-        if (manifest.hooks?.postInstallModule) {
-            Callbacks?.OnProgress?.('Hooks', `Running postInstall module '${manifest.hooks.postInstallModule}'...`);
-            const appInfo = await FindInstalledApp(context.ContextUser, manifest.name);
-            await ExecuteHookModule(manifest.hooks.postInstallModule, {
-                App: appInfo,
-                RepoRoot: context.RepoRoot,
-                Provider: context.DatabaseProvider,
-                ContextUser: context.ContextUser,
-                Callbacks: context.Callbacks,
-                Manifest: manifest,
-            }, context.RepoRoot);
+        await SetAppStep(context.ContextUser, createdAppId, 'Finalized');
+        if (!IsStepDone(INSTALL_STEP_ORDER, resumeCheckpoint, 'HooksRun')) {
+            if (manifest.hooks?.postInstall) {
+                Callbacks?.OnProgress?.('Hooks', 'Running postInstall hook...');
+                await ExecuteHook(manifest.hooks.postInstall, context.RepoRoot);
+            }
+            if (manifest.hooks?.postInstallModule) {
+                Callbacks?.OnProgress?.('Hooks', `Running postInstall module '${manifest.hooks.postInstallModule}'...`);
+                const appInfo = await FindInstalledApp(context.ContextUser, manifest.name);
+                await ExecuteHookModule(manifest.hooks.postInstallModule, {
+                    App: appInfo,
+                    RepoRoot: context.RepoRoot,
+                    Provider: context.DatabaseProvider,
+                    ContextUser: context.ContextUser,
+                    Callbacks: context.Callbacks,
+                    Manifest: manifest,
+                }, context.RepoRoot);
+            }
+            await SetAppStep(context.ContextUser, createdAppId, 'HooksRun');
         }
+        await SetAppStep(context.ContextUser, createdAppId, null);
         try {
             await RecordInstallHistoryEntry(context.ContextUser, createdAppId, 'Install', manifest, {
                 Success: true,
                 DurationSeconds: GetDurationSeconds(startTime),
                 StartedAt: new Date(startTime),
                 EndedAt: new Date(),
-                Summary: 'Initial installation',
+                Summary: isResume ? 'Initial installation (resumed after a prior interrupted attempt)' : 'Initial installation',
             });
         }
         catch (histErr) {
@@ -196,6 +260,7 @@ async function RecordInstallationAtomically(contextUser, manifest, callbacks, pr
     try {
         const appId = await RecordAppInstallation(contextUser, manifest, callbacks, tg, 'Installing', provider, subpath);
         if (manifest.dependencies) {
+            await DeleteAppDependencies(contextUser, appId, tg);
             await RecordAppDependencies(contextUser, appId, manifest.dependencies, tg);
         }
         callbacks?.OnProgress?.('Record', 'Committing installation records...');
@@ -236,6 +301,9 @@ export async function UpgradeApp(options, context) {
             return BuildFailureResult('Upgrade', options.AppName, '', 'Schema', startTime, `App '${options.AppName}' is not installed`);
         }
         upgradeAppId = existingApp.ID;
+        if (existingApp.Status === 'Installing' || existingApp.Status === 'Removing') {
+            return BuildMutexConflictResult('Upgrade', options.AppName, existingApp.Version, startTime, existingApp.Status);
+        }
         previousVersion = existingApp.Version;
         const explicitUpgradeVersion = options.Version;
         const targetVersion = explicitUpgradeVersion ?? (await GetLatestVersion(existingApp.RepositoryURL, context.GitHubOptions, existingApp.Subpath ?? undefined));
@@ -292,8 +360,19 @@ export async function UpgradeApp(options, context) {
                 }
             }
         }
+        const checkpointTargetsThisVersion = existingApp.LastCompletedStepTargetVersion === manifest.version;
+        const resumeCheckpoint = (existingApp.Status === 'Upgrading' || existingApp.Status === 'Error') && checkpointTargetsThisVersion ? (existingApp.LastCompletedStep ?? null) : null;
+        if (resumeCheckpoint) {
+            Callbacks?.OnProgress?.('Resume', `Resuming upgrade of ${options.AppName} to v${manifest.version} from step '${resumeCheckpoint}'...`);
+        }
+        else if ((existingApp.Status === 'Upgrading' || existingApp.Status === 'Error') && existingApp.LastCompletedStep && !checkpointTargetsThisVersion) {
+            Callbacks?.OnProgress?.('Resume', `A previous upgrade attempt targeting a different version (${existingApp.LastCompletedStepTargetVersion ?? 'unknown'}) was left in progress — starting the upgrade to v${manifest.version} from the top instead of resuming it.`);
+        }
+        if (!resumeCheckpoint && existingApp.LastCompletedStep) {
+            await SetAppStep(context.ContextUser, existingApp.ID, null);
+        }
         await SetAppStatus(context.ContextUser, existingApp.ID, 'Upgrading');
-        if (manifest.migrations && manifest.schema) {
+        if (!IsStepDone(UPGRADE_STEP_ORDER, resumeCheckpoint, 'MigrationsApplied') && manifest.migrations && manifest.schema) {
             const migrationResult = await HandleMigrations(manifest, context, subpath);
             if (!migrationResult.Success) {
                 const detail = migrationResult.ErrorMessage ?? 'Migration failed';
@@ -305,55 +384,75 @@ export async function UpgradeApp(options, context) {
                 await SetAppStatus(context.ContextUser, existingApp.ID, 'Error');
                 return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Migration', startTime, recoverable);
             }
+            await SetAppStep(context.ContextUser, existingApp.ID, 'MigrationsApplied', undefined, manifest.version);
         }
-        const effectiveUpgradeVersion = explicitUpgradeVersion ? targetVersion.replace(/^v/, '') : manifest.version;
-        const effectiveUpgradeStrategy = explicitUpgradeVersion ? 'exact' : context.VersionStrategy;
-        const pkgResult = await HandlePackageInstallation(manifest, context, effectiveUpgradeVersion, effectiveUpgradeStrategy, options.Verbose);
         let npmInstallWarning;
-        if (!pkgResult.Success) {
-            if (pkgResult.PackageJsonUpdated) {
-                npmInstallWarning = pkgResult.ErrorMessage;
-                Callbacks?.OnWarn?.('Packages', `npm install failed — package.json entries were updated but dependencies were not resolved. Run 'npm install' manually after fixing npm auth.\n  Detail: ${pkgResult.ErrorMessage}`);
+        if (!IsStepDone(UPGRADE_STEP_ORDER, resumeCheckpoint, 'PackagesInstalled')) {
+            const effectiveUpgradeVersion = explicitUpgradeVersion ? targetVersion.replace(/^v/, '') : manifest.version;
+            const effectiveUpgradeStrategy = explicitUpgradeVersion ? 'exact' : context.VersionStrategy;
+            const pkgResult = await HandlePackageInstallation(manifest, context, effectiveUpgradeVersion, effectiveUpgradeStrategy, options.Verbose);
+            if (!pkgResult.Success) {
+                if (pkgResult.PackageJsonUpdated) {
+                    npmInstallWarning = pkgResult.ErrorMessage;
+                    Callbacks?.OnWarn?.('Packages', `npm install failed — package.json entries were updated but dependencies were not resolved. Run 'npm install' manually after fixing npm auth.\n  Detail: ${pkgResult.ErrorMessage}`);
+                }
+                else {
+                    await RecordFailureHistory(context.ContextUser, existingApp.ID, 'Upgrade', manifest, 'Packages', pkgResult.ErrorMessage ?? 'Package update failed', startTime, previousVersion);
+                    await SetAppStatus(context.ContextUser, existingApp.ID, 'Error');
+                    return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Packages', startTime, pkgResult.ErrorMessage ?? 'Package update failed');
+                }
             }
             else {
-                await RecordFailureHistory(context.ContextUser, existingApp.ID, 'Upgrade', manifest, 'Packages', pkgResult.ErrorMessage ?? 'Package update failed', startTime, previousVersion);
+                await SetAppStep(context.ContextUser, existingApp.ID, 'PackagesInstalled', undefined, manifest.version);
+            }
+        }
+        if (!IsStepDone(UPGRADE_STEP_ORDER, resumeCheckpoint, 'ConfigUpdated')) {
+            const configResult = HandleServerConfig(manifest, context);
+            if (!configResult.Success) {
+                await RecordFailureHistory(context.ContextUser, existingApp.ID, 'Upgrade', manifest, 'Config', configResult.ErrorMessage ?? 'Config update failed', startTime, previousVersion);
                 await SetAppStatus(context.ContextUser, existingApp.ID, 'Error');
-                return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Packages', startTime, pkgResult.ErrorMessage ?? 'Package update failed');
+                return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Config', startTime, configResult.ErrorMessage ?? 'Config update failed');
             }
+            await SetAppStep(context.ContextUser, existingApp.ID, 'ConfigUpdated', undefined, manifest.version);
         }
-        const configResult = HandleServerConfig(manifest, context);
-        if (!configResult.Success) {
-            await RecordFailureHistory(context.ContextUser, existingApp.ID, 'Upgrade', manifest, 'Config', configResult.ErrorMessage ?? 'Config update failed', startTime, previousVersion);
-            await SetAppStatus(context.ContextUser, existingApp.ID, 'Error');
-            return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Config', startTime, configResult.ErrorMessage ?? 'Config update failed');
+        if (!IsStepDone(UPGRADE_STEP_ORDER, resumeCheckpoint, 'AngularExcludesUpdated')) {
+            HandleAngularPrebundleExcludes(manifest, context);
+            await SetAppStep(context.ContextUser, existingApp.ID, 'AngularExcludesUpdated', undefined, manifest.version);
         }
-        HandleAngularPrebundleExcludes(manifest, context);
         await UpdateAppRecord(context.ContextUser, existingApp.ID, {
             Version: manifest.version,
             ManifestJSON: JSON.stringify(manifest),
             Status: 'Active',
         });
-        if (manifest.hooks?.postUpgrade) {
-            Callbacks?.OnProgress?.('Hooks', 'Running postUpgrade hook...');
-            await ExecuteHook(manifest.hooks.postUpgrade, context.RepoRoot);
-        }
-        if (manifest.hooks?.postUpgradeModule) {
-            Callbacks?.OnProgress?.('Hooks', `Running postUpgrade module '${manifest.hooks.postUpgradeModule}'...`);
-            await ExecuteHookModule(manifest.hooks.postUpgradeModule, {
-                App: existingApp,
-                RepoRoot: context.RepoRoot,
-                Provider: context.DatabaseProvider,
-                ContextUser: context.ContextUser,
-                Callbacks: context.Callbacks,
-                Manifest: manifest,
-            }, context.RepoRoot);
+        await SetAppStep(context.ContextUser, existingApp.ID, 'RecordUpdated', undefined, manifest.version);
+        if (!IsStepDone(UPGRADE_STEP_ORDER, resumeCheckpoint, 'HooksRun')) {
+            if (manifest.hooks?.postUpgrade) {
+                Callbacks?.OnProgress?.('Hooks', 'Running postUpgrade hook...');
+                await ExecuteHook(manifest.hooks.postUpgrade, context.RepoRoot);
+            }
+            if (manifest.hooks?.postUpgradeModule) {
+                Callbacks?.OnProgress?.('Hooks', `Running postUpgrade module '${manifest.hooks.postUpgradeModule}'...`);
+                await ExecuteHookModule(manifest.hooks.postUpgradeModule, {
+                    App: existingApp,
+                    RepoRoot: context.RepoRoot,
+                    Provider: context.DatabaseProvider,
+                    ContextUser: context.ContextUser,
+                    Callbacks: context.Callbacks,
+                    Manifest: manifest,
+                }, context.RepoRoot);
+            }
+            await SetAppStep(context.ContextUser, existingApp.ID, 'HooksRun', undefined, manifest.version);
         }
-        if (manifest.dependencies) {
+        if (!IsStepDone(UPGRADE_STEP_ORDER, resumeCheckpoint, 'DependenciesReplaced') && manifest.dependencies) {
             const depsReplaced = await ReplaceAppDependenciesAtomically(context.ContextUser, existingApp.ID, manifest.dependencies);
             if (!depsReplaced) {
                 Callbacks?.OnWarn?.('Record', 'App upgraded, but its dependency records could not be updated atomically — re-run the upgrade to refresh them.');
             }
+            else {
+                await SetAppStep(context.ContextUser, existingApp.ID, 'DependenciesReplaced', undefined, manifest.version);
+            }
         }
+        await SetAppStep(context.ContextUser, existingApp.ID, null, undefined, manifest.version);
         try {
             await RecordInstallHistoryEntry(context.ContextUser, existingApp.ID, 'Upgrade', manifest, {
                 PreviousVersion: previousVersion,
@@ -409,12 +508,23 @@ export async function RemoveApp(options, context) {
             return BuildFailureResult('Remove', options.AppName, '', 'Schema', startTime, `App '${options.AppName}' is not installed`);
         }
         removeAppId = existingApp.ID;
+        if (existingApp.Status === 'Installing' || existingApp.Status === 'Upgrading') {
+            return BuildMutexConflictResult('Remove', options.AppName, existingApp.Version, startTime, existingApp.Status);
+        }
         if (!options.Force) {
             const dependents = await FindDependentApps(context.ContextUser, options.AppName);
             if (dependents.length > 0) {
                 return BuildFailureResult('Remove', options.AppName, existingApp.Version, 'Schema', startTime, `Cannot remove: the following apps depend on ${options.AppName}: ${dependents.join(', ')}. Use --force to override.`);
             }
         }
+        const rawCheckpoint = existingApp.Status === 'Removing' || existingApp.Status === 'Error' ? (existingApp.LastCompletedStep ?? null) : null;
+        const resumeCheckpoint = IsOwnCheckpoint(REMOVE_STEP_ORDER, rawCheckpoint) ? rawCheckpoint : null;
+        if (existingApp.LastCompletedStep && !resumeCheckpoint) {
+            await SetAppStep(context.ContextUser, existingApp.ID, null);
+        }
+        if (resumeCheckpoint) {
+            Callbacks?.OnProgress?.('Resume', `Resuming removal of ${options.AppName} from step '${resumeCheckpoint}'...`);
+        }
         await SetAppStatus(context.ContextUser, existingApp.ID, 'Removing');
         const manifest = JSON.parse(existingApp.ManifestJSON);
         removeManifest = manifest;
@@ -433,90 +543,106 @@ export async function RemoveApp(options, context) {
                 Manifest: manifest,
             }, context.RepoRoot);
         }
-        const shareCheck = existingApp.SchemaName
-            ? await CheckSchemaSharedByOtherApps(context.ContextUser, existingApp.SchemaName, existingApp.ID)
-            : { Shared: false, CheckFailed: false };
-        const schemaShared = shareCheck.Shared;
-        const shareCheckError = shareCheck.CheckFailed
-            ? `Could not determine whether schema '${existingApp.SchemaName}' is shared by other Open Apps (share-check query failed): ${shareCheck.ErrorMessage ?? 'unknown error'}`
-            : undefined;
-        if (schemaShared && !shareCheck.CheckFailed) {
-            Callbacks?.OnWarn?.('Schema', `Schema '${existingApp.SchemaName}' is still used by another installed Open App — skipping metadata + schema removal to protect co-tenant data.`);
-        }
-        let metadataResult = { Success: true };
-        if (existingApp.SchemaName && !schemaShared) {
-            Callbacks?.OnProgress?.('Metadata', `Removing entity metadata for schema '${existingApp.SchemaName}'...`);
-            metadataResult = await RemoveAppEntityMetadata(existingApp.SchemaName, context.ContextUser, Callbacks);
-        }
-        let teardownResult = { Success: true };
-        if (!options.KeepData) {
-            teardownResult = await HandleTeardown(manifest, context, existingApp.Subpath ?? undefined);
-            if (!teardownResult.Success) {
-                Callbacks?.OnError?.('Metadata', `Teardown failed: ${teardownResult.ErrorMessage}`);
+        if (!IsStepDone(REMOVE_STEP_ORDER, resumeCheckpoint, 'DbCleanupDone')) {
+            const shareCheck = existingApp.SchemaName
+                ? await CheckSchemaSharedByOtherApps(context.ContextUser, existingApp.SchemaName, existingApp.ID)
+                : { Shared: false, CheckFailed: false };
+            const schemaShared = shareCheck.Shared;
+            const shareCheckError = shareCheck.CheckFailed
+                ? `Could not determine whether schema '${existingApp.SchemaName}' is shared by other Open Apps (share-check query failed): ${shareCheck.ErrorMessage ?? 'unknown error'}`
+                : undefined;
+            if (schemaShared && !shareCheck.CheckFailed) {
+                Callbacks?.OnWarn?.('Schema', `Schema '${existingApp.SchemaName}' is still used by another installed Open App — skipping metadata + schema removal to protect co-tenant data.`);
             }
-        }
-        let schemaDropError;
-        if (!options.KeepData && existingApp.SchemaName && !schemaShared) {
-            Callbacks?.OnProgress?.('Schema', `Dropping schema '${existingApp.SchemaName}'...`);
-            const dropResult = await DropAppSchema(existingApp.SchemaName, context.DatabaseProvider, {
-                allowDoubleUnderscore: options.AllowDoubleUnderscoreSchema === true,
-            });
-            if (!dropResult.Success) {
-                schemaDropError = dropResult.ErrorMessage;
-                Callbacks?.OnError?.('Schema', `Failed to drop schema: ${dropResult.ErrorMessage}`);
+            let metadataResult = { Success: true };
+            if (existingApp.SchemaName && !schemaShared) {
+                Callbacks?.OnProgress?.('Metadata', `Removing entity metadata for schema '${existingApp.SchemaName}'...`);
+                const declaredApplicationIds = await ExtractDeclaredApplicationIds(manifest, context, existingApp.Subpath ?? undefined);
+                metadataResult = await RemoveAppEntityMetadata(existingApp.SchemaName, context.ContextUser, Callbacks, context.DatabaseProvider, {
+                    DatabaseProvider: context.DatabaseProvider,
+                    MJCoreSchema: context.MJCoreSchema,
+                    DeclaredApplicationIds: declaredApplicationIds,
+                });
             }
-        }
-        const removalErrors = [
-            shareCheckError,
-            teardownResult.Success ? undefined : teardownResult.ErrorMessage,
-            metadataResult.Success ? undefined : metadataResult.ErrorMessage,
-            schemaDropError,
-        ].filter((e) => !!e);
-        if (removalErrors.length > 0) {
-            const combined = removalErrors.join('; ');
-            await RecordInstallHistoryEntry(context.ContextUser, existingApp.ID, 'Remove', manifest, {
-                Success: false,
-                DurationSeconds: GetDurationSeconds(startTime),
-                StartedAt: new Date(startTime),
-                EndedAt: new Date(),
-                Summary: `Remove failed: ${combined}`,
-            });
-            await SetAppStatus(context.ContextUser, existingApp.ID, 'Error');
-            return BuildFailureResult('Remove', options.AppName, existingApp.Version, 'Schema', startTime, combined);
-        }
-        Callbacks?.OnProgress?.('Config', 'Removing config, client bootstrap, and package references...');
-        const otherApps = (await ListInstalledApps(context.ContextUser))
-            .filter(a => a.Name !== options.AppName && a.Status !== 'Removed');
-        const otherManifests = otherApps.flatMap(a => {
-            try {
-                return [JSON.parse(a.ManifestJSON)];
+            let teardownResult = { Success: true };
+            if (!options.KeepData) {
+                teardownResult = await HandleTeardown(manifest, context, existingApp.Subpath ?? undefined);
+                if (!teardownResult.Success) {
+                    Callbacks?.OnError?.('Metadata', `Teardown failed: ${teardownResult.ErrorMessage}`);
+                }
             }
-            catch {
-                Callbacks?.OnWarn?.('Config', `Ignoring app '${a.Name}' when computing shared excludes — its ManifestJSON could not be parsed.`);
-                return [];
+            let schemaDropError;
+            if (!options.KeepData && existingApp.SchemaName && !schemaShared) {
+                Callbacks?.OnProgress?.('Schema', `Dropping schema '${existingApp.SchemaName}'...`);
+                const dropResult = await DropAppSchema(existingApp.SchemaName, context.DatabaseProvider, {
+                    allowDoubleUnderscore: options.AllowDoubleUnderscoreSchema === true,
+                });
+                if (!dropResult.Success) {
+                    schemaDropError = dropResult.ErrorMessage;
+                    Callbacks?.OnError?.('Schema', `Failed to drop schema: ${dropResult.ErrorMessage}`);
+                }
             }
-        });
-        await Promise.all([
-            Promise.resolve(RemoveServerDynamicPackages(context.RepoRoot, options.AppName, context.ServerPackagePath)),
-            Promise.resolve(manifest.schema ? RemoveEntityPackageMapping(context.RepoRoot, manifest.schema.name, context.ServerPackagePath) : undefined),
-            Promise.resolve(HandleAngularPrebundleExcludeRemoval(manifest, otherManifests, context)),
-            Promise.resolve(RemoveAppPackages({
-                RepoRoot: context.RepoRoot,
-                ServerPackages: manifest.packages?.server ?? [],
-                ClientPackages: manifest.packages?.client ?? [],
-                SharedPackages: manifest.packages?.shared ?? [],
-                Version: existingApp.Version,
-                ServerPackagePath: context.ServerPackagePath,
-                ClientPackagePath: context.ClientPackagePath,
-                PackageManager: context.PackageManager,
-                AdditionalTargets: context.AdditionalTargets,
-            })),
-        ]);
-        Callbacks?.OnProgress?.('Packages', 'Running package install...');
-        const installResult = RunPackageInstall(context.RepoRoot, options.Verbose, undefined, context.PackageManager);
-        if (!installResult.Success) {
-            Callbacks?.OnWarn?.('Packages', `Package install warning during removal: ${installResult.ErrorMessage}`);
+            const removalErrors = [
+                shareCheckError,
+                teardownResult.Success ? undefined : teardownResult.ErrorMessage,
+                metadataResult.Success ? undefined : metadataResult.ErrorMessage,
+                schemaDropError,
+            ].filter((e) => !!e);
+            if (removalErrors.length > 0) {
+                const combined = removalErrors.join('; ');
+                await RecordInstallHistoryEntry(context.ContextUser, existingApp.ID, 'Remove', manifest, {
+                    Success: false,
+                    DurationSeconds: GetDurationSeconds(startTime),
+                    StartedAt: new Date(startTime),
+                    EndedAt: new Date(),
+                    Summary: `Remove failed: ${combined}`,
+                });
+                await SetAppStatus(context.ContextUser, existingApp.ID, 'Error');
+                return BuildFailureResult('Remove', options.AppName, existingApp.Version, 'Schema', startTime, combined);
+            }
+            await SetAppStep(context.ContextUser, existingApp.ID, 'DbCleanupDone');
+        }
+        if (!IsStepDone(REMOVE_STEP_ORDER, resumeCheckpoint, 'FilesRemoved')) {
+            Callbacks?.OnProgress?.('Config', 'Removing config, client bootstrap, and package references...');
+            const otherApps = (await ListInstalledApps(context.ContextUser))
+                .filter(a => a.Name !== options.AppName && a.Status !== 'Removed');
+            const otherManifests = otherApps.flatMap(a => {
+                try {
+                    return [JSON.parse(a.ManifestJSON)];
+                }
+                catch {
+                    Callbacks?.OnWarn?.('Config', `Ignoring app '${a.Name}' when computing shared excludes — its ManifestJSON could not be parsed.`);
+                    return [];
+                }
+            });
+            await Promise.all([
+                Promise.resolve(RemoveServerDynamicPackages(context.RepoRoot, options.AppName, context.ServerPackagePath)),
+                Promise.resolve(manifest.schema ? RemoveEntityPackageMapping(context.RepoRoot, manifest.schema.name, context.ServerPackagePath) : undefined),
+                Promise.resolve(HandleAngularPrebundleExcludeRemoval(manifest, otherManifests, context)),
+                Promise.resolve(RemoveAppPackages({
+                    RepoRoot: context.RepoRoot,
+                    ServerPackages: manifest.packages?.server ?? [],
+                    ClientPackages: manifest.packages?.client ?? [],
+                    SharedPackages: manifest.packages?.shared ?? [],
+                    Version: existingApp.Version,
+                    ServerPackagePath: context.ServerPackagePath,
+                    ClientPackagePath: context.ClientPackagePath,
+                    PackageManager: context.PackageManager,
+                    AdditionalTargets: context.AdditionalTargets,
+                })),
+            ]);
+            Callbacks?.OnProgress?.('Packages', 'Running package install...');
+            const installResult = RunPackageInstall(context.RepoRoot, options.Verbose, undefined, context.PackageManager);
+            if (!installResult.Success) {
+                Callbacks?.OnWarn?.('Packages', `Package install warning during removal: ${installResult.ErrorMessage}`);
+            }
+            await SetAppStep(context.ContextUser, existingApp.ID, 'FilesRemoved');
         }
+        await UpdateAppRecord(context.ContextUser, existingApp.ID, {
+            Status: 'Removed',
+            LastCompletedStep: null,
+            LastCompletedStepTargetVersion: null,
+        });
         try {
             await RecordInstallHistoryEntry(context.ContextUser, existingApp.ID, 'Remove', manifest, {
                 Success: true,
@@ -529,9 +655,6 @@ export async function RemoveApp(options, context) {
         catch (histErr) {
             Callbacks?.OnWarn?.('Record', `App removed, but the history audit entry could not be written: ${histErr instanceof Error ? histErr.message : String(histErr)}`);
         }
-        await UpdateAppRecord(context.ContextUser, existingApp.ID, {
-            Status: 'Removed',
-        });
         Callbacks?.OnSuccess?.('Remove', `Successfully removed ${options.AppName}`);
         return {
             Success: true,
@@ -565,6 +688,9 @@ export async function DisableApp(appName, context) {
     if (!app) {
         return BuildFailureResult('Install', appName, '', 'Config', startTime, `App '${appName}' is not installed`);
     }
+    if (!SETTLED_STATUSES.has(app.Status)) {
+        return BuildMutexConflictResult('Install', appName, app.Version, startTime, app.Status, 'disable');
+    }
     const toggle = ToggleServerDynamicPackages(context.RepoRoot, appName, false, context.ServerPackagePath);
     if (!toggle.Success) {
         return BuildFailureResult('Install', appName, app.Version, 'Config', startTime, toggle.ErrorMessage ?? 'Failed to update dynamicPackages.server in mj.config.cjs');
@@ -585,6 +711,9 @@ export async function EnableApp(appName, context) {
     if (!app) {
         return BuildFailureResult('Install', appName, '', 'Config', startTime, `App '${appName}' is not installed`);
     }
+    if (!SETTLED_STATUSES.has(app.Status)) {
+        return BuildMutexConflictResult('Install', appName, app.Version, startTime, app.Status, 'enable');
+    }
     const toggle = ToggleServerDynamicPackages(context.RepoRoot, appName, true, context.ServerPackagePath);
     if (!toggle.Success) {
         return BuildFailureResult('Install', appName, app.Version, 'Config', startTime, toggle.ErrorMessage ?? 'Failed to update dynamicPackages.server in mj.config.cjs');
@@ -607,6 +736,9 @@ async function ResolveDependencyChain(manifest, context) {
     const installedApps = await ListInstalledApps(context.ContextUser);
     const installedMap = {};
     for (const app of installedApps) {
+        if (app.Status !== 'Active' && app.Status !== 'Disabled') {
+            continue;
+        }
         installedMap[app.Name] = { Version: app.Version, Repository: app.RepositoryURL };
     }
     const dependencies = (manifest.dependencies ?? {});
@@ -922,63 +1054,88 @@ async function ExecuteHookModule(specifier, payload, repoRoot) {
         throw new OpenAppPhaseError('Hooks', err instanceof Error ? err.message : String(err));
     }
 }
-export async function RemoveAppEntityMetadata(schemaName, contextUser, callbacks, provider) {
+export async function RemoveAppEntityMetadata(schemaName, contextUser, callbacks, provider, options) {
     try {
         const rv = new RunView();
         const escaped = EscapeSqlString(schemaName);
+        const declaredAppIds = (options?.DeclaredApplicationIds ?? [])
+            .map((id) => NormalizeUUID(id))
+            .filter((id) => !!id);
+        const useFkGraph = !!options?.DatabaseProvider?.Dialect;
         const md = (provider ?? new Metadata());
-        const tg = await md.CreateTransactionGroup();
-        const queueDeleteByFilterOrThrow = async (entityName, filter) => {
-            const r = await QueueDeleteEntitiesByFilter(rv, contextUser, entityName, filter, tg);
-            if (!r.Success) {
-                throw new Error(r.ErrorMessage ?? `Failed to queue delete of ${entityName} records`);
-            }
-        };
         const entityResult = await rv.RunView({
             EntityName: 'MJ: Entities',
-            ExtraFilter: `SchemaName = '${escaped}'`,
+            ExtraFilter: `LOWER(SchemaName) = LOWER('${escaped}')`,
             ResultType: 'entity_object',
         }, contextUser);
         if (!entityResult.Success) {
             throw new Error(`Failed to query entities for schema '${schemaName}': ${entityResult.ErrorMessage}`);
         }
         if (entityResult.Results.length === 0) {
-            await queueDeleteByFilterOrThrow('MJ: Schema Info', `SchemaName = '${escaped}'`);
+            const tg = await md.CreateTransactionGroup();
+            const r = await QueueDeleteEntitiesByFilter(rv, contextUser, 'MJ: Schema Info', `LOWER(SchemaName) = LOWER('${escaped}')`, tg);
+            if (!r.Success) {
+                throw new Error(r.ErrorMessage ?? 'Failed to queue delete of MJ: Schema Info records');
+            }
             if (!(await tg.Submit())) {
                 throw new Error('Transaction failed: schema-info cleanup could not be committed');
             }
+            await DeleteAppOwnedApplications(rv, declaredAppIds, contextUser, callbacks);
             callbacks?.OnSuccess?.('Metadata', `Entity metadata for schema '${schemaName}' removed`);
             return { Success: true };
         }
         const entityIds = entityResult.Results.map((e) => e.ID);
         const idList = entityIds.map((id) => `'${EscapeSqlString(id)}'`).join(',');
-        const fieldResult = await rv.RunView({
-            EntityName: 'MJ: Entity Fields',
-            ExtraFilter: `EntityID IN (${idList})`,
-            ResultType: 'entity_object',
-        }, contextUser);
-        if (!fieldResult.Success) {
-            throw new Error(`Failed to query entity fields for schema '${schemaName}': ${fieldResult.ErrorMessage}`);
-        }
-        const fieldIdList = fieldResult.Results.map((f) => `'${EscapeSqlString(f.ID)}'`).join(',');
         const ownedAppIds = await FindAppOwnedApplications(rv, contextUser, entityIds, idList);
-        if (fieldIdList.length > 0) {
-            await queueDeleteByFilterOrThrow('MJ: Entity Field Values', `EntityFieldID IN (${fieldIdList})`);
-        }
-        await queueDeleteByFilterOrThrow('MJ: Entity Permissions', `EntityID IN (${idList})`);
-        await queueDeleteByFilterOrThrow('MJ: Application Entities', `EntityID IN (${idList})`);
-        await queueDeleteByFilterOrThrow('MJ: Entity Settings', `EntityID IN (${idList})`);
-        await queueDeleteByFilterOrThrow('MJ: Entity Relationships', `EntityID IN (${idList}) OR RelatedEntityID IN (${idList})`);
-        await queueDeleteByFilterOrThrow('MJ: Entity Fields', `EntityID IN (${idList})`);
-        for (const entity of entityResult.Results) {
-            entity.TransactionGroup = tg;
-            await entity.Delete();
-        }
-        await queueDeleteByFilterOrThrow('MJ: Schema Info', `SchemaName = '${escaped}'`);
-        if (!(await tg.Submit())) {
-            throw new Error('Transaction failed: entity metadata cleanup could not be committed atomically');
-        }
-        await DeleteAppOwnedApplications(rv, ownedAppIds, contextUser, callbacks);
+        if (useFkGraph) {
+            const dbProvider = options.DatabaseProvider;
+            const mjSchema = options?.MJCoreSchema ?? '__mj';
+            const rootPredicate = buildRootDoomedPredicate(dbProvider.Dialect, schemaName);
+            await RunFkGraphTeardown(dbProvider, mjSchema, rootPredicate, callbacks);
+        }
+        else {
+            const tg = await md.CreateTransactionGroup();
+            const queueDeleteByFilterOrThrow = async (entityName, filter) => {
+                const r = await QueueDeleteEntitiesByFilter(rv, contextUser, entityName, filter, tg);
+                if (!r.Success) {
+                    throw new Error(r.ErrorMessage ?? `Failed to queue delete of ${entityName} records`);
+                }
+            };
+            const fieldResult = await rv.RunView({
+                EntityName: 'MJ: Entity Fields',
+                ExtraFilter: `EntityID IN (${idList})`,
+                ResultType: 'entity_object',
+            }, contextUser);
+            if (!fieldResult.Success) {
+                throw new Error(`Failed to query entity fields for schema '${schemaName}': ${fieldResult.ErrorMessage}`);
+            }
+            const fieldIdList = fieldResult.Results.map((f) => `'${EscapeSqlString(f.ID)}'`).join(',');
+            if (fieldIdList.length > 0) {
+                await queueDeleteByFilterOrThrow('MJ: Entity Field Values', `EntityFieldID IN (${fieldIdList})`);
+            }
+            await queueDeleteByFilterOrThrow('MJ: Entity Permissions', `EntityID IN (${idList})`);
+            await queueDeleteByFilterOrThrow('MJ: Application Entities', `EntityID IN (${idList})`);
+            await queueDeleteByFilterOrThrow('MJ: Entity Settings', `EntityID IN (${idList})`);
+            await queueDeleteByFilterOrThrow('MJ: Entity Relationships', `EntityID IN (${idList}) OR RelatedEntityID IN (${idList})`);
+            await queueDeleteByFilterOrThrow('MJ: Entity Fields', `EntityID IN (${idList})`);
+            for (const entity of entityResult.Results) {
+                entity.TransactionGroup = tg;
+                await entity.Delete();
+            }
+            await queueDeleteByFilterOrThrow('MJ: Schema Info', `SchemaName = '${escaped}'`);
+            if (!(await tg.Submit())) {
+                throw new Error('Transaction failed: entity metadata cleanup could not be committed atomically');
+            }
+        }
+        const allAppIds = [];
+        const appSeen = new Set();
+        for (const id of ownedAppIds.map((x) => NormalizeUUID(x)).concat(declaredAppIds)) {
+            if (id && !appSeen.has(id)) {
+                appSeen.add(id);
+                allAppIds.push(id);
+            }
+        }
+        await DeleteAppOwnedApplications(rv, allAppIds, contextUser, callbacks);
         callbacks?.OnSuccess?.('Metadata', `Entity metadata for schema '${schemaName}' removed`);
         return { Success: true };
     }
@@ -988,6 +1145,33 @@ export async function RemoveAppEntityMetadata(schemaName, contextUser, callbacks
         return { Success: false, ErrorMessage: `Failed to remove entity metadata for schema '${schemaName}': ${message}` };
     }
 }
+async function ExtractDeclaredApplicationIds(manifest, context, subpath) {
+    if (!manifest.migrations || !manifest.schema) {
+        return [];
+    }
+    let tempDir;
+    try {
+        tempDir = join(tmpdir(), `mj-app-${manifest.name}-appids-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        const download = await DownloadAppMigrations(manifest, context, tempDir, subpath);
+        if (!download.Success) {
+            return [];
+        }
+        return await extractApplicationIds(tempDir);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        if (tempDir) {
+            try {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch {
+            }
+        }
+    }
+}
 async function FindAppOwnedApplications(rv, contextUser, entityIds, idList) {
     const ours = new Set(entityIds.map((id) => NormalizeUUID(id)));
     const linked = await rv.RunView({ EntityName: 'MJ: Application Entities', ExtraFilter: `EntityID IN (${idList})`, Fields: ['ApplicationID'], ResultType: 'simple' }, contextUser);