Come creare file exe da un'app node.js?

Ho un'app per nodi che ho scritto, che eseguo come segue:

node.exe app.js inputArg

C'è un modo per comprimerlo in un .exe da solo? Quindi posso fare qualcosa del genere?

App.exe inputArg

Ho un modo per simulare questo utilizzando un file batch, quindi posso farlo:

App.bat inputArg

Ma questo richiede che io abbia tutte le dipendenze e il nodo in quella cartella, il che non è l'ideale.

Ci sono alcune alternative, sia gratuite che commerciali. Non ho usato nessuno di loro ma in teoria dovrebbero funzionare:

• Iexpress (strumento nativo di Windows)
• Quick Batch File Compiler (commerciale)
• BoxedApp Packer
• "Advanced" Batch To EXE Converter " (freeware)

La maggior parte richiederà di mantenere il file batch come eseguibile principale, quindi raggruppare node.exe e gli script.

A seconda dello script, hai anche la possibilità di portarlo su JSDB , che supporta un modo semplice per creare eseguibili semplicemente aggiungendo risorse ad esso.

Una terza quasi soluzione è mantenere il nodo da qualche parte C:\utilse aggiungere questa cartella alla PATHvariabile d'ambiente. Quindi puoi creare file .bat in quella directory che eseguono node + i tuoi script preferiti: ho fatto funzionare coffeescript coffeesu Windows in questo modo. Questa configurazione può essere automatizzata con un file batch, uno script vb o un programma di installazione.

La soluzione che ho usato è il node-webkit di Roger Wang .

Questo è un modo fantastico per creare pacchetti di app nodejs e distribuirli, ti dà anche la possibilità di "raggruppare" l'intera app come un singolo eseguibile. Supporta Windows, Mac e Linux.

Qui alcuni documenti sulle varie opzioni per la distribuzione di app node-webkit, ma in poche parole, fai quanto segue:

1. Comprimi tutti i tuoi file, con un package.json nella root
2. Cambia l'estensione da .zip a .nw
3. copia / b nw.exe + app.nw app.exe

Proprio come una nota aggiunta: ho spedito diverse applicazioni di produzione / installazione di CD usando questo, e ha funzionato alla grande. La stessa app funziona su Windows, Mac, Linux e sul Web.

Aggiornamento: il nome del progetto è cambiato in "nw.js" e si trova correttamente qui: nw.js

Per chiunque si imbatta in questa domanda, ora ci sono due progetti che creano ex dai tuoi progetti nodo, Pkg ed Electron.atom.io , che differiscono leggermente:

1. Pkg compilerà il tuo progetto in codice nativo, includerà anche risorse E un'installazione di nodejs (il sistema non avrà bisogno di installare nodejs per eseguire l'exe). Il tuo codice sorgente non sarà incluso. L'eseguibile risultante è SOLO Windows (.exe). Tutte le piattaforme sono ora supportate. Ora richiede una licenza per i prodotti commerciali. Completamente open source.
2. Electron.atom.io sebbene non compatterà e genererà un .exe per te, PU essere utilizzato per distribuire app nodejs poiché offrono un modo per distribuire applicazioni . I vantaggi sono che electron è multipiattaforma (windows, mac osx, linux), gli svantaggi sono che il tuo codice sorgente sarà incluso, anche se offrono un modo per distribuire la tua app all'interno di un archivio asar . Non sarà a prova di proiettile ma è comunque migliore della tua fonte in chiaro.

Per impostazione predefinita, Windows associa i .jsfile a Windows Script Host , il motore di runtime JS autonomo di Microsoft. Se digiti script.js al prompt dei comandi (o fai doppio clic su un .jsfile in Explorer), lo script viene eseguito dawscript.exe .

Questo potrebbe risolvere un problema locale con un'impostazione globale , ma potresti invece associare .js file a node.exe, in modo che digitando script.js al prompt dei comandi o facendo doppio clic / trascinando gli elementi sugli script li con Node.

Naturalmente, se, come me, hai associato i .jsfile a un editor in modo che facendo doppio clic su di essi si apra il tuo editor di testo preferito, questo suggerimento non servirà a molto. Puoi anche aggiungere una voce di menu di scelta rapida di di di "Esegui con nodo" .js, sebbene questa alternativa non risolva le esigenze della riga di comando.

La soluzione più semplice è probabilmente quella di utilizzare solo un file batch: non è necessario avere una copia di Node nella cartella in cui risiede lo script. Fai semplicemente riferimento all'eseguibile di Node in modo assoluto:

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

Un'altra alternativa è questa semplicissima app C # che avvierà Node usando il proprio nome di file + .jscome script da eseguire e passerà qualsiasi argomento della riga di 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);
    }
}

Quindi, se si chiama l'EXE risultante "app.exe", è possibile digitare app arg1 ...e Node verrà avviato con la riga di comando "app.js" arg1 .... Si noti che l'app per il programma di avvio automatico C # verrà chiusa immediatamente, lasciando Node responsabile della finestra della console.

Poiché questo è probabilmente di interesse relativamente ampio, sono andato avanti e l'ho reso disponibile su GitHub , incluso l' exe compilato se entrare in furgoni con estranei è la tua passione.

Lo strumento migliore che conosco è lo strumento NodeJS: zeit / pkg

È molto facile da usare (molto più di Nexe, solo come esempio), puoi semplicemente installarlo a livello globale: npm install -g pkg

per creare eseguibili per macOS, Linux e Windows:

pkg exampleApp.js

Avevo un po 'di codice complicato che utilizzava il server socket NodeJS, ho provato diverse applicazioni, nessuna lo ha creato correttamente, tranne zeit / pkg .

Non l'ho provato, ma nexe sembra che nexe possa farlo:

https://github.com/crcn/nexe

Da quando è stata data risposta a questa domanda, è stata lanciata un'altra soluzione.

https://github.com/appjs/appjs

Al momento della stesura di questo documento, questa è la soluzione definitiva per il packaging delle app node.js tramite un pacchetto Chrome ridotto compilato in un eseguibile.

Modifica: AppJS non è più attivo, ma suggerisce di per sé un fork chiamato deskshell.

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

Ci sono molte buone risposte qui, ma non sono tutte così semplici come JXcore .

Una volta installato JXcore su Windows, tutto ciò che devi fare è eseguire:

jx package app.js "myAppName" -native

Questo produrrà un file .exe che puoi distribuire e può essere eseguito senza alcuna dipendenza esterna (non hai nemmeno bisogno di JXcore né Node.js sul sistema).

Ecco la documentazione su quella funzionalità: http://jxcore.com/packaging-code-protection/#cat-74

Modifica 2018

Quel progetto ora è morto ma è ancora ospitato qui: https://github.com/jxcore/jxcore-release (grazie @Elmue)

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

disclose essenzialmente crea un file eseguibile autoestraente dal tuo progetto Node.js e dall'interprete Node.js con le seguenti caratteristiche,

1. Nessuna GUI. CLI pura.
2. Nessuna dipendenza in fase di esecuzione
3. Supporta sia Windows che Unix
4. Viene eseguito lentamente per la prima volta (estrazione in una directory della cache), quindi veloce per sempre

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

Ho creato un nuovo progetto chiamato node-compilerper compilare il tuo progetto Node.js in un unico eseguibile.

È meglio di disclose in quanto non viene mai eseguito lentamente per la prima volta, poiché il codice sorgente viene compilato insieme all'interprete Node.js, proprio come le librerie Node.js standard.

Inoltre, reindirizza le richieste di file e directory in modo trasparente alla memoria invece che al file system in fase di esecuzione. In modo che non sia richiesto alcun codice sorgente per eseguire il prodotto compilato.

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

Confrontando con progetti simili,

• pkg ( https://github.com/zeit/pkg ): Pkg ha hackerato le API di fs. * dinamicamente per accedere ai file nel pacchetto, mentre il compilatore Node.js li lascia da soli e invece lavora a un livello più profondo tramite libsquash. Pkg utilizza JSON per archiviare i file nel pacchetto mentre il compilatore Node.js utilizza SquashFS più sofisticato e ampiamente utilizzato come struttura dati.

• EncloseJS ( http://enclosejs.com/ ): EncloseJS limita l'accesso ai file nel pacchetto solo a cinque API fs. *, Mentre il compilatore Node.js supporta tutte le API fs. *. EncloseJS ha una licenza proprietaria e addebita denaro quando viene utilizzato mentre Node.js Compiler è concesso in licenza dal MIT e gli utenti sono sia liberi di usarlo che di modificarlo.

• Nexe ( https://github.com/nexe/nexe ): Nexe non supporta i requisiti dinamici a causa del suo utilizzo di browserify, mentre il compilatore Node.js supporta tutti i tipi di requisiti incluso require.resolve.

• asar ( https://github.com/electron/asar ): Asar utilizza JSON per memorizzare le informazioni sui file mentre il compilatore Node.js utilizza SquashFS. Asar mantiene l'archivio del codice e l'eseguibile separati mentre il compilatore Node.js collega tutto il codice sorgente JavaScript insieme alla macchina virtuale Node.js e genera un singolo eseguibile come prodotto finale.

• AppImage ( http://appimage.org/ ): AppImage supporta solo Linux con un kernel che supporta SquashFS, mentre il compilatore Node.js supporta tutte e tre le piattaforme Linux, macOS e Windows, nel frattempo senza requisiti di funzionalità speciali dal kernel.

Ti sto raccomandando BoxedApp per questo. È un prodotto commerciale che funziona molto bene. Funziona con qualsiasi app NodeJS. L'utente finale riceverà un solo file EXE per la tua app. Nessuna necessità di installazione.

In Electron, ad esempio, l'utente finale deve installare / decomprimere la tua app e vedrà tutti i file sorgente del tuo codice.

BoxedApp Sta impacchettando tutti i file e le dipendenze di cui la tua app NodeJS ha bisogno. Supporta le compressioni e il file compilato funziona su Windows XP +

Quando lo usi, assicurati di aggiungere Node.EXE all'app compilata. Scegli una versione del nodo che supporti Windows XP (se necessario)

Il programma supporta gli argomenti della riga di comando, quindi dopo il pacchetto, puoi farlo

c:\myApp argument1

E puoi ottenere l'argomento nel codice del tuo nodo:

process.argv[1]

A volte la tua app ha dipendenze di file, quindi in BoxedApp puoi aggiungere qualsiasi cartella e file come dipendenza, ad esempio puoi inserire un file di impostazioni.

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

Ulteriori informazioni:

• L'azienda
• Il prodotto
• Scarica la prova

Solo una nota: di solito sto raccomandando software open-source / gratuito, ma in questo caso non ho trovato nulla che possa portare a termine il lavoro.

Ho trovato che una qualsiasi di queste soluzioni soddisfacesse i miei requisiti, quindi ho creato la mia versione del nodo chiamata node2exe che lo fa. È disponibile su https://github.com/areve/node2exe

Sto esplorando questo argomento da alcuni giorni ed ecco cosa ho trovato. Le opzioni si dividono in due categorie:

Se vuoi creare un'app desktop, le migliori opzioni sono:

1- NW.js : consente di chiamare tutti i moduli Node.js direttamente da DOM e abilita un nuovo modo di scrivere applicazioni con tutte le tecnologie Web.

2- Electron : crea app desktop multipiattaforma con JavaScript, HTML e CSS

Ecco un buon confronto tra loro: NW.js & Electron Compared . Penso che NW.js sia migliore e fornisce anche un'applicazione per compilare file JS. Ci sono anche alcuni eseguibili autonomi e programmi di installazione come Enigma Virtual Box . Entrambi contengono una versione incorporata di Chrome che non è necessaria per le app server.

se vuoi creare un pacchetto di un'app server, queste sono le migliori opzioni:

node-compiler : compilatore Ahead-of-time (AOT) progettato per Node.js, che funziona.

Nexe : crea un singolo eseguibile dalle tue app node.js.

In questa categoria, credo che il compilatore di nodi sia migliore che supporta i moduli di richiesta dinamica e di nodo nativo. È molto facile da usare e l'output inizia a 25 MB. Puoi leggere un confronto completo con altre soluzioni nella pagina Node Compiler. Non ho letto molto su Nexe, ma per ora sembra che Node Compiler non compili il file js in formato binario utilizzando la funzionalità snapshot V8, ma è previsto per la versione 2. Avrà anche un installer builder integrato.

Prova nexe che crea un singolo eseguibile dalle tue app node.js.

https://github.com/nexe/nexe

Mi sono stancato di iniziare su Win dal prompt dei comandi, quindi mi sono imbattuto anche in questo. Leggermente migliorata ver. su cosa josh3736 . Questo utilizza un file XML per acquisire alcune impostazioni. Ad esempio, il percorso Node.exee il file da avviare nell'app.js. predefinito Anche l'ambiente da caricare (produzione, sviluppo ecc.) Che hai specificato nel tuo app.js (o server.js o come lo hai chiamato). Essenzialmente aggiunge il NODE_ENV={0}dove {0} è il nome della tua configurazione in app.js come una variabile per te. Puoi farlo modificando l'elemento "mode" nel config.xml. Puoi prendere il progetto qui ==> directory, solo per salvare un passaggio. Altrimenti modificali o la tua build genererà un avviso. github . Nota negli eventi di post-compilazione puoi modificare i percorsi di copia da copiare automaticamente sul tuo config.xml e l'eseguibile sul tuoNodejs

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);
        }

Potrebbero esserci molte altre opzioni, ma per quanto ne so, c'è un progetto in sviluppo attivo su GitHub https://github.com/zeit/pkg . Puoi giocarci. Un altro su https://github.com/nexe/nexe ma non in fase di sviluppo attivo.

C'è un progetto di strumento di compilazione opensource chiamato nodebob . Presumo che le finestre della piattaforma di lavoro,

1. semplicemente clonare o scaricare il progetto
2. copia tutti i tuoi file di progetto node-webkit nella cartella dell'app.
3. eseguire lo script build.bat.

Troverai il file eseguibile all'interno della cartella di rilascio.