Comment créer des fichiers EXE à partir d'une application node.js?

J'ai une application de nœud que j'ai écrite, que je lance comme suit:

node.exe app.js inputArg

Existe-t-il un moyen de regrouper cela dans un .exe par lui-même? Alors je peux juste faire quelque chose comme ça?

App.exe inputArg

J'ai un moyen de simuler cela en utilisant un fichier batch, donc je peux le faire:

App.bat inputArg

Mais cela nécessite que je dispose de toutes les dépendances et du nœud dans ce dossier, ce qui n'est pas idéal.

Il existe quelques alternatives, à la fois gratuites et commerciales. Je n'en ai utilisé aucun mais en théorie, ils devraient fonctionner:

• Iexpress (outil Windows natif)
• Compilateur de fichiers par lots rapide (commercial)
• Emballeur BoxedApp
• "Advanced" Batch To EXE Converter " (logiciel gratuit)

La plupart vous demanderont de conserver le fichier de commandes comme exécutable principal, puis de regrouper node.exe et vos scripts.

En fonction de votre script, vous avez également la possibilité de le porter vers JSDB , qui prend en charge un moyen simple de créer des exécutables en y ajoutant simplement des ressources.

Une troisième quasi-solution consiste à conserver le nœud quelque part C:\utilset à ajouter ce dossier à votre PATHvariable d'environnement. Ensuite, vous pouvez créer des fichiers .bat dans ce répertoire qui exécutent le nœud + vos scripts préférés - je fais coffeefonctionner coffeescript sur Windows de cette façon. Cette configuration peut être automatisée avec un fichier batch, un script vb ou un programme d'installation.

La solution que j'ai utilisée est le node-webkit de Roger Wang .

C'est un moyen fantastique de regrouper les applications nodejs et de les distribuer, cela vous donne même la possibilité de "regrouper" l'ensemble de l'application en un seul exécutable. Il prend en charge Windows, Mac et Linux.

Voici quelques documents sur les différentes options de déploiement d'applications node-webkit, mais en un mot, procédez comme suit:

1. Compressez tous vos fichiers, avec un package.json à la racine
2. Changez l'extension de .zip en .nw
3. copier / b nw.exe + app.nw app.exe

Juste une note supplémentaire - j'ai expédié plusieurs applications de production / installation de CD en utilisant cela, et cela a très bien fonctionné. La même application fonctionne sur Windows, Mac, Linux et sur le Web.

Mise à jour: le nom du projet a changé en 'nw.js' et se trouve correctement ici: nw.js

Pour quiconque tombe sur cette question, il existe maintenant deux projets qui créent des ex à partir de vos projets de nœuds, Pkg et Electron.atom.io , ils diffèrent légèrement:

1. Pkg compilera votre projet en code natif, ils incluront également des actifs ET une installation nodejs (le système n'aura pas besoin d'installer nodejs pour exécuter le .exe). Votre code source ne sera pas inclus. L'exécutable résultant est Windows UNIQUEMENT (.exe). Toutes les plates-formes sont désormais prises en charge. Il nécessite désormais une licence pour les produits commerciaux. Entièrement open source.
2. Electron.atom.io bien qu'il ne compacte pas et ne génère pas un .exe pour vous, il PEUT être utilisé pour distribuer des applications nodejs car elles offrent un moyen de distribuer des applications . Les avantages sont qu'électron est multi-plateforme (Windows, mac osx, linux), les inconvénients sont que votre code source sera inclus, même s'ils offrent un moyen de distribuer votre application dans une archive asar . Ce ne sera pas à l'épreuve des balles mais c'est toujours mieux que votre source en clair.

Par défaut, Windows associe les .jsfichiers à Windows Script Host , le moteur d'exécution JS autonome de Microsoft. Si vous tapez script.js à l'invite de commandes (ou double-cliquez sur un .jsfichier dans l'Explorateur), le script est exécuté par wscript.exe.

Cela peut résoudre un problème local avec un paramètre global , mais vous pouvez associer des .js fichiers à la node.exeplace, de sorte que la saisie de script.js à une invite de commande ou un double-clic / glissement d'éléments sur des scripts les lancera avec Node.

Bien sûr, si, comme moi, vous avez associé des .jsfichiers à un éditeur pour que double-cliquer dessus ouvre votre éditeur de texte préféré, cette suggestion ne fera pas grand-chose. Vous pouvez également ajouter une entrée de menu contextuelle «Exécuter avec le nœud» aux .jsfichiers, bien que cette alternative ne résout pas vos besoins en ligne de commande.

La solution la plus simple est probablement d'utiliser simplement un fichier de commandes - vous n'avez pas besoin d'avoir une copie de Node dans le dossier dans lequel réside votre script. Il vous suffit de référencer l'exécutable Node de manière absolue:

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

Une autre alternative est cette application C # très simple qui démarrera Node en utilisant son propre nom de fichier + .jscomme script à exécuter, et passera tous les arguments de ligne de commande.

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

Donc, si vous nommez le fichier EXE résultant "app.exe", vous pouvez taper app arg1 ...et Node démarrera avec la ligne de commande "app.js" arg1 .... Notez que l'application d'amorçage C # se fermera immédiatement, laissant Node en charge de la fenêtre de la console.

Étant donné que cela présente probablement un intérêt relativement large, je suis allé de l'avant et je l'ai rendu disponible sur GitHub , y compris l' exe compilé si vous aimez entrer dans des fourgons avec des inconnus.

Le meilleur outil que je connaisse est l'outil NodeJS: zeit / pkg

Il est très simple d'utilisation (bien plus que Nexe, à titre d'exemple), vous pouvez simplement l'installer globalement: npm install -g pkg

pour créer des exécutables pour macOS, Linux et Windows:

pkg exampleApp.js

J'avais un peu de code compliqué qui utilisait le serveur socket NodeJS, j'ai essayé différentes applications, aucune d'entre elles ne l'a créée correctement, sauf zeit / pkg .

Je ne l'ai pas essayé, mais nexe semble que nexe peut le faire:

https://github.com/crcn/nexe

Depuis que cette question a été répondue, une autre solution a été lancée.

https://github.com/appjs/appjs

Au moment d'écrire ces lignes, il s'agit de la solution ultime pour empaqueter les applications node.js via un package chrome dépouillé compilé dans un exécutable.

Edit: AppJS n'est plus actif, mais lui-même suggère une fourchette appelée deskshell.

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

Il y a beaucoup de bonnes réponses ici, mais elles ne sont pas toutes aussi simples que JXcore .

Une fois JXcore installé sur Windows, il ne vous reste plus qu'à exécuter:

jx package app.js "myAppName" -native

Cela produira un fichier .exe que vous pouvez distribuer et qui peut être exécuté sans aucune dépendance externe (vous n'avez même pas besoin de JXcore ni de Node.js sur le système).

Voici la documentation sur cette fonctionnalité: http://jxcore.com/packaging-code-protection/#cat-74

Modifier 2018

Ce projet est maintenant mort mais il est toujours hébergé ici: https://github.com/jxcore/jxcore-release (merci @Elmue)

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

disclose fait essentiellement un exe auto-extractible de votre projet Node.js et de l'interpréteur Node.js avec les caractéristiques suivantes,

1. Pas de GUI. CLI pur.
2. Aucune dépendance d'exécution
3. Prend en charge Windows et Unix
4. S'exécute lentement pour la première fois (extraction vers un répertoire de cache), puis rapidement pour toujours

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

J'ai créé un nouveau projet appelé node-compilerà compiler votre projet Node.js en un seul exécutable.

C'est mieux que disclosede ne jamais s'exécuter lentement pour la première fois, puisque votre code source est compilé avec l'interpréteur Node.js, tout comme les bibliothèques Node.js standard.

En outre, il redirige les demandes de fichiers et de répertoires de manière transparente vers la mémoire plutôt que vers le système de fichiers lors de l'exécution. Pour qu'aucun code source ne soit nécessaire pour exécuter le produit compilé.

Comment ça marche: https://speakerdeck.com/pmq20/node-dot-js-compiler-compiling-your-node-dot-js-application-into-a-single-executable

Comparaison avec des projets similaires,

• pkg ( https://github.com/zeit/pkg ): Pkg a piraté les API fs. * dynamiquement afin d'accéder aux fichiers du package, alors que Node.js Compiler les laisse seuls et travaille à un niveau plus profond via libsquash. Pkg utilise JSON pour stocker les fichiers dans le package tandis que Node.js Compiler utilise le SquashFS plus sophistiqué et largement utilisé comme structure de données.

• EncloseJS ( http://enclosejs.com/ ): EncloseJS limite l'accès aux fichiers du package à seulement cinq API fs. *, Alors que Node.js Compiler prend en charge toutes les API fs. *. EncloseJS est sous licence propriétaire et facture de l'argent lorsqu'il est utilisé, tandis que Node.js Compiler est sous licence MIT et les utilisateurs sont à la fois libres de l'utiliser et libres de le modifier.

• Nexe ( https://github.com/nexe/nexe ): Nexe ne prend pas en charge les exigences dynamiques en raison de son utilisation de browserify, alors que Node.js Compiler prend en charge toutes sortes de require, y compris require.resolve.

• asar ( https://github.com/electron/asar ): Asar utilise JSON pour stocker les informations des fichiers tandis que Node.js Compiler utilise SquashFS. Asar garde l'archive de code et l'exécutable séparés tandis que le compilateur Node.js lie tout le code source JavaScript avec la machine virtuelle Node.js et génère un seul exécutable en tant que produit final.

• AppImage ( http://appimage.org/ ): AppImage ne prend en charge que Linux avec un noyau qui prend en charge SquashFS, tandis que Node.js Compiler prend en charge les trois plates-formes de Linux, macOS et Windows, entre-temps sans aucune exigence de fonctionnalités spéciales du noyau.

Je vous recommande BoxedApp pour cela. C'est un produit commercial qui fonctionne très bien. Cela fonctionne pour n'importe quelle application NodeJS. L'utilisateur final ne recevra qu'un seul fichier EXE pour votre application. Pas besoin d'installation.

Dans Electron, par exemple, l'utilisateur final doit installer / décompresser votre application, et il verra tous les fichiers source de votre code.

BoxedApp Il regroupe tous les fichiers et dépendances dont votre application NodeJS a besoin. Il prend en charge les compressions et le fichier compilé fonctionne sur Windows XP +

Lorsque vous l'utilisez, assurez-vous d'ajouter Node.EXE à l'application compilée. Choisissez une version de nœud prenant en charge Windows XP (si vous en avez besoin)

Le programme prend en charge les arguments de ligne de commande, donc après le package, vous pouvez faire

c:\myApp argument1

Et vous pouvez obtenir l'argument dans le code de votre nœud:

process.argv[1]

Parfois, votre application a des dépendances de fichiers, donc dans BoxedApp, vous pouvez ajouter n'importe quel dossier et fichier en tant que dépendance, par exemple, vous pouvez insérer un fichier de paramètres.

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

Plus d'informations:

• L'entreprise
• Le produit
• Télécharger la version d'essai

Juste une note: en général, je recommande des logiciels open-source / gratuits, mais dans ce cas, je n'ai rien trouvé qui fasse le travail.

J'ai trouvé que l'une de ces solutions répondait à mes exigences, j'ai donc créé ma propre version de node appelée node2exe qui le fait. Il est disponible sur https://github.com/areve/node2exe

J'explore ce sujet depuis quelques jours et voici ce que j'ai trouvé. Les options se divisent en deux catégories:

Si vous souhaitez créer une application de bureau, les meilleures options sont:

1- NW.js : permet d'appeler tous les modules Node.js directement depuis DOM et permet une nouvelle façon d'écrire des applications avec toutes les technologies Web.

2- Electron : Créez des applications de bureau multiplateformes avec JavaScript, HTML et CSS

Voici une bonne comparaison entre eux: NW.js & Electron Compared . Je pense que NW.js est meilleur et qu'il fournit également une application pour compiler des fichiers JS. Il existe également des exécutables autonomes et des installateurs comme Enigma Virtual Box . Ils contiennent tous deux une version intégrée de Chrome qui n'est pas nécessaire pour les applications serveur.

si vous souhaitez empaqueter une application serveur, voici les meilleures options:

compilateur de nœuds : Ahead-of-Time (AOT) conçu pour Node.js, qui fonctionne juste.

Nexe : créez un seul exécutable à partir de vos applications node.js

Dans cette catégorie, je pense que le compilateur de nœuds est meilleur, car il prend en charge les modules de nœuds dynamiques et natifs. Il est très facile à utiliser et la sortie commence à 25 Mo. Vous pouvez lire une comparaison complète avec d'autres solutions dans la page Node Compiler. Je n'ai pas beaucoup lu sur Nexe, mais pour l'instant, il semble que Node Compiler ne compile pas le fichier js au format binaire en utilisant la fonction d'instantané V8, mais il est prévu pour la version 2. Il aura également un constructeur d'installation intégré.

Essayez nexe qui crée un seul exécutable à partir de vos applications node.js

https://github.com/nexe/nexe

Je suis fatigué de commencer à gagner à partir de l'invite de commande, puis je suis tombé dessus aussi. Ver légèrement amélioré. sur quoi josh3736 . Cela utilise un fichier XML pour saisir quelques paramètres. Par exemple, le chemin d'accès Node.exeainsi que le fichier à démarrer dans le fichier app.js. par défaut. Aussi l'environnement à charger (production, dev, etc.) que vous avez spécifié dans votre app.js (ou server.js ou comme vous l'avez appelé). Essentiellement, il ajoute le NODE_ENV={0}where {0} est le nom de votre configuration dans app.js en tant que var pour vous. Pour ce faire, modifiez l'élément "mode" dans le fichier config.xml. Vous pouvez récupérer le projet ici ==> répertoire github . Notez que dans les événements post-build, vous pouvez modifier les chemins de copie pour copier automatiquement sur votre config.xml et l'exécutable sur votreNodejs , juste pour enregistrer une étape. Sinon, modifiez-les ou votre build lancera un avertissement.

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

Il peut y avoir de nombreuses autres options mais à ma connaissance, il existe un projet en développement actif sur GitHub https://github.com/zeit/pkg . Vous pouvez jouer avec. Un de plus sur https://github.com/nexe/nexe mais pas en développement actif.

Il existe un projet d'outil de construction open source appelé nodebob . Je suppose que les fenêtres de la plate-forme de travail,

1. clonez ou téléchargez simplement le projet
2. copiez tous vos fichiers de projet node-webkit dans le dossier de l'application.
3. exécutez le script build.bat.

Vous trouverez le fichier exécutable dans le dossier release.