The Role of Enhancer.cs in Wand‑Enhancer’s Patching Process: Complete Workflow Guide

Enhancer.cs serves as the central orchestrator in the Wand‑Enhancer project, managing the complete workflow from ASAR extraction to patch injection and repackaging to create a modified Wand Electron application.

The open‑source Wand‑Enhancer tool (available at k1tbyte/Wand‑Enhancer) enables users to customize the Wand application by modifying its underlying Electron ASAR archive. At the heart of this modification pipeline lies Enhancer.cs, a C# class that transforms user configuration into executable patches while preserving the integrity of the original application structure.

How Enhancer.cs Orchestrates the Patch Pipeline

Enhancer.cs in Wand‑Enhancer acts as the primary controller that bridges the WPF user interface with low‑level ASAR manipulation. When instantiated and invoked from the view layer, it executes a six‑stage process that converts the original Wand application into an enhanced version with activated features, developer tools, and custom script injection.

Loading and Validating Patch Configuration

The process begins by ingesting a PatchConfig object populated from the WPF UI. Enhancer.cs verifies that all required dependencies—such as custom script paths and bridge binaries—exist before proceeding. This validation step prevents partial modifications that could corrupt the application.

Extracting the Original ASAR Archive

Using the AsarSharp library, specifically the Extractor class, Enhancer.cs unpacks resources/app.asar from the target Wand installation. It respects the "skip unpacked entries" rule documented in the ASAR Patch Pipeline section of AGENTS.md, ensuring that deliberately unpacked files remain untouched during the extraction phase.

Applying Built‑in Patches

After extraction, the class applies a series of built‑in modifications through dedicated patch functions. These include:

• EPatchType.ActivatePro – Unlocks professional features within the Wand bundle
• DevToolsOnF12 – Enables Chrome DevTools activation via the F12 key
• Additional reducer and service method rewrites specific to the Wand architecture

These patches modify JavaScript bundles inside the extracted ASAR content before repackaging.

Injecting the Web Panel Bridge

Following core modifications, Enhancer.cs integrates the remote web panel infrastructure. It copies web‑panel/dist/bridge.cjs and default renderer scripts from web‑panel/dist/renderer‑scripts/ into the extracted archive under the remote‑panel/ directory. This injection establishes the communication layer between the modified Wand application and the external web interface.

Integrating Custom User Scripts

If the user selected custom renderer scripts through the UI, Enhancer.cs verifies their file paths and copies them into remote‑panel/renderer‑scripts/. This allows arbitrary JavaScript execution within the Wand renderer context, extending functionality beyond built‑in patches.

Repackaging the Modified ASAR

The final stage uses AsarSharp.Creator to rebuild app.asar and its unpacked sibling. The RepackageAsar() method preserves any original unpacked files that were deliberately excluded from the extraction, ensuring the patched application maintains compatibility with Electron's file system expectations.

UI Integration: Triggering the Patch from MainWindowVm.cs

The Enhancer class operates under the control of the presentation layer defined in WandEnhancer/View/MainWindow/MainWindowVm.cs. At line 157, the view model constructs an Enhancer instance and invokes its primary entry point:

// In MainWindowVm.cs - WPF view model orchestration
var enhancer = new Enhancer(weModInfo, logger, patchConfig);
enhancer.Patch();   // Executes extraction → patch → injection → repack flow

This separation of concerns keeps UI logic distinct from the complex file manipulation and binary patching operations handled within Enhancer.cs.

Key Dependencies and Source Files

Several components support the patching workflow orchestrated by Enhancer.cs:

• Enhancer.cs (WandEnhancer/Core/Enhancer.cs) – Central class containing ExtractOriginalAsar(), ApplyBuiltInPatches(), CopyWebPanelDist(), and RepackageAsar() methods.
• PatchConfig.cs – Model class holding user‑selected options and script paths consumed by the enhancer.
• AsarSharp – Third‑party library providing AsarSharp.Extractor and AsarSharp.Creator for safe ASAR archive manipulation.
• AGENTS.md – Documentation detailing the ASAR patch pipeline rules and bridge integration architecture.

Summary

• Enhancer.cs serves as the core orchestrator for Wand‑Enhancer's modification workflow, handling the complete lifecycle from extraction to repackaging.
• The class validates user configuration through PatchConfig before touching any application files, ensuring safe operation.
• It utilizes AsarSharp utilities to extract and rebuild the Electron ASAR while preserving unpacked entries as specified in AGENTS.md.
• Built‑in patches like EPatchType.ActivatePro and DevToolsOnF12 are applied to modify Wand's service methods and enable developer features.
• The web panel bridge (bridge.cjs) and custom renderer scripts are injected into the remote‑panel/ directory within the ASAR structure.
• UI integration occurs through MainWindowVm.cs, which instantiates the enhancer and calls Patch() to execute the full workflow.

Frequently Asked Questions

What specific method triggers the entire patching workflow in Enhancer.cs?

The Patch() method serves as the public entry point that triggers the complete workflow. When called from MainWindowVm.cs, it sequentially executes ExtractOriginalAsar(), ApplyBuiltInPatches(), CopyWebPanelDist(), CopyCustomScriptsIfAny(), and RepackageAsar() to transform the original Wand application.

How does Enhancer.cs handle the Electron ASAR archive without corrupting the application?

The class uses the AsarSharp library's Extractor and Creator classes to handle ASAR files. It specifically respects the "skip unpacked entries" rule documented in AGENTS.md, meaning it preserves files that Electron leaves outside the archive (in the app.asar.unpacked directory) and maintains them during the repackaging phase.

Can Enhancer.cs apply patches selectively based on user preferences?

Yes. The class consumes a PatchConfig object that contains boolean flags and file paths selected through the WPF interface. It validates these settings before execution and conditionally runs specific patch functions—such as only copying custom scripts if the user provided valid paths—ensuring only requested modifications are applied.

Where does Enhancer.cs place the web panel components inside the Wand application?

It copies the bridge binary and renderer scripts into a remote‑panel/ directory inside the extracted ASAR contents. Specifically, web‑panel/dist/bridge.cjs goes to the root of this directory, while renderer scripts populate remote‑panel/renderer‑scripts/, establishing the infrastructure for the remote web interface.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}