Como fazer arquivos exe de um aplicativo node.js?

Tenho um aplicativo de nó que escrevi e que executo da seguinte maneira:

node.exe app.js inputArg

Existe alguma maneira de empacotar isso em um .exe sozinho? Então eu posso fazer algo assim?

App.exe inputArg

Eu tenho uma maneira de fingir isso usando um arquivo em lote, então posso fazer o seguinte:

App.bat inputArg

Mas isso requer que eu tenha todas as dependências e nós nessa pasta, o que não é o ideal.

Existem algumas alternativas, gratuitas e comerciais. Não usei nenhum deles, mas, em teoria, devem funcionar:

• Iexpress (ferramenta nativa do Windows)
• Compilador de arquivo de lote rápido (comercial)
• BoxedApp Packer
• Conversor de lote para EXE "avançado" (freeware)

A maioria exigirá que você mantenha o arquivo em lote como 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 JSDB , que oferece suporte a uma maneira fácil de criar executáveis simplesmente anexando recursos a ele.

Uma terceira quase solução é manter o nó em algum lugar como C:\utilse adicionar esta pasta à sua PATHvariável de ambiente. Então você pode criar arquivos .bat naquele diretório que executa o nó + seus scripts preferidos - eu tenho o coffeescript coffeefuncionando no Windows desta forma. Esta configuração pode ser automatizada com um arquivo em lote, script vb ou instalador.

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

Esta é uma maneira fantástica de empacotar aplicativos nodejs e distribuí-los, e ainda oferece a opção de "empacotar" o aplicativo inteiro como um único executável. Suporta windows, mac e linux.

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

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

Apenas como uma observação adicional - Eu enviei vários aplicativos de produção / instalação de cd usando isso e funcionou muito bem. O mesmo aplicativo é executado em windows, mac, linux e na web.

Atualização: o nome do projeto mudou para 'nw.js' e está localizado corretamente aqui: nw.js

Para qualquer um que esteja se deparando com esta questão, agora existem dois projetos que criam exes a partir de seus projetos de nó, Pkg e Electron.atom.io , eles diferem ligeiramente:

1. Pkg irá compilar seu projeto para o código nativo, eles também incluem ativos E uma instalação de nodejs (o sistema não precisará instalar nodejs para executar o .exe). Seu código-fonte não será incluído. O executável resultante é SOMENTE para Windows (.exe). Todas as plataformas são suportadas agora. Agora requer uma licença para produtos comerciais. Código totalmente aberto.
2. Electron.atom.io embora não seja compactado e gere um .exe para você, ele PODE ser usado para distribuir aplicativos nodejs, pois eles oferecem uma maneira de distribuir aplicativos . Os benefícios são que o electron é multiplataforma (windows, mac osx, linux), os contras são que o seu código-fonte SERÁ incluído, embora eles ofereçam uma forma de distribuir a sua aplicação dentro de um arquivo asar . Não será à prova de balas, mas ainda é melhor do que sua fonte.

Por padrão, o Windows associa .jsarquivos ao Windows Script Host , o mecanismo de tempo de execução JS autônomo da Microsoft. Se você digitar script.js em um prompt de comando (ou clicar duas vezes em um .jsarquivo no Explorer), o script será executado por wscript.exe.

Isso pode resolver um problema local com uma configuração global , mas você pode associar .js arquivos a node.exe, de modo que digitar script.js em um prompt de comando ou clicar duas vezes / arrastar itens em scripts irá iniciá-los com o Node.

Claro, se - como eu - você associou .jsarquivos a um editor de forma que clicar duas vezes neles abre seu editor de texto favorito, esta sugestão não adiantará muito. Você também pode adicionar uma entrada de menu do botão direito do mouse "Executar com Nó" aos .jsarquivos, embora essa alternativa não resolva suas necessidades de linha de comando.

A solução mais simples é provavelmente usar apenas um arquivo em lote - você não precisa ter uma cópia do Node na pasta em que seu script reside. Basta fazer referência ao executável do Node com certeza:

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

Outra alternativa é este aplicativo C # muito simples que iniciará o Node usando seu próprio nome de arquivo + .jscomo o script a ser executado e transmitirá quaisquer argumentos de 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 resultante como "app.exe", poderá digitar app arg1 ...e o Node será iniciado com a linha de comando "app.js" arg1 .... Observe que o aplicativo bootstrapper C # sairá imediatamente, deixando o Node encarregado da janela do console.

Como isso provavelmente é de interesse relativamente amplo, eu fui em frente e disponibilizei isso no GitHub , incluindo o exe compilado, se você gosta de entrar em vans com estranhos.

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

É muito fácil de usar (muito mais do que o Nexe, apenas a título de exemplo), você pode simplesmente instalar no global: npm install -g pkg

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

pkg exampleApp.js

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

Ainda não tentei, mas parece que nexe pode fazer isso:

https://github.com/crcn/nexe

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

https://github.com/appjs/appjs

No momento em que este artigo foi escrito, esta é a solução definitiva para empacotar aplicativos node.js por meio de um pacote reduzido de cromo compilado em um executável.

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

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

Há muitas respostas boas aqui, mas nem todas são tão diretas quanto JXcore .

Depois de instalar o JXcore 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 quaisquer dependências externas (você nem precisa de JXcore nem Node.js no sistema).

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

Editar 2018

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

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

disclose essencialmente faz um exe autoextraível de seu projeto Node.js e intérprete Node.js com as seguintes características,

1. Sem GUI. CLI puro.
2. Sem dependências de tempo de execução
3. Suporta Windows e Unix
4. É executado lentamente pela primeira vez (extraindo para um diretório de cache), depois rápido para sempre

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

Fiz um novo projeto chamado node-compilerpara compilar seu projeto Node.js em um único executável.

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

Além disso, ele redireciona as solicitações de arquivos e diretórios de forma transparente para a memória, em vez de para o sistema de arquivos durante a execução. Para que nenhum código-fonte seja 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 semelhantes,

• pkg ( https://github.com/zeit/pkg ): Pkg hackeado fs. * API's dinamicamente para acessar os arquivos do pacote, enquanto o Node.js Compiler os deixa sozinhos 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 usado como sua estrutura de dados.

• EncloseJS ( http://enclosejs.com/ ): EncloseJS restringe o acesso aos arquivos do pacote a apenas cinco APIs fs. *, Enquanto o compilador Node.js suporta todas as APIs fs. *. O EncloseJS é licenciado pelo proprietário e cobra dinheiro quando usado, enquanto o Node.js Compiler é licenciado pelo MIT e os usuários são livres para usá-lo e modificá-lo.

• Nexe ( https://github.com/nexe/nexe ): Nexe não oferece suporte a requisitos dinâmicos devido ao seu uso de browserify, enquanto o compilador Node.js oferece suporte a todos os tipos de requisitos, incluindo require.resolve.

• asar ( https://github.com/electron/asar ): Asar usa JSON para armazenar informações de arquivos enquanto o compilador Node.js usa SquashFS. Asar mantém o arquivo de código e o executável separados enquanto o compilador Node.js vincula todo o código-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 Node.js Compiler suporta todas as três plataformas de Linux, macOS e Windows, entretanto sem quaisquer requisitos de recursos especiais do kernel.

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

No Electron, por exemplo, o usuário final precisa instalar / descompactar seu aplicativo e verá todos os arquivos-fonte do seu código.

BoxedApp é o empacotamento de todos os arquivos e dependências que seu aplicativo NodeJS precisa. Suporta compressões e o arquivo compilado funciona no Windows XP +

Ao usá-lo, certifique-se de adicionar Node.EXE ao aplicativo compilado. Escolha uma versão de nó compatível com Windows XP (se precisar)

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 em seu código de nó:

process.argv[1]

Às vezes, seu aplicativo tem dependências de arquivos, portanto, em 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
• Baixar teste

Apenas uma nota: normalmente estou recomendando sobre software livre / open-source, mas neste caso não encontrei nada que faça o trabalho.

Eu descobri que 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

Venho explorando esse assunto há alguns dias e aqui está o que encontrei. As opções se enquadram em duas categorias:

Se você deseja construir 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 forma de escrever aplicativos com todas as tecnologias da web.

2- Electron : Crie aplicativos de plataforma cruzada para desktop com JavaScript, HTML e CSS

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

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

node-compiler : compilador Ahead-of-time (AOT) projetado para 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, pois oferece suporte a módulos de nó nativos e requisitos dinâmicos. É muito fácil de usar e a saída começa em 25 MB. 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 agora, parece que o Node Compiler não compila o arquivo js para o formato binário usando o recurso de instantâneo V8, mas está planejado para a versão 2. Ele também terá um construtor de instalador integrado.

Experimente o nexe, que cria um único executável de seus aplicativos node.js.

https://github.com/nexe/nexe

Cansei de começar no win a partir do prompt de comando, então também me deparei com isso. Versão ligeiramente melhorada. sobre o que josh3736 . Isso usa um arquivo XML para obter algumas configurações. Por exemplo, o caminho Node.exee o arquivo para iniciar no app.js. padrão Além disso, o ambiente para carregar (produção, desenvolvimento, etc) que você especificou em seu app.js (ou server.js ou como você o chamou). Essencialmente, ele adiciona o NODE_ENV={0}where {0} é o nome de sua configuração em app.js como uma var para você. Você faz isso modificando o elemento "mode" no config.xml. Você pode pegar o projeto aqui ==> github . Observe que nos eventos de pós-construção, você pode modificar os caminhos de cópia para copiar automaticamente em seu config.xml e o executável emNodejsdiretório, 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 um em https://github.com/nexe/nexe, mas não em desenvolvimento ativo.

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

1. simplesmente clone ou baixe o projeto
2. copie todos os seus arquivos de projeto do node-webkit para a pasta do aplicativo.
3. execute o script build.bat.

Você encontrará o arquivo executável dentro da pasta de lançamento.