shelljs - :shell: Portable Unix shell commands for Node.js

  •        38

If you have feedback, suggestions, or need help, feel free to post in our issue tracker.Upgrading from an older version? Check out our breaking changes page to see what changes to watch out for while upgrading.

http://github.com/shelljs/shelljs
https://github.com/shelljs/shelljs

Dependencies:

glob : ^7.0.0
interpret : ^1.0.0
rechoir : ^0.6.2

Tags
Implementation
License
Platform

   




Related Projects

shx - Portable Shell Commands for Node

  •    Javascript

shx is a wrapper around ShellJS Unix commands, providing an easy solution for simple Unix-like, cross-platform commands in npm package scripts.This will allow using shx in your package.json scripts.

cash - Cross-platform Linux commands in ES6

  •    Javascript

Cash is a cross-platform implementation of Unix shell commands written in straight ES6. No native compiling and no external dependencies.While young, Cash aims to offer an alternative Linux feel on Windows and to open the door to cross-platform bash scripting in a Javascript environment.

shelljs - Portable Unix shell commands for Node.js

  •    Javascript

Portable Unix shell commands for Node.js

browsix - Browsix is a Unix-like operating system for the browser.

  •    Javascript

While standard operating systems like Unix make it relatively simple to build complex applications, web browsers lack the features that make this possible. This project is Browsix, a JavaScript-only framework that brings the essence of Unix to the browser. Browsix makes core Unix features available to web applications (including pipes, processes, signals, sockets, and a shared file system) and extends JavaScript runtimes for C, C++, Go, and Node.js programs so they can run in a Unix-like environment within the browser. Browsix also provides a POSIX-like shell that makes it easy to compose applications together for parallel data processing via pipes. For more details, check out our tech report (PDF).

stream-handbook - how to write node programs with streams

  •    Javascript

Now you will have a stream-handbook command that will open this readme file in your $PAGER. Otherwise, you may continue reading this document as you are presently doing.Streams come to us from the earliest days of unix and have proven themselves over the decades as a dependable way to compose large systems out of small components that do one thing well. In unix, streams are implemented by the shell with | pipes. In node, the built-in stream module is used by the core libraries and can also be used by user-space modules. Similar to unix, the node stream module's primary composition operator is called .pipe() and you get a backpressure mechanism for free to throttle writes for slow consumers.


gitlab-shell - Replacement for gitolite

  •    Ruby

GitLab Shell handles git commands for GitLab and modifies the list of authorized keys. GitLab Shell is not a Unix shell nor a replacement for Bash or Zsh. Maybe you wonder why in the case of git push over http(s) the Rails app doesn't handle authentication before delegating to GitLab Shell. This is because GitLab Rails doesn't have the logic to interpret git push commands. The idea is to have these interpretation code in only one place and this is GitLab Shell so we can reuse it for ssh access. Actually GitLab Shell executes all git push commands without checking authorizations and relies on the pre-receive hooks to check authorizations. When you do a git pull command the authorizations are checked before executing the commands (either in GitLab Rails or GitLab Shell with an API call to GitLab Rails). The authorization checks for git pull are much simpler since you only have to check if a user can access the repo (no need to check branch permissions).

closh - Bash-like shell based on Clojure

  •    Clojure

Closh combines the best of traditional unix shells with the power of Clojure. It aims to be a modern alternative to bash. Warning: Closh is still in a early stage and under a heavy development. It is not ready for daily use yet since it is quite easy to get it to crash. At this moment I am most interested in gathering feedback and use cases to help make the best possible design trade-offs. Closh is tested on Linux, should run on macOS too. Windows who knows.

oh - A surprisingly powerful Unix shell

  •    Go

Oh is a Unix shell. If you've used other Unix shells, oh should feel familiar. Where oh diverges from traditional Unix shells is in its programming language features.

pwd.sh - Unix shell, GPG-based password manager

  •    Shell

Script to manage passwords in an encrypted file using gpg. New! Purse is a fork which uses public key authentication instead of a master passphrase and can integrate with YubiKey.

Shell based Unix utilities

  •    

This project is a library of shell functions emulating the common and not-so-common Unix utilities. No external compiled binaries are referenced from these functions, all code is entirely shell based, using built-in shell commands.

Cygwin - Get that Linux feeling on Windows

  •    C

Cygwin is a collection of tools which provide a Linux look and feel environment for Windows. It is a DLL (cygwin1.dll) which acts as a Linux API layer providing substantial Linux API functionality. The Cygwin tools are ports of the popular GNU development tools for Microsoft Windows. They can be used from one of the provided Unix shells like bash, tcsh or zsh.

replacing-bash-scripting-with-python - Guide on using using python for administrative scripting

  •    

The Unix shell is one of my favorite inventions ever. It's genius, plain and simple. The idea is that the user environment is a Turing-complete, declarative programming language. It has a dead-simple model for dealing with I/O and concurrency, which are notoriously difficult in most other languages. For problems where the data can be expressed as a stream of similar objects separated by newlines to be processed concurrently through a series of filters and handles a lot of I/O, it's difficult to think of a more ideal language than the shell. A lot of the core parts on a Unix or Linux system is designed to express data in such formats.

consh

  •    Shell

Consh, short for quot;concurrent shell,quot; is a decentralized distributed system service for collections of UNIX hosts that augments a user's favorite UNIX shell with commands that allow for easy-to-understand multi-threaded and distributed shell scripting.

cicada - A simple Unix shell written in Rust

  •    Rust

Cicada is a simple Unix shell written in Rust. It's ready for daily use. Please refer to docs/install.md.

Gow - Unix command line utilities installer for Windows.

  •    VB

Gow (Gnu On Windows) is the lightweight alternative to Cygwin. It uses a convenient Windows installer that installs about 130 extremely useful open source UNIX applications compiled as native win32 binaries. It is designed to be as small as possible, about 10 MB, as opposed to Cygwin which can run well over 100 MB depending upon options.

ztanesh - Improve your UNIX command line experience and productivity with ztanesh project: the tools will make your shell more powerful and easier to use

  •    Shell

Improve your UNIX command line experience and productivity with the the configuration provided by ztanesh project: the tools will make your shell more powerful and easier to use.The screenshot above shows additional ls coloring. Prompt: top left is active virtualenv etc. development environment, top right is server, time, bottom right is path.

shell-novice - Software Carpentry introduction to the shell for novices.

  •    Python

An introduction to the Unix shell for people who have never used the command line before. Please see https://swcarpentry.github.io/shell-novice/ for a rendered version of this material, the lesson template documentation for instructions on formatting, building, and submitting material, or run make in this directory for a list of helpful commands.

dotfiles - custom linux config files - managed via gnu stow

  •    Shell

in the unix world programs are commonly configured in two different ways, via shell arguments or text based configuration files. programs with many options like window managers or text editors are configured on a per-user basis with files in your home directory ~. in unix like operating systems any file or directory name that starts with a period or full stop character is considered hidden, and in a default view will not be displayed. thus the name dotfiles. "you are your dotfiles".

makeself - A self-extracting archiving tool for Unix systems, in 100% shell script.

  •    Shell

makeself.sh is a small shell script that generates a self-extractable compressed tar archive from a directory. The resulting file appears as a shell script (many of those have a .run suffix), and can be launched as is. The archive will then uncompress itself to a temporary directory and an optional arbitrary command will be executed (for example an installation script). This is pretty similar to archives generated with WinZip Self-Extractor in the Windows world. Makeself archives also include checksums for integrity self-validation (CRC and/or MD5/SHA256 checksums). The makeself.sh script itself is used only to create the archives from a directory of files. The resultant archive is actually a compressed (using gzip, bzip2, or compress) TAR archive, with a small shell script stub at the beginning. This small stub performs all the steps of extracting the files, running the embedded command, and removing the temporary files when done. All the user has to do to install the software contained in such an archive is to "run" the archive, i.e sh nice-software.run. I recommend using the ".run" (which was introduced by some Makeself archives released by Loki Software) or ".sh" suffix for such archives not to confuse the users, so that they will know they are actually shell scripts (with quite a lot of binary data attached to them though!).

ucr-cs100 - open source software construction course

  •    C++

Hacking is a mindset. I can't force it on you---it's up to you to embrace it. For example, we'll be discussing many new tools in this course: a version control system called git, an editor called vim, debugging tools called gdb, valgrind, and cppcheck, and we'll be going into quite a bit more depth on how to use the bash shell and the Linux operating system. All of these tools are very weird. Using them will make you uncomfortable. At first. But these tools are powerful. Mastering these tools will make you a much more efficient programmer. Once you've mastered them, you'll never go back. Your first four homework assignments walk you through the process of building your own unix shell. This is the biggest project you've undertaken so far. You'll be developing it as an open source project, and you will collaborate with each other at various points.