0

Does anyone know how to achieve being to execute a node bash proram from the command line, for example the way you might call "brew install" - normally, you need to call "node NAME_OF_CLI".

The problem is that I can't just throw my program into the /bin folder because I would need to put the node_modules folder in there as well - and that just does not seem acceptable. Is there a known way to package all of these things together so it will be an executable program?

Also, I do not want this to be in npm - this is not a public module.

netpoetica
  • 3,375
  • 4
  • 27
  • 37
  • Additionally, I do not have want to have to implicitly call "node" - so I have it my path. This seems to work, but I just want to be clear that I am looking for a solution that does not include invoking node manually – netpoetica May 31 '13 at 14:19

2 Answers2

1

Here's what I would do.

Distribute your program in a traditional archive

  • package your program into a distributable archive such as .tar.bz2 (preferred), .tar.gz, or .zip (if it needs to support windows)
  • In the archive include node itself, your fully-populated node_modules folder, and all your other javascript modules, files, whatnot
  • Because node is platform-dependent, you will thus need a different archive distribution for each target architecture (linux/windows/osx)
  • These above are consistent with the 12 Factor App Build/Release/Run principles.
  • Include an executable shell script that is your program's entry point that can do something like

Include an executable shell script wrapper

#!/bin/sh
DIR=$(dirname "${0}")
exec "${DIR}/node/bin/node" "${DIR}/main.js" "${@}"

Install via curl command line copy/paste

I noticed in the comments you want a homebrew-style install-via curl command line. In that case, all of the above still applies but your curl command downloads a shell script that does:

  • download the distribution archive
  • extract it in place (/usr/local/programname would be reasonable)
  • If necessary, set up symlinks or copy files into a bin directory in the user's PATH (/usr/local/bin/programname would be reasonable)

So your curl command might be curl http://example.com/myprogram/install.sh | sh

Again, this is consistent with the 12 Factor App principles, which are sound. In particular:

  • Do not expect the target user to already have node installed
  • Do not expect the target user to install node by following your directions
  • Do not bother trying to support varying versions of node unless you really have a requirement to do so
  • It is OK to bundle node with your app. It makes it easier to install, easier to support, and less prone to errors.

Misc Tips

  • Make sure your installer code is idempotent
  • You may want to explicitly set the wrapper shell script executable on the target machine with chmod in the install.sh script as zip archives and tar under some circumstances won't preserve that
  • Watch out for OS X's crappy old tar. Use gnutar instead.

Reference material

Refer to homebrew's go ruby program for ideas/inspiration https://raw.github.com/mxcl/homebrew/go

Here are some examples taken from build script in the github repo for my web site

install_node() {
  local VERSION=${1-0.10.7}
  local PREFIX=${2-node}
  local PLATFORM=$(uname | tr A-Z a-z)
  case $(uname -p) in
      i686)
          ARCH=x86
      ;;
  esac
  mkdir -p "${PREFIX}"
  curl --silent \
    "http://nodejs.org/dist/v${VERSION}/node-v${VERSION}-${PLATFORM}-${ARCH}.tar.gz" \
    | tar xzf - --strip-components=1 -C "${PREFIX}"
}


task:dist() {
  cd "${CODE_PATH}"
  local GIT_REF="${1-master}"
  local BUILD_DIR="build"
  local DIST_DIR="dist"
  local PREFIX="${SITE}-${GIT_REF}"
  dirs "${BUILD_DIR}" "${DIST_DIR}"
  echo doing git archive
  git archive --format=tar --prefix="${PREFIX}/" "${GIT_REF}" | \
    #extract that archive into a temporary build directory
    "${TAR}" --directory "${BUILD_DIR}" --extract
  #install node
  NODE_VERSION=$(./bin/jsonpath.coffee engines.node)
  echo installing node
  install_node "${NODE_VERSION}" "${BUILD_DIR}/${PREFIX}/node"
  #Note we use npm from the build platform (OS X) here instead of
  #the one for the run platform as they are incompatible
  echo install npm packages
  (cd "${BUILD_DIR}/${PREFIX}" && npm install --silent --production)
  echo creating archive
  "${TAR}" --directory "${BUILD_DIR}" --create --bzip2 --file "${DIST_DIR}/${PREFIX}.tar.bz2" .
}
Community
  • 1
  • 1
Peter Lyons
  • 142,938
  • 30
  • 279
  • 274
  • Indeed! Thanks a ton. I might actually use the npm link option just so the repo can be live and users can continue to pull the updated program, which will automagically be symlinked. But I certainly do like to know that my original idea is possible. Thanks! – netpoetica May 31 '13 at 15:43
0

Add a file to the ./bin folder

$ cd myproject
$ mkdir bin

bin/my_bin_file:

#!/usr/bin/env node
require('../main_file.js');

Add a "bin" option to your package.json:

"bin": {
    "my_bin_file": "./bin/my_bin_file"
}

Make it executable

$ chmod +x bin/my_bin_file

Install globally:

npm install -g

EDIT: npm can install your package globally to the system without it being public, and there is a shebang in the bin file that tells the system how to invoke it (no need to call node on the cli explicitly)

furydevoid
  • 1,391
  • 8
  • 7
  • Ahh... I tried with "npm link" but it made a symlink to the repo. Both of these solutions aren't any good because I do not want to have the user do any of these things. I want them to be able to curl my program into their /bin directory and start using it right away. – netpoetica May 31 '13 at 14:52
  • Do everything except "npm install -g". Then you can write a small shell script that just downloads your package and runs npm install -g. As far as I'm aware, there isn't another way to package them single-binary style. Everything except 'npm install -g' is a one-time thing on your end. – furydevoid May 31 '13 at 21:28