This message was deleted.

🤔

Interesting. I'd be curious how "normal" non-log output behaves. I'm referring to clikt / mordant, BTW: https://github.com/ajalt/clikt/issues/428

there is no protocol for indicating "this pipe accepts ANSI terminal escapes" (nor any other types of content negotiation)

So is my assumption correct that the app's output gets piped when using Gradle's

run

task? If so, why does it need to get piped in the first place?

hypothetically Gradle could run child processes in a pty with environment set up so that they think they're attached to a real terminal, then parse and forward everything from there. but that's likely to cause other issues

Oh...

Even if the Gradle client would run it directly, (which it could if it is compatible to the daemon args and run with

--no-daemon

), it would probably be piped, because you still run one process from another.

Well, naively, if I could just use

ProcessBuilder

(without redirection configured) to spawn another process, that should work, or?

If clickt does not support that, you should open a feature request and if it does, you should configure it 🙂

Forcing color is not really a solution IMO, just a work-around.

Yes, it is a work-around you need when piping the command like when running it through

grep

or piping it to

less

or running it through Gradle Daemon

Unless there's a reliable way to tell whether an app is being run by Gradle / the daemon... and only then force color.

you can consider it a workaround but the whole idea of terminal detection is a bigger mess

Also, there is no "standard" interactive console recognition. If you for example run older Gradle versions in Git Bash, you get pretty ugly output as the recognition there did not work properly.

even if you're running in a daemon, you have no way to tell if the client on the other end supports color

Unless there's a reliable way to tell whether an app is being run by Gradle / the daemon... and only then force color.

That's exactly what I said

> Unless there's a reliable way to tell whether an app is being run by Gradle / the daemon... and only then force color.

That's exactly what I said

Well, what I thought you were saying is that my clikt app should support

--force-color

and I should specify that manually when I know I'm running via Gradle.

Yes, your clickt app should support forcing color and suppressing color

if you know you only ever run Gradle in environments with color support, then go ahead and configure it to tell the commands to force color. this has to be done out of band because UNIX pipes are dumb.

Ah. That would not scale for all clikt users though. If feasile, there should be clikt-built-in logic to determine whether it's being run via Gradle, and then automatically force color.

that would still be the wrong thing to do

That would not scale for all clikt users though.

Why not? I as user of a tool that uses clickt would hate it as hell if I can not suppress color or enforce color how I need it.

I don't see why there should be anything special about clikt - the only solution is what @Vampire mentioned that every other cli tool does, which is to have flags to disable detection and force color on or off

Just that it is run by Gradle is not enough to know it should force color eventually, except you only ever call that task manually, but that's why the task configuration should configure it as I said and not clickt magically recognizing it is run through Gradle which it cannot anyway.

Ok, understood.