Como fazer arquivos exe a partir de um aplicativo node.js?

Eu tenho um aplicativo de nó que eu escrevi, que eu corro da seguinte forma:

node.exe app.js inputArg

Existe alguma maneira que eu possa empacotar isso em um .exe por si só? Então eu posso fazer algo assim?

App.exe inputArg

Eu tenho alguma maneira de fingir isso usando um arquivo de lote, então eu posso fazer isso:

App.bat inputArg

Mas isso requer que eu tenha todas as dependencies e nó nessa pasta, o que não é o ideal.

Existem algumas alternativas, gratuitas e comerciais. Eu não usei nenhum deles, mas em teoria eles deveriam funcionar:

  • Iexpress (ferramenta de janelas nativas)
  • Compilador de Arquivos em Lote Rápido (comercial)
  • “Advanced” Batch To EXE Converter ” (freeware)

A maioria exigirá que você mantenha o arquivo em lote como o executável principal e, em seguida, agrupe o node.exe e seus scripts.

Dependendo do seu script, você também tem a opção de portá-lo para o JSDB , que suporta uma maneira fácil de criar executáveis simplesmente anexando resources a ele.

Uma terceira quase-solução é manter o nó em algum lugar como C:\utils e adicionar essa pasta à sua variável de ambiente PATH . Em seguida, você pode criar arquivos .bat nesse diretório que executa o nó + seus scripts preferidos – fiz com que o coffee do coffeescript funcionasse no Windows dessa maneira. Essa configuração pode ser automatizada com um arquivo de lote, script vb ou instalador.

A solução que usei é o node-webkit de Roger Wang.

Esta é uma maneira fantástica de empacotar os aplicativos do nodejs e distribuí-los, e até oferece a opção de “empacotar” o aplicativo inteiro como um único executável. Suporta janelas, mac e linux.

Aqui estão alguns documentos sobre as várias opções para implantar aplicativos node-webkit, mas, em poucas palavras, você faz o seguinte:

  1. Feche todos os seus arquivos, com um pacote.json na raiz
  2. Altere a extensão de .zip para .nw
  3. copy / b nw.exe + app.nw app.exe

Apenas como uma nota adicional – eu enviei várias aplicações de checkbox de produção / instalação de cd usando isso, e funcionou muito bem. O mesmo aplicativo é executado no windows, mac, linux e pela web.

Para qualquer um que tropeçar nessa questão, agora existem dois projetos que criam exes a partir de seus projetos de nó, EncloseJS e Electron.atom.io , eles diferem ligeiramente:

  1. O EncloseJS irá compilar seu projeto para código nativo, eles também incluem ativos e uma instalação de nodejs (o sistema não precisará instalar o nodejs para executar o .exe). Seu código-fonte não será incluído. O executável resultante é o Windows ONLY (.exe). Todas as plataformas são suportadas agora. Agora requer uma licença para produtos comerciais.
  2. Electron.atom.io enquanto ele não vai compactar e gerar um. Exe para você, ele pode ser usado para distribuir aplicativos nodejs, uma vez que oferecem uma maneira de distribuir aplicativos . Os benefícios são que o elétron é multi-plataforma (windows, mac osx, linux), os contras são que seu código fonte será incluído, mesmo que eles ofereçam uma maneira de distribuir seu aplicativo dentro de um arquivo asar . Não será à prova de bala, mas ainda é melhor do que a sua fonte na planície.

Por padrão, o Windows associa arquivos .js ao host de scripts do Windows , o mecanismo de tempo de execução independente da Microsoft. Se você digitar script.js em um prompt de comando (ou clicar duas vezes em um arquivo .js no Explorer), o script será executado por wscript.exe .

Isso pode estar resolvendo um problema local com uma configuração global , mas você pode associar arquivos .js com node.exe , de modo que digitar script.js em um prompt de comando ou clicar duas vezes / arrastar itens em scripts os inicie com o Node.

É claro que, se – como eu – você associou arquivos .js a um editor, de modo que clicar duas vezes neles abre seu editor de texto favorito, essa sugestão não fará muito bem. Você também pode adicionar uma input de menu do botão direito do mouse de “Execute with Node” para arquivos .js , embora essa alternativa não resolva suas necessidades de linha de comando.


A solução mais simples é provavelmente usar apenas um arquivo de lote – você não precisa ter uma cópia do Node na pasta em que seu script reside. Apenas faça referência ao executável do Node absolutamente:

 "C:\Program Files (x86)\nodejs\node.exe" app.js %* 

Outra alternativa é esse aplicativo C # muito simples, que iniciará o Node usando seu próprio nome de arquivo + .js como o script a ser executado, e repassará todos os argumentos da linha de comando.

 class Program { static void Main(string[] args) { var info = System.Diagnostics.Process.GetCurrentProcess(); var proc = new System.Diagnostics.ProcessStartInfo(@"C:\Program Files (x86)\nodejs\node.exe", "\"" + info.ProcessName + ".js\" " + String.Join(" ", args)); proc.UseShellExecute = false; System.Diagnostics.Process.Start(proc); } } 

Portanto, se você nomear o EXE “app.exe” resultante, poderá digitar app arg1 ... e o Node será iniciado com a linha de comando "app.js" arg1 ... Observe que o aplicativo bootstrapper C # será imediatamente encerrado, deixando o Node responsável pela janela do console.

Já que isso é provavelmente de interesse relativamente amplo, eu fui em frente e disponibilizei isso no GitHub , incluindo o exe compilado se entrar em vans com estranhos é coisa sua.

Desde que esta pergunta foi respondida, outra solução foi lançada.

https://github.com/appjs/appjs

No momento em que este artigo foi escrito, essa é a solução final para o empacotamento de aplicativos node.js por meio de um pacote simplificado de cromo compilado em um executável.

Edit: AppJS não está mais ativo, mas em si sugere um fork chamado deskshell.

https://github.com/sihorton/appjs-deskshell/

Há muitas boas respostas aqui, mas elas não são tão simples quanto a JXcore .

Depois de ter o JXcore instalado no Windows, tudo o que você precisa fazer é executar:

 jx package app.js "myAppName" -native 

Isso produzirá um arquivo .exe que você pode distribuir e pode ser executado sem nenhuma dependência externa (você nem precisa do JXcore nem do Node.js no sistema).

Aqui está a documentação sobre essa funcionalidade: http://jxcore.com/packaging-code-protection/#cat-74

Editar 2018

Esse projeto está morto, mas ainda está hospedado aqui: https://github.com/jxcore/jxcore-release (thanks @Elmue)

Não tentei, mas nexe parece nexe pode fazer isso:

https://github.com/crcn/nexe

A melhor ferramenta que conheço é a ferramenta NodeJS: zeit / pkg

É muito fácil de usar (muito mais do que o Nexe, apenas como um exemplo), você pode instalar em todo o mundo: npm install -g pkg

para criar executáveis ​​para macOS, Linux e Windows:

pkg exampleApp.js

Eu tinha um pouco de código complicado que usava o servidor de soquete NodeJS, tentei aplicativos diferentes, nenhum deles criou corretamente, exceto o zeit / pkg .

Pouco tarde nisso, mas com base na resposta , eu criei um rápido “como fazer” post, usando Advanced “Batch To EXE Converter

http://www.alexjamesbrown.com/development/create-a-standalone-exe-to-run-a-node-js-application/

Eu encontrei qualquer uma dessas soluções atendeu aos meus requisitos, então fiz minha própria versão do nó chamado node2exe que faz isso. Está disponível em https://github.com/areve/node2exe

Tente disclose : https://github.com/pmq20/disclose

disclose essencialmente faz um exe autoextraível do seu projeto Node.js e do interpretador Node.js com as seguintes características,

  1. Sem GUI. CLI puro
  2. Não há dependencies de tempo de execução
  3. Suporta tanto o Windows quanto o Unix
  4. Executa lentamente pela primeira vez (extraindo para um diretório de cache), depois jejua para sempre

Experimente o node-compiler : https://github.com/pmq20/node-compiler

Eu fiz um novo projeto chamado node-compiler para compilar seu projeto Node.js em um único executável.

É melhor do que disclose que ele nunca é executado lentamente pela primeira vez, já que seu código-fonte é compilado junto com o interpretador Node.js, assim como as bibliotecas Node.js padrão.

Além disso, ele redireciona as solicitações de arquivos e diretórios de forma transparente para a memory, em vez de para o sistema de arquivos no tempo de execução. Portanto, nenhum código-fonte é necessário para executar o produto compilado.

Como funciona: https://speakerdeck.com/pmq20/node-dot-js-compiler-compiling-your-node-dot-js-application-into-a-single-executable

Comparando com projetos similares,

  • pkg ( https://github.com/zeit/pkg ): Pkg hacked fs. * APIs dinamicamente para acessar arquivos no pacote, enquanto o Node.js Compiler deixa-os em paz e, em vez disso, trabalha em um nível mais profundo via libsquash. O Pkg usa JSON para armazenar arquivos no pacote enquanto o Node.js Compiler usa o SquashFS mais sofisticado e amplamente utilizado como sua estrutura de dados.

  • EncloseJS ( http://enclosejs.com/ ): O EncloseJS restringe o access a arquivos no pacote para apenas cinco fs. * APIs, enquanto o Node.js Compiler suporta todas as APIs do fs. *. O EncloseJS é licenciado e cobra dinheiro quando usado, enquanto o Node.js Compiler é licenciado pelo MIT e os usuários podem usá-lo gratuitamente e modificá-lo.

  • Nexe ( https://github.com/nexe/nexe ): O Nexe não suporta dynamic require devido ao uso de browserify, enquanto o Node.js Compiler suporta todos os tipos de require, incluindo require.resolve.

  • asar ( https://github.com/electron/asar ): Asar usa o JSON para armazenar informações dos arquivos, enquanto o Node.js Compiler usa o SquashFS. Asar mantém o arquivo de código e o executável separados, enquanto o Compilador Node.js vincula todos os códigos-fonte JavaScript junto com a máquina virtual Node.js e gera um único executável como o produto final.

  • AppImage ( http://appimage.org/ ): AppImage suporta apenas Linux com um kernel que suporta SquashFS, enquanto o Node.js Compiler suporta todas as três plataformas de Linux, macOS e Windows, enquanto isso, sem quaisquer requisitos especiais de resources do kernel.

Eu estou te recomendando BoxedApp para isso. É um produto comercial que funciona muito bem. Ele funciona para qualquer aplicativo NodeJS. O usuário final receberá apenas um arquivo EXE para seu aplicativo. Não há necessidade de instalação.

Na Electron, por exemplo, o usuário final precisa instalar / descompactar seu aplicativo, e ele verá todos os arquivos de origem do seu código.

BoxedApp Está empacotando todos os arquivos e dependencies que seu aplicativo NodeJS precisa. Suporta compressões e o arquivo compilado funciona no Windows XP +

Quando você usá-lo, não se esqueça de adicionar o Node.EXE ao aplicativo compilado. Escolha uma versão de nó que suporte o Windows XP (se você precisar disso)

O programa suporta argumentos de linha de comando, Então após o pacote, você pode fazer

 c:\myApp argument1 

E você pode obter o argumento no seu código de nó:

 process.argv[1] 

Às vezes, seu aplicativo tem dependencies de arquivos, portanto, no BoxedApp você pode adicionar qualquer pasta e arquivo como uma dependência, por exemplo, você pode inserir um arquivo de configurações.

 var mySettings=require('fs').readFileSync('./settings.jgon').toString() 

Mais informações:

  • A empresa
  • O produto
  • Download de avaliação

Apenas uma nota: geralmente eu estou recomendando sobre software livre / código aberto, mas neste caso eu não encontrei nada que faça o trabalho.

Cansado de começar a ganhar a partir do prompt de comando, em seguida, eu corri em tudo isso também. Ver ligeiramente melhorado sobre o que josh3736 . Isso usa um arquivo XML para pegar algumas configurações. Por exemplo, o caminho para o Node.exe , bem como o arquivo para iniciar no app.js. padrão. Também o ambiente para carregar (produção, desenvolvimento, etc) que você especificou em seu app.js (ou server.js ou o que quer que você tenha chamado). Essencialmente, ele adiciona o NODE_ENV={0} que {0} é o nome de sua configuração em app.js como um var para você. Você faz isso modificando o elemento “mode” no config.xml. Você pode pegar o projeto aqui ==> github . Observe nos events Post Build que você pode modificar os caminhos de cópia para copiar automaticamente o config.xml e o executável no diretório Nodejs , apenas para salvar uma etapa. Caso contrário, edite-os ou sua construção emitirá um aviso.

 var startInfo = new ProcessStartInfo(); startInfo.FileName = nodepath; startInfo.Arguments = apppath; startInfo.UseShellExecute = false; startInfo.CreateNoWindow = false; startInfo.WindowStyle = ProcessWindowStyle.Hidden; if(env.Length > 0) startInfo.EnvironmentVariables.Add("NODE_ENV", env); try { using (Process p = Process.Start(startInfo)) { p.WaitForExit(); } } catch (Exception ex) { MessageBox.Show(ex.Message.ToString(), "Start Error", MessageBoxButtons.OK); } 

Pode haver muitas outras opções, mas, que eu saiba, há um projeto em desenvolvimento ativo no GitHub https://github.com/zeit/pkg . Você pode brincar com isso. Mais uma em https://github.com/nexe/nexe, mas não no desenvolvimento ativo.

Eu tenho explorado esse tópico por alguns dias e aqui está o que eu encontrei. As opções se enquadram em duas categorias:

Se você deseja criar um aplicativo de desktop, as melhores opções são:

1- NW.js : permite chamar todos os módulos Node.js diretamente do DOM e permite uma nova maneira de escrever aplicativos com todas as tecnologias da Web.

2- Electron : Crie aplicativos de desktop multiplataforma com JavaScript, HTML e CSS

Aqui está uma boa comparação entre eles: NW.js & Electron Compared . Eu acho que o NW.js é melhor e também fornece um aplicativo para compilar arquivos JS. Existem também alguns construtores executáveis ​​e instaladores independentes, como o Enigma Virtual Box . Ambos contêm uma versão incorporada do Chrome, que é desnecessária para aplicativos de servidor.

Se você quiser empacotar um aplicativo de servidor, estas são as melhores opções:

node-compiler : Compilador Ahead-of-time (AOT) projetado para o Node.js, que simplesmente funciona.

Nexe : crie um único executável a partir de seus aplicativos node.js

Nesta categoria, acredito que o compilador de nó é melhor e suporta módulos de requerimento dynamic e de nó nativo. É muito fácil de usar e a saída começa em 25MB. Você pode ler uma comparação completa com outras soluções na página Node Compiler. Eu não li muito sobre o Nexe, mas por enquanto, parece que o Node Compiler não compila o arquivo js para o formato binário usando o recurso de snapshot V8, mas está planejado para a versão 2. Ele também terá um construtor de instalador embutido.

Experimente o nexe que cria um único executável a partir dos seus aplicativos node.js

https://github.com/nexe/nexe

Existe um projeto de ferramenta de construção de código aberto chamado nodebob . Eu suponho que as janelas da plataforma de trabalho,

  1. basta clonar ou baixar o projeto
  2. copie todos os arquivos do projeto node-webkit para a pasta do aplicativo.
  3. execute o script build.bat.

Você encontrará o arquivo executável dentro da pasta de liberação.