Ability to run cli functionality from code. Dynamic tailwindcss generation

[OliverRC]

I have a setup (and albeit a unique one) where I'd like to dynamically generate tailwind classes for an incoming html blob (string).

Right now I've tried a getto solution of writing the blob to disk into a tmp directory and then having the cli generate output.css where the dir is in the sources list and then read the css back in from disk.

Whilst this could work in theory I have experienced some issues.

1. Gaining access to the tailwindcss/cli is easy in the traditional workflow but is kinda a pain in the above described scenario
2. For some reason trying to execute the cli as a process (from .NET 9 in this case) is not working properly

• oddly when redirecting stdout and stderr the output of tailwindcss/cli is getting dumped into stderr for some reason ? Weird.
• Doing a WaitForExit never returns with the processes exit code

3. I tried directly integrating with the binary for tailwindcss/cli, however the Mac immediately disallowed it as a "potentially dangerous binary" and so got stuck there

The main goal here is the ability to programmatically generate tailwind classes for a given input string. As far as I know the TailwindCSS CLI is built in rust.

Some ideas to make this easier could be:

1. The ability to pipe input html and configuration into the cli and have the results output to stdout or something similar
2. A programmatic interface to interact with the binary. Maybe namedpipes, grpc ... \

• obviously I am not expecting a .NET layer but if given an interface in rust I could forsee creating an Interop layer

[OliverRC]

An example of the process spawning .NET code. Running the outputted command manually in the terminal works perfectly.
I am also seeing the Done in 1s arriving in the error StandardError buffer.

  private async Task RunTailwindCliAsync(string outputCssPath)
    {
        var currentWorkingDir = AppDomain.CurrentDomain.BaseDirectory;
        var startInfo = new ProcessStartInfo
        {
            FileName = "./tailwindcss", // Adjust for your platform if necessary
            Arguments = $"--cwd \"{currentWorkingDir}\" --input \"tailwind.base.css\" -o \"output.css\" --minify",
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            RedirectStandardInput = true,
            UseShellExecute = false,
            CreateNoWindow = true,
            WorkingDirectory = AppDomain.CurrentDomain.BaseDirectory
        };

        // Initialize process in a try block to ensure disposal if exception is thrown
        using var process = new Process();
        process.StartInfo = startInfo;

        _logger.LogInformation("Running Tailwind CLI: {Command} {Arguments}", startInfo.FileName, startInfo.Arguments);
        process.Start();

        Task<string> readOutputTask = process.StandardOutput.ReadToEndAsync();
        Task<string> readErrorTask = process.StandardError.ReadToEndAsync();

        await process.WaitForExitAsync();

        // Await the reading tasks to ensure all output is consumed
        string output = await readOutputTask;
        string error = await readErrorTask;

        if (process.ExitCode != 0)
        {
            throw new InvalidOperationException($"Tailwind CLI failed with exit code {process.ExitCode}: {error}");
        }
    }

[wongjn]

As an FYI, only the file scanning portion of Tailwind is written in Rust. The other parts of it are compiled to JavaScript from TypeScript.