Set as executable files that are intended to be binaries

[leafac]

Search Terms

• mode
• binary
• executable
• package.json bin

Suggestion

Currently, the TypeScript compiler always generates files with the 644 mode. But some files are meant to be executable: they may start with #!/usr/bin/env node; they may be marked as bin in package.json; they may have an executable mode set on the .ts source; and so forth.

It’d be great if the TypeScript compiler would take any of the hints I mentioned above, figure that the file should be executable, and create the .js as so.

At least the TypeScript compiler doesn’t change the mode of existing .js files when overwriting them, so I can chmod once, and as long as never delete the file, it’ll have the right mode.

Use Cases

This is mostly for development and running the binary from the command-line directly. Once you install the package, npm puts the binary in the node_modules/.bin folder, npx picks it up, and all is good.

Examples

You’re working on a project that should provide a binary: src/my-binary.ts. You do one of the things I mentioned to indicate that the file should be executable. You run tsc, and the generated file at lib/my-binary.js is marked as +x. Then you can call the binary with lib/my-binary.js from the command-line and it works.

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[RyanCavanaugh]

There'd really need to be some compelling reason why TS has to be the tool that does this since it's trivially scriptable as part of a larger build system.

[leafac]

Some reasons for you to ponder:

1. Convention over configuration. It’s more ergonomic to have the TypeScript compiler produce files with the appropriate executable mode by default than to configure some other part of a larger build system do the job.
2. Some folks, like me, aren’t using larger build systems. We just call tsc and that’s it.
3. The change I’m proposing shouldn’t break anything for anyone.

[wojpawlik]

Proposal:

1. chmod +x emitted .js files starting from #!/usr/bin/env node\n,
2. Don't emit shebang into .d.ts files (typescript@4.2.3 does for some reason).

Disclaimer: wojpawlik/deno2node@9de1b89

[gustavohenke]

Explicitly +1ing as this hasn't seen much action for a couple of months.

I agree with Leandro Facchinetti (@leafac), tsc is the one build tool that I need. I can have a postbuild script do chmod +x on the compiled file, but it wouldn't work with --watch.

[thorsent]

+1 here that watch is a very good reason why tsc should care about permissions.

I think that replicating source file permissions over to the object file makes the most sense. I think it's reasonable to assume that an executable permission on a source file would be intentional.

Adding a look-see for the shebang works but feels like a barnacle.

[sambacha]

import { chmodSync } from 'fs';

/** 
* setChmod
* typescript uses 664 as the default 
* @see {@link github.com/microsoft/TypeScript/issues/37583 }
*/
const setChmod = '755'; 
/** 
* @note apply the needed chmod on your entrypoint
*/
chmodSync('dist/bin/index.js', setChmod);

another example: https://github.com/nrwl/nx/blob/master/packages/react-native/src/utils/chmod-task.ts

[blockscoped]

+1 Just keeping this issue alive.
I can't think of a compelling reason against this change.

[sparecycles]

Personally, I was expecting the executable flag to carry over from the source file.

[ritschwumm]

if this were implemented, i bet someone finds a non-obvious but interesting way to execute code on some innocent developers computer...

[nickserv]

That isn't an issue. Making a source file executable is a clear sign that it's safe to be executed, and is the default without build tools.