Sets expectations that formal documentation for the new UI is still being written.
Directs users to the YouTube video for a demonstration and highlights the removal of `InstallAppsAndSysprep.cmd`.
Adds LTSC to the list of supported Windows versions and emphasizes the fast deployment time with bold formatting. Also includes minor typographic corrections.
Adds a new function to programmatically retrieve the required authentication token for the Lenovo PSREF API. This change is necessary as Lenovo is now restricting API access without a JavaScript-generated token.
The new function launches a headless browser instance, uses the DevTools protocol to extract the token from local storage, and then terminates the browser. This ensures continued access to the comprehensive model data available through the PSREF API, which is not fully present in other catalogs.
The User-Agent string has also been updated.
Updates the Win32 app installation script to handle WinGet-sourced apps and user-defined apps in two separate batches instead of merging them. This ensures all WinGet apps are installed before any user-defined apps.
The core installation logic is extracted into a reusable function, improving script structure and readability.
Additionally, removes a pause command and a redundant console message from other scripts to improve automation flow.
Change the dependency resolution logic from a single global scan to an isolated, per-application scan.
This prevents potential version conflicts that could occur if multiple applications require different versions of the same dependency package. Each application now resolves its dependencies only from its own dedicated 'Dependencies' folder, ensuring the correct versions are used and making the installation process more robust and reliable.
Refactors the application download logic to correctly handle packages from the 'msstore' source, which does not support architecture specification.
- The download process no longer passes an architecture parameter for msstore apps.
- The architecture selection dropdown in the UI is now disabled for msstore apps to prevent invalid configurations.
- Imported or searched msstore apps will display 'NA' for their architecture.
Refactors the Store app installation script to be significantly more robust and intelligent. The new implementation automatically resolves application dependencies instead of relying on a simple folder structure.
Key improvements include:
- Pre-scans all application folders to create a central catalog of available dependencies.
- Parses the `AppxManifest.xml` from each main app package (including from within bundles) to determine its true dependencies.
- Resolves the required dependencies by finding the best available package from the catalog that meets version and OS architecture requirements.
- Adds support for extracting zipped dependency packages.
- Improves temporary file management and logging.
Refactors the Winget search functionality to enhance performance and provide a better user experience.
- Updates the UI to show a wait cursor, disable the search button, and display a status message during the search operation.
- Improves the post-search status message to differentiate between new and total applications found.
- Utilizes `ForEach-Object -Parallel` to speed up the processing of search results on multi-core systems.
Removes the log message that is generated when auto-scrolling is enabled. This reduces log spam, as this can be a frequent event.
The message for when a user manually disables auto-scrolling is retained.
Adds a blank line after each application installation command. This visually separates the output for each app, making the logs easier to read in the terminal.
Enhances the driver mapping logic to ensure JSON files with a single entry are handled correctly. The model matching is now more flexible, allowing for partial matches in either direction between the system's reported model and the mapping file.
Adds a user-facing message to indicate that the driver injection process may take a significant amount of time, preventing confusion about the script stalling.
Refactors the error handling for failed build jobs to more reliably capture the root cause of the failure.
The logic now uses `Receive-Job` with an `ErrorVariable` to directly capture the error stream from the job, which provides a more accurate terminating error message than the previous method.
Additionally, the error message box now includes the full path to the log file, making it easier for the user to locate.
Improves the reliability and clarity of the application download process.
- Introduces specific error codes for download failures, such as publisher restrictions from the Microsoft Store.
- Blocks downloading the Company Portal app from the `winget` source due to packaging issues and provides a user-friendly message.
- Refines status messages in the UI for better user feedback.
- Installs the WinGet PowerShell module for all users to prevent context-related issues.
Enhances the application download logic to automatically extract zip archives. This allows for handling packages that are delivered in a compressed format.
Improves the reliability of identifying UWP applications by iterating through all downloaded files instead of checking only the first one. This prevents errors when multiple files are present after download or extraction.
Adds cleanup logic to the window's `Closed` event handler to properly terminate any active background build job.
This prevents the build process from becoming an orphaned job if the user closes the UI while a build is in progress. The change ensures the job, its polling timer, and log streams are all stopped and disposed of correctly.
Refines the logic for verifying existing Win32 applications by checking for architecture-specific names (x86, x64, arm64).
Enhances validation by ensuring the application folder contains files of a sufficient size, not just that the folder exists.
Adds more detailed logging to aid in troubleshooting cases where an app is not found or its content is missing.
Improves the pre-download check to correctly identify existing multi-architecture applications by looking for both x86 and x64 subfolders.
This prevents unnecessary re-downloads of apps that have separate builds for each architecture. The logic is also consolidated to remove a redundant code block.
Replaces the `Compare-Object` cmdlet with a faster, manual loop comparison on pre-sorted arrays to optimize the VHDX cache check for matching updates.
This change also refactors the extraction of update filenames for better readability and adds checks for empty collections to improve script robustness.
Streamlines the logic for finding Cumulative Update (CU) and Cumulative Update Preview (CUP) files by removing redundant code.
The file search now relies directly on a wildcard search using the KB article ID, instead of first attempting a match with a specific filename. This change simplifies the script and makes the discovery process more direct. Also removes commented-out code.
Introduces the ability to specify and download multiple architectures for a single application.
- Adds an "Architecture" dropdown column to the Winget UI, allowing users to select the desired architecture(s) for each app (e.g., x86, x64, arm64, or 'x86 x64').
- Updates the download logic to process each specified architecture, creating separate subfolders for multi-architecture Win32 apps.
- Modifies the app list format to save and load the selected architecture for each application.
- Improves the download process by checking if an application has already been downloaded before attempting a new download.
Removes the use of global variables for paths and architecture settings. Instead, these values are now passed explicitly as parameters to the relevant functions.
This change improves code clarity, reduces the risk of side effects, and makes the functions more modular and easier to test.
Adds standard PowerShell comment-based help blocks (synopsis and description) to all UI and common library script modules (`.psm1`) and the main UI entry point script (`.ps1`).
This improves maintainability and discoverability by documenting the purpose of each script file. Also removes various redundant or commented-out code blocks.
Adds a "Threads" setting to the UI, allowing users to control the throttle limit for parallel tasks like driver and application processing.
This introduces a new textbox in the build options and updates the parallel processing function to use this configurable value instead of a hardcoded one.
Input validation is also added to ensure the threads value is a valid integer and is at least 1. The new setting is integrated into the configuration save/load functionality.
Adds a validation check to ensure application names are unique.
If a user attempts to add an application with a name that already exists, a warning message is displayed, and the operation is cancelled.
Prevents stale, intermediate status messages from overwriting the final status of a completed task in the UI.
A set of completed task identifiers is now maintained. Any incoming intermediate status updates for tasks that are already marked as complete are ignored.
The job completion logic is also refactored for better robustness and clarity across different job-end states (failed, completed with data, completed without data).
Improves the "Copy BYO Apps" functionality by centralizing the `UserAppList.json` update process. The application list is now saved once from the UI before starting the copy, rather than individually within each background task.
Adds a confirmation prompt that warns the user if any application folders already exist in the destination, allowing them to choose whether to overwrite them. The copy logic is updated to remove existing folders before copying to ensure a clean state.
Enhances the orchestrator script to skip application installation steps if no corresponding app lists or files are present. This prevents unnecessary script executions and cleans up the output log.
Makes the 'Arguments' field optional when adding a 'Bring Your Own' application, simplifying the process for apps without arguments.
Ensures the 'Priority' field for applications is consistently saved as an integer to improve data integrity.
Removes the check for a pre-existing capture ISO when applications are being installed.
This change simplifies the logic by unconditionally creating the capture media if `InstallApps` is enabled. This ensures the media is always correctly configured for capturing the virtual machine to an FFU.
Introduces the ability to use a custom XML file for Office installation, allowing for more flexible configurations.
The build script now accepts an `OfficeConfigXMLFile` parameter. If provided, its filename will be used for the installation.
The Office Deployment Toolkit is now downloaded to the specified Office path instead of the development path. UI tooltips are updated to clarify this behavior.
Improves the tooltips for the Office installation path and configuration XML options.
The updated text provides clearer guidance on the purpose and usage of these settings.
Implements the click handler for the browse button associated with the Office configuration XML file path.
This change enables users to select the configuration file via a file dialog, automatically populating the path into the text field and improving usability.
Forces the creation of capture media if app installation is enabled and the capture ISO does not already exist.
This change prevents a failure later in the build process by ensuring the necessary media is available.
Improves the performance of creating multiple deployment USB drives by refactoring the process to run in parallel using `ForEach-Object -Parallel`.
Key changes:
- Mounts the deployment ISO once before processing begins, rather than for each individual drive.
- Partitions, formats, and copies files to multiple USB drives concurrently, significantly reducing the total time required.
- Simplifies and cleans up the FFU selection logic.
- Standardizes on `robocopy` for all large file transfer operations to improve performance and logging.
Refines the logic for setting the Windows Release from a saved configuration to handle ambiguous values.
When a release value like '2019' exists for both Server and LTSC editions, the UI could select the wrong item. The logic now inspects the `WindowsSKU` config value to differentiate between them, correctly selecting the LTSC or non-LTSC release.
Improves the reliability of finding update files (CU, CUP, .NET) by first using the exact filename from the update metadata. The script now only falls back to searching by KB article ID if the primary method fails.
Additionally, this enhances the VHDX cache lookup logic. The comparison now uses update file names extracted directly from their URLs, ensuring a more accurate match against the cached configuration.
Separates the process of identifying required Windows updates from the download process itself. This allows for checking against the VHDX cache using a list of required updates before any files are downloaded, making the caching mechanism more efficient and reliable.
This change introduces a new `Get-UpdateFileInfo` function to gather update metadata. The main script logic is updated to first determine all necessary updates, then check for a suitable cached VHDX, and only download the updates if no valid cache item is found.
Moves the "Build" tab to appear after the "Hyper-V Settings" tab. This change aligns the UI with the typical user process, creating a more intuitive sequence for configuration.
Improves the user experience in the monitor tab by making the log output autoscroll conditional.
Autoscrolling is now disabled when the user selects a log entry other than the last one, allowing them to inspect previous output without interruption. Selecting the last item in the list re-enables autoscrolling.
Adds a feature to automatically save the selected drivers to `Drivers.json` upon download, preserving the user's selection for future use.
Improves script execution by:
- Ensuring the disk cleanup process completes before proceeding.
- Suppressing progress bars globally for a cleaner console output.
- Hiding non-critical warnings during driver installation.
- Removing an unused BITS transfer function and trailing whitespace.
Introduces a progress reporting system to provide real-time feedback during the FFU build. This includes adding a progress bar and status messages to the UI, which are updated at key stages of the build process.
- Adds a new `Set-Progress` function to log progress updates.
- Integrates `Set-Progress` calls throughout the main build script.
- Updates the UI to parse progress logs and update the progress bar and status text.
- Improves error reporting in the UI to display more detailed failure reasons.
- Corrects a typo in the `LogicalSectorSizeBytes` parameter name in documentation and log messages.
Deletes the old log file before starting a new build job to prevent the UI from displaying stale content from a previous run.
Replaces a fixed delay with a more robust wait loop that polls for the new log file's creation. This avoids a race condition where the monitor could fail to attach if the background job was slow to start. A timeout is included to prevent the UI from hanging.
Introduces a new "Monitor" tab in the `BuildFFUVM` UI to display live log output from the build process.
When a build is started, the UI now automatically switches to the Monitor tab. It tails the main log file in real-time and displays the content in a list view, which auto-scrolls as new entries appear.
This provides immediate visual feedback on the build progress and any errors without needing to manually open the log file.
Additionally, this change adds a Ctrl+C keyboard shortcut to copy selected log lines from the monitor view to the clipboard.
Refactors the FFU build process to execute asynchronously using a background job. This prevents the UI from freezing during the build.
A timer now polls the job status and updates the UI with the final result (success or failure) upon completion. The build button is also disabled while a build is in progress to prevent multiple executions.
Introduces a centralized function to handle script termination, ensuring the DISM log is always copied on failure for easier debugging.
Improves user-facing error messages to provide clearer guidance for common issues, such as a missing hard drive, incorrect USB drive configuration, or FFU logical sector size mismatches.
Adds post-deployment verification to ensure the Windows partition is created and assigned a drive letter correctly after applying the FFU.
Refactors the script's console output to be cleaner and more user-friendly.
- Adds formatted section headers to clearly delineate each stage of the deployment process.
- Replaces verbose console logging with more selective and meaningful status messages for the user.
- Prevents external commands from opening new windows, creating a more seamless execution flow in the terminal.
rbalsleyMSFT