DEV Community: chuongmep

Fix Loading module from ... was blocked because of a disallowed MIME type

chuongmep — Wed, 12 Nov 2025 03:21:02 +0000

This is simple way to fix :

Find type format relate to the issue from console in web browser

Add the code from python server, in my case I'm not able to load .mjs from source :

import mimetypes
mimetypes.add_type('text/javascript', '.mjs')

Install NVM for Windows Without Administrator

chuongmep — Wed, 03 Sep 2025 01:18:31 +0000

Most tutorials for nvm-windows assume you install it using the Windows installer, which requires administrator privileges. But what if you can’t run installers or don’t have admin rights?

Here’s a step-by-step guide to setting up NVM (Node Version Manager) for Windows manually, without admin access.

1. Download NVM for Windows (No-Install)

Go to the nvm-windows releases page and download the nvm-noinstall.zip package.

Extract it somewhere you can write to, for example:

D:\_WIP\Download\nvm-noinstall

2. Create `settings.txt`

Inside the extracted folder, create a new file called settings.txt with this content:

root: D:\_WIP\Download\nvm-noinstall
path: D:\_WIP\Download\nvm-noinstall\nodejs
arch: 64
proxy: none

This tells NVM where to keep Node.js versions and where the active Node.js binary should be symlinked.

3. Create the `nodejs` Folder

Still inside your extracted folder, create a new folder:

nodejs

This will be the folder NVM points to for the currently active Node.js version.

4. Install Node.js Using NVM

Open Command Prompt (no admin needed) and run:

nvm install latest

This will download and install the latest version of Node.js.

5. Setup Environment Variables

Since you don’t have admin rights, you’ll set user-level environment variables.

Add the following to your user environment variables:

NVM_HOME → D:\_WIP\Download\nvm-noinstall
NVM_SYMLINK → D:\_WIP\Download\nvm-noinstall\nodejs

Then, update your Path (user-level) to include:

%NVM_HOME%
%NVM_SYMLINK%

Tip: You don’t need to set nvm_symlink manually in environment variable, only settings.txt.

6. Verify Installation

Check available Node.js versions:

nvm list available

Check installed versions:

nvm list

Switch Node.js versions easily:

nvm use 20

References

Bonus: What’s Next?

If you’re looking at alternatives to Node.js, check out Bun — a modern JavaScript runtime that is fast and has built-in tools like a bundler, transpiler, and test runner.

Would you like me to make this more hands-on with a screenshot of environment variable setup and the settings.txt file so dev.to readers don’t get stuck?

How to Fix FastAPI Debug Not Working in PyCharm on Windows

chuongmep — Sun, 31 Aug 2025 13:25:56 +0000

If you are developing a FastAPI application in PyCharm on Windows, you might run into this issue:

Problem: You start the debugger, it runs, but code changes are not reflected on reload.

I ran into this recently, and here’s what fixed it for me: downgrading Python from 3.12 to 3.11.

Here’s the step-by-step solution:

Create a new environment In PyCharm, create a new virtual environment (e.g., .venv) using Python 3.11.

Configure Python Debug Go to your Run/Debug Configurations and select the new environment. Make sure the “Python interpreter” points to your .venv.

Start Debug Run the debugger. Now, changes in your code should properly reload and reflect in the application.

This simple downgrade solved the reload issue on Windows.

Azure Functions host did not return isolated worker process id. Macos

chuongmep — Sat, 30 Aug 2025 11:11:52 +0000

Fixing .NET SDK Issue on macOS (ARM vs x64)

I recently ran into an issue on macOS when working with .NET SDK.
After some trial and error, I finally found the solution — and I hope this helps someone facing the same problem.

The Problem

When running .NET SDK on macOS with Apple Silicon (M1/M2), you might face compatibility issues if you install the wrong build of the SDK.
At first, I installed the ARM64 version, but some tools and workloads didn’t work properly.

The Fix

You need to install the x64 version of the .NET SDK instead of the ARM64 version.

That small change fixed the problem completely.

👉 You can grab the x64 build directly here:
Download .NET 8 SDK

Why x64?

Even though Apple Silicon supports ARM64, many tools, extensions, and third-party dependencies still expect x64 binaries. Running the x64 version of the SDK ensures better compatibility when developing on macOS.

Would you like me to make it short and quick (just the fix), or a longer version with some explanation about Rosetta 2 and why x64 works better in this case?

Change HomePage Azure Function .NET : Your Functions 4.0 app is up and running

chuongmep — Thu, 03 Apr 2025 08:46:57 +0000

I have some panic when I search from the internet to see how can we change the home page of Azure Function under .NET. In this post I will help you easy to change it some config and setting .

You can change it by modifying the content using the host.json.
You need to add "extensions": { "http": { "routePrefix": "" } } in your host.json, Example :

{
    "version": "2.0",
    "logging": {
        "applicationInsights": {
            "samplingSettings": {
                "isEnabled": true,
                "excludedTypes": "Request"
            },
            "enableLiveMetricsFilters": true
        }
    },
    "extensions": { "http": { "routePrefix": "" } }
}

And now, you need to define a function return the home page information, in this example we will return the home page with result Hello from Azure Function!

[Function("RootFunction")]
        public IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get",
                Route = "{ignored:maxlength(0)?}")]
            HttpRequest req,
            string ignored = "")
        {
            _logger.LogInformation($"C# HTTP trigger function processed a request.");
            return new OkObjectResult("Hello from Azure Function!");
        }

Now when you look back after deployment, you can see the result.

Enjoy !

Reference

https://stackoverflow.com/questions/67180247/azure-functions-serving-content-for-root-url/76419027#76419027

Install NVM Macos Easiest Way

chuongmep — Wed, 26 Mar 2025 06:13:39 +0000

I'm not sure why many posts and blog make problem more comlicated ,Let's use :

cd /tmp
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc

Now, after restart terminal, you can able to use it,

nvm

Reference

https://github.com/oracle/graal/issues/8234

How to setup Conda-Forge on macOS (Apple Silicon)

chuongmep — Sat, 22 Mar 2025 07:01:27 +0000

Why Install Conda from Conda-Forge?

Conda is a powerful package manager for Python and other languages, commonly used for data science, machine learning, and software development. While the default Anaconda distribution is popular, the Conda-Forge version provides a lightweight and community-driven alternative.

If you're using an Apple Silicon Mac (M1/M2), installing Miniforge3 from Conda-Forge ensures better performance and compatibility.

Conda-Forge can use under

Step-by-Step Installation

1. Download Miniforge3 (Conda-Forge Version)

Go to the official website: Conda-Forge Miniforge

Download the installer for macOS (ARM64), which is optimized for Apple Silicon.

2. Install Miniforge3

Once downloaded, open a terminal and run:

bash ~/Downloads/Miniforge3-MacOSX-arm64.sh

Follow the on-screen instructions to complete the installation.

3. Verify Installation

After installation, check if Conda is installed:

/Users/your-username/miniforge3/bin/conda --version

(Replace your-username with your actual username.)

If Conda is installed correctly, you should see the version output.

Fix: "Command Not Found" Issue After Installation

If you get a "command not found" error when running conda, follow these steps:

1. Add Conda to PATH

Open your terminal and run:

echo 'export PATH="/Users/your-username/miniforge3/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

If using bash instead of zsh, replace ~/.zshrc with ~/.bashrc.

2. Initialize Conda for Your Shell

Run the following command:

/Users/your-username/miniforge3/bin/conda init zsh

For bash, use:

/Users/your-username/miniforge3/bin/conda init bash

Then restart your terminal.

3. Test Conda

Try these commands:

conda --version
conda info

If they work, your installation is now properly configured!

Conclusion

Using Miniforge3 from Conda-Forge ensures a lightweight, Apple Silicon-optimized Conda installation. If you run into issues with conda not being found, setting the correct PATH and initializing Conda should fix it. Enjoy your Conda-powered development environment on macOS!

Building a Secure Autodesk Platform Services (APS) API App: Session Management and Middleware Configuration

chuongmep — Wed, 19 Mar 2025 05:20:36 +0000

Building a Secure Autodesk Platform Services (APS) API App: Session Management and Middleware Configuration

When building applications with Autodesk Platform Services (APS), secure and persistent authentication is crucial for ensuring a smooth user experience. One of the key components in any web application is proper session management. In this post, we'll walk through how to set up session management using express-session and cookie-session while building an APS API app.

What Is Autodesk Platform Services (APS)?

Autodesk Platform Services (APS) provides a cloud-based API platform that allows developers to integrate Autodesk tools into their applications. These APIs can be used for everything from model viewing to data exchange and file management, and they require proper authentication to ensure security.

When building an APS application, handling OAuth 2.0 authentication is a critical part of the process. This typically involves handling access tokens, refresh tokens, and user sessions. For this reason, you need to carefully manage how session data is stored and accessed.

Session Management in APS API Applications

In APS, after you authenticate a user and obtain an access token, you typically need to manage the session to maintain the user’s login state. Session management involves storing the authentication data securely and making it available across multiple requests. This is where express-session or cookie-session come into play.

Using `cookie-session`

cookie-session is a lightweight solution where the session data is stored directly in the browser's cookies. It's perfect for smaller-scale apps or scenarios where session data doesn’t need to be too large. Here's a basic setup:

const express = require('express');
const session = require('cookie-session');
const { PORT, SERVER_SESSION_SECRET } = require('./config.js');

let app = express();

// Serve static files
app.use(express.static('wwwroot'));

// Session configuration using cookie-session
app.use(session({
    secret: SERVER_SESSION_SECRET,           // A secret key to sign the cookie
    maxAge: 24 * 60 * 60 * 1000,             // Session expiration (1 day)
    httpOnly: true,                          // Cookie can't be accessed via JS
    secure: false,                           // Set to true if using HTTPS
}));

// Route handlers
app.use(require('./routes/auth.js'));
app.use(require('./routes/hubs.js'));

// Start the server
app.listen(PORT, () => console.log(`Server running on http://localhost:${PORT}`));

With this setup, the session data (like refresh_token and user-specific data) will be stored in a cookie. The cookie will automatically be sent with every request, allowing you to retrieve and update session data without needing a database.

Using `express-session` for Larger Apps

While cookie-session is great for lightweight sessions, larger applications or those requiring more robust session handling might benefit from express-session. This session middleware stores session data server-side, allowing for more complex and secure storage solutions like Redis or a database.

Here’s how you can use express-session:

npm install express-session

And configure it in your app:

const express = require('express');
const session = require('express-session');
const { PORT, SERVER_SESSION_SECRET } = require('./config.js');

let app = express();

// Serve static files
app.use(express.static('wwwroot'));

// Session middleware configuration using express-session
app.use(session({
    secret: SERVER_SESSION_SECRET,           // Secret key to sign the session cookie
    resave: false,                           // Don't save session if not modified
    saveUninitialized: true,                 // Create session even if it's empty
    cookie: {
        maxAge: 24 * 60 * 60 * 1000,         // Session expiration (1 day)
        httpOnly: true,                      // Cookie can't be accessed via JS
        secure: false,                       // Set to true if using HTTPS
    }
}));

// Route handlers
app.use(require('./routes/auth.js'));
app.use(require('./routes/hubs.js'));

// Start the server
app.listen(PORT, () => console.log(`Server running on http://localhost:${PORT}`));

This configuration allows session data to be stored on the server (in memory, Redis, or another store), which is generally more secure for large applications. Unlike cookie-session, express-session doesn't store the actual session data in the cookie itself. Instead, it stores only a session ID, and the actual session data is kept server-side.

Authentication Flow and Session Management

After the user authenticates with APS via OAuth 2.0, you’ll typically handle tokens (access and refresh tokens) to maintain authentication. Here's an overview of the flow:

Initial Authentication:
- The user is redirected to Autodesk’s OAuth endpoint for authentication.
- Once authenticated, APS returns an authorization code, which is exchanged for an access token and refresh token.
Storing Tokens:
- Once you obtain the access and refresh tokens, you store them in the session so that they can be used in subsequent requests.
- This typically looks like this in your middleware:
```
 req.session.refresh_token = publicCredentials.refresh_token;
 req.session.access_token = publicCredentials.access_token;
```

Token Refresh:

When the access token expires, you’ll need to use the refresh token to obtain a new access token. This involves checking the session for the stored refresh token and making a request to APS to refresh the session.
Example of refreshing a token:

 if (expires_at < Date.now()) {
     const internalCredentials = await authenticationClient.refreshToken(refresh_token, APS_CLIENT_ID, {
         clientSecret: APS_CLIENT_SECRET,
         scopes: INTERNAL_TOKEN_SCOPES
     });
     req.session.refresh_token = internalCredentials.refresh_token;
     req.session.access_token = internalCredentials.access_token;
 }

Using Tokens in Requests:
- After authenticating and refreshing tokens, you can use the session tokens to interact with the Autodesk APIs and access model data, manage files, and more.

Security Considerations

When working with session management, especially in authentication-heavy apps, security is crucial. Here are some best practices:

Use HTTPS: Always use HTTPS for production to encrypt data in transit, including session cookies.
Secure Cookies: Set the secure: true option for cookies if you’re using HTTPS, ensuring cookies are only sent over secure connections.
Session Expiry: Use appropriate session expiry times (via maxAge) to limit session duration and reduce the risk of stale sessions being hijacked.
Protect Against CSRF: Ensure your app implements CSRF protection to prevent malicious requests from being sent on behalf of the user.

Conclusion

Session management is a crucial part of building secure and efficient Autodesk Platform Services apps. Whether you’re using cookie-session for lightweight sessions or express-session for more robust storage solutions, managing tokens and session data effectively will ensure that your application works seamlessly while maintaining security.

With the correct session setup, you can easily manage user authentication, refresh tokens, and secure communication with Autodesk APIs—creating a smooth experience for your users.

Fix EACCES: permission denied, unlink '/usr/local/bin/code'

chuongmep — Sat, 15 Mar 2025 04:00:55 +0000

If you're using macOS and trying to run the shortcut command:

code .

to open the current folder in VS Code, but you get a permission error like this:

EACCES: permission denied, unlink '/usr/local/bin/code'

then you're not alone! This issue is quite common and happens because the /usr/local/bin/code file requires administrative privileges to modify or delete.

How to Fix It

To resolve this issue, follow these steps:

Step 1: Remove the Existing `code` Binary

Since the file is in /usr/local/bin/, you'll need admin permissions to remove it. Run the following command in your terminal:

sudo rm -f /usr/local/bin/code

Enter your password when prompted.

Step 2: Reinstall the `code` Command

Now, reopen VS Code, then follow these steps:

Open the Command Palette (Cmd + Shift + P).
Search for Shell Command: Install 'code' command in PATH.
Click on it to reinstall the CLI command.

Step 3: Verify

To confirm it's working, try running:

code --version

If you see the version number of VS Code, then it's fixed! 🎉

Notes

This fix requires admin permissions to install the code command properly.
If you're using a non-admin account, you may need to ask your system administrator for help.

Now, you can happily use code . again without any issues! 🚀

Let me know in the comments if you run into any trouble! Happy coding! 😊

AvaloniaUI Native AOT Deployment on Windows

chuongmep — Fri, 21 Feb 2025 08:49:12 +0000

Introduction

Deploying an AvaloniaUI application with Native AOT (Ahead-Of-Time compilation) on Windows can significantly improve startup performance and reduce the size of your application. However, due to Avalonia's reliance on reflection-based bindings, Native AOT can cause runtime errors if not properly configured.

This guide provides a step-by-step approach to resolving trimming issues and ensuring a successful Native AOT deployment for AvaloniaUI applications.

Common Issues and Fixes

1. XAML Views Not Reachable via Runtime Loader

If you encounter the following error:

Avalonia: XAML resource "avares://YourApp/Views/MainWindow.axaml" won't be reachable via runtime loader, as no public constructor was found.

✅ Fix: Ensure Your Views Have a Public Constructor

Each view must have a public parameterless constructor in its .axaml.cs file. Example:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }
}

2. Ensure XAML Files Are Embedded Properly

If your UI does not load or throws missing resource errors, check your XAML file properties.

✅ Fix: Set Build Action to `AvaloniaResource`

Open Visual Studio.
Right-click your .axaml file → Select Properties.
Set Build Action to AvaloniaResource.

3. Fixing PublishTrimmed and Trimming Issues

Since Native AOT automatically enables trimming, Avalonia's reflection-based UI bindings might get stripped out.

✅ Fix: Add `TrimmerRootAssembly` in `.csproj`

To prevent Avalonia's essential assemblies from being trimmed, modify your .csproj file:

<ItemGroup>
    <TrimmerRootAssembly Include="Avalonia.Controls" />
    <TrimmerRootAssembly Include="Avalonia.Base" />
    <TrimmerRootAssembly Include="Avalonia.Markup.Xaml" />
</ItemGroup>

4. Project Configuration

<PropertyGroup>
        <OutputType>WinExe</OutputType>
        <TargetFramework>net8.0</TargetFramework>
        <Nullable>enable</Nullable>
        <PublishReadyToRun>true</PublishReadyToRun>
        <PublishAot>true</PublishAot>
        <EventSourceSupport>true</EventSourceSupport>
        <IsAotCompatible>true</IsAotCompatible>
        <!-- Recommended Avalonia trimming settings for Native AOT -->
        <!--    <BuiltInComInteropSupport>false</BuiltInComInteropSupport>-->
        <!--    <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>-->
        <TrimMode>partial</TrimMode>
        <ApplicationManifest>app.manifest</ApplicationManifest>
        <StripSymbols>false</StripSymbols>
        <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
        <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
    </PropertyGroup>

Building and Publishing for Native AOT

Run the following command to publish your Avalonia app with Native AOT:

dotnet publish -r win-x64 -c Release --self-contained true -p:PublishAot=true

Final Checklist for Native AOT Deployment ✅

✔ Ensure all views have a public constructor
✔ Set XAML files to AvaloniaResource
✔ Prevent trimming of required Avalonia assemblies (TrimmerRootAssembly)
✔ Use rd.xml to preserve Avalonia reflection-based types
✔ Properly initialize Avalonia in App.axaml.cs
✔ Publish using dotnet publish -p:PublishAot=true

Conclusion

By following these steps, you can successfully deploy AvaloniaUI applications using Native AOT on Windows without breaking essential functionality. This ensures a smaller, faster application while avoiding common pitfalls with Avalonia’s reflection-heavy UI framework.

For further details, refer to the official documentation:

Comparing JSON Libraries in .NET: Newtonsoft.Json vs. System.Text.Json

chuongmep — Thu, 20 Feb 2025 01:15:49 +0000

When working with JSON in .NET, two popular libraries are Newtonsoft.Json (also known as Json.NET) and System.Text.Json. Below, we compare their usage for reading and parsing JSON data.

1. Newtonsoft.Json

Reading and Parsing JSON

Installation:

Install-Package Newtonsoft.Json

Example: Deserialize JSON to Object

using Newtonsoft.Json;

public class Token
{
    public string? AccessToken { get; set; }
    public string? RefreshToken { get; set; }
    public int ExpiresIn { get; set; }
}

string json = "{ 'access_token': 'abc123', 'refresh_token': 'def456', 'expires_in': 3600 }";
Token token = JsonConvert.DeserializeObject<Token>(json);

Console.WriteLine(token.AccessToken); // Output: abc123

Example: Reading JSON from a File

string jsonContent = File.ReadAllText("token.json");
Token token = JsonConvert.DeserializeObject<Token>(jsonContent);

Example: Using JObject for Dynamic Access

using Newtonsoft.Json.Linq;

string json = "{ 'access_token': 'abc123', 'refresh_token': 'def456', 'expires_in': 3600 }";
JObject tokenData = JsonConvert.DeserializeObject<JObject>(json);
string accessToken = tokenData["access_token"]?.Value<string>();

2. System.Text.Json

Reading and Parsing JSON

Installation:
System.Text.Json is included in .NET Core 3.0 and later versions, so no additional installation is needed.

Example: Deserialize JSON to Object

using System.Text.Json;

public class Token
{
    public string? AccessToken { get; set; }
    public string? RefreshToken { get; set; }
    public int ExpiresIn { get; set; }
}

string json = "{ \"access_token\": \"abc123\", \"refresh_token\": \"def456\", \"expires_in\": 3600 }";
Token token = JsonSerializer.Deserialize<Token>(json);

Console.WriteLine(token.AccessToken); // Output: abc123

Example: Reading JSON from a File

string jsonContent = File.ReadAllText("token.json");
Token token = JsonSerializer.Deserialize<Token>(jsonContent);

Example: Using JsonDocument for Dynamic Access

using System.Text.Json;

string json = "{ \"access_token\": \"abc123\", \"refresh_token\": \"def456\", \"expires_in\": 3600 }";
using JsonDocument doc = JsonDocument.Parse(json);
JsonElement root = doc.RootElement;
string accessToken = root.GetProperty("access_token").GetString();

Comparison Summary

Feature	Newtonsoft.Json	System.Text.Json
Installation	Requires separate NuGet package	Built-in with .NET Core 3.0+
Deserialization	`JsonConvert.DeserializeObject<T>()`	`JsonSerializer.Deserialize<T>()`
Dynamic Access	`JObject` for flexible JSON access	`JsonDocument` for read-only access
Null Handling	More configurable options	Default ignore nulls with options
Performance	Slower than System.Text.Json	Generally faster and more efficient

Why AOT Needs to Use System.Text.Json

Ahead-Of-Time (AOT) Compilation is a technique used to improve performance by compiling code before runtime. System.Text.Json is designed to work seamlessly with AOT in .NET, providing the following benefits:

Reduced Memory Footprint: System.Text.Json is more lightweight, which helps in minimizing memory usage during compilation.
Faster Startup Times: AOT compilation with System.Text.Json can lead to faster application startup times because the JSON handling is optimized and compiled ahead of time.
Native Support: Being a part of the .NET core libraries, System.Text.Json is optimized for performance and compatibility with AOT compilation, reducing the risk of runtime issues compared to third-party libraries like Newtonsoft.Json.
Enhanced Performance: System.Text.Json typically offers better performance due to optimizations for serialization and deserialization, which is critical for applications that rely heavily on JSON data.

Conclusion

Both Newtonsoft.Json and System.Text.Json have their strengths. Use Newtonsoft.Json for complex scenarios and flexibility, and consider System.Text.Json for better performance, native support in .NET Core, and seamless integration with AOT compilation.

Resolve 'IBM437' is not a supported encoding name EPPlus

chuongmep — Wed, 05 Feb 2025 07:56:32 +0000

First add a reference to System.Text.Encoding.CodePages assembly.

<ItemGroup>
    <PackageReference Include="System.Text.Encoding.CodePages" Version="4.3.0" />
</ItemGroup>

Then register the missing parts:

 Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

Reference

https://github.com/JanKallman/EPPlus/issues/31

DEV Community: chuongmep

Fix Loading module from ... was blocked because of a disallowed MIME type

Install NVM for Windows Without Administrator

1. Download NVM for Windows (No-Install)

2. Create settings.txt

3. Create the nodejs Folder

4. Install Node.js Using NVM

5. Setup Environment Variables

6. Verify Installation

References

Bonus: What’s Next?

How to Fix FastAPI Debug Not Working in PyCharm on Windows

Azure Functions host did not return isolated worker process id. Macos

Fixing .NET SDK Issue on macOS (ARM vs x64)

The Problem

The Fix

Why x64?

Change HomePage Azure Function .NET : Your Functions 4.0 app is up and running

Reference

Install NVM Macos Easiest Way

Reference

How to setup Conda-Forge on macOS (Apple Silicon)

Why Install Conda from Conda-Forge?

Step-by-Step Installation

1. Download Miniforge3 (Conda-Forge Version)

2. Install Miniforge3

3. Verify Installation

Fix: "Command Not Found" Issue After Installation

1. Add Conda to PATH

2. Initialize Conda for Your Shell

3. Test Conda

Conclusion

Building a Secure Autodesk Platform Services (APS) API App: Session Management and Middleware Configuration

Building a Secure Autodesk Platform Services (APS) API App: Session Management and Middleware Configuration

What Is Autodesk Platform Services (APS)?

Session Management in APS API Applications

Using cookie-session

Using express-session for Larger Apps

Authentication Flow and Session Management

Security Considerations

Conclusion

Fix EACCES: permission denied, unlink '/usr/local/bin/code'

How to Fix It

Step 1: Remove the Existing code Binary

Step 2: Reinstall the code Command

Step 3: Verify

Notes

AvaloniaUI Native AOT Deployment on Windows

Introduction

Common Issues and Fixes

1. XAML Views Not Reachable via Runtime Loader

✅ Fix: Ensure Your Views Have a Public Constructor

2. Ensure XAML Files Are Embedded Properly

✅ Fix: Set Build Action to AvaloniaResource

3. Fixing PublishTrimmed and Trimming Issues

✅ Fix: Add TrimmerRootAssembly in .csproj

4. Project Configuration

Building and Publishing for Native AOT

Final Checklist for Native AOT Deployment ✅

Conclusion

Comparing JSON Libraries in .NET: Newtonsoft.Json vs. System.Text.Json

1. Newtonsoft.Json

Reading and Parsing JSON

Example: Deserialize JSON to Object

Example: Reading JSON from a File

Example: Using JObject for Dynamic Access

2. System.Text.Json

Reading and Parsing JSON

Example: Deserialize JSON to Object

Example: Reading JSON from a File

Example: Using JsonDocument for Dynamic Access

Comparison Summary

Why AOT Needs to Use System.Text.Json

Conclusion

Resolve 'IBM437' is not a supported encoding name EPPlus

Reference

2. Create `settings.txt`

3. Create the `nodejs` Folder

Using `cookie-session`

Using `express-session` for Larger Apps

Step 1: Remove the Existing `code` Binary

Step 2: Reinstall the `code` Command

✅ Fix: Set Build Action to `AvaloniaResource`

✅ Fix: Add `TrimmerRootAssembly` in `.csproj`