Borrow implementations from OpenSSH-portable:

https://github.com/openssh/openssh-portable/blob/master/openbsd-compat/md5.c
https://github.com/openssh/openssh-portable/blob/master/openbsd-compat/sha1.c
https://github.com/openssh/openssh-portable/blob/master/openbsd-compat/sha2.c

In preparation for child process support. Probably leave os.pipe out, since it will be used for IPC.

Initial functions:

• low level fd i/o
• cwd
• isatty
• pipe
• abort

We will need a way to cleanly exit the interpreter instead of just doing exit. Probably use an exception SJSExit, VMExit or SystemExit to signal this, then capture it, run atexit handlers and call exit(code).

Some sources for inspiration:

• https://docs.python.org/3.6/library/subprocess.html#subprocess.run
• https://docs.python.org/3.6/library/subprocess.html#popen-constructor
• https://nodejs.org/api/child_process.html

Base:

• os.fork
• os.execve
• os.waitpid
• os.getpid
• os.getppid
• os.dup
• os.chdir
• os.setsid

Process module:

• process.daemonize
• process.spawn

Right now we run them one after the other, but the original source code is no longer needed after we compile it to JavaScript, so we can free it.

This means that we also do more work before we actually run the code, so it might not be beneficial.

Possible exception is time.sleep. Also investigate the implications on select and poll.

https://github.com/fatcerberus/minisphere/blob/master/src/engine/commonjs.c

https://github.com/davepacheco/node-getopt
https://github.com/nodeca/argparse
https://github.com/ringo/ringojs/blob/master/modules/ringo/args.js
https://github.com/yargs/yargs
https://github.com/substack/minimist
https://github.com/tj/commander.js

Small enough library to embed for UI stuff, maybe. Sample Node bindings: https://github.com/parro-it/libui-node

I recently switched from Mersenne Twister (MT19937) to xoroshiro128+ for random number generation in minisphere. It's about 4 times as fast as MT, generates 64-bit unsigned integers, is higher quality (i.e. passes more randomness tests), and is in the public domain. It's the successor to the xorshift128+ algorithm currently used by SpiderMonkey and V8:

• xoroshiro128+ http://xoroshiro.di.unimi.it/

The implementation I wrote for minisphere allows creating multiple generator instances as well as saving and restoring the state of the generator. Since the state is only 128-bit it can be represented as a single 32-character hex string that you can write to a file and read back later. MT19937 has nearly 2.5KB of state making it a bit unwieldy.

Here's my implementation if you want to look at it:

• https://github.com/fatcerberus/minisphere/blob/master/src/shared/xoroshiro.c

Some "binadata" module, analogous to https://docs.python.org/2/library/struct.html or http://docs.ruby-lang.org/en/2.0.0/Array.html#method-i-pack

Example:

foo/
foo/bar.c
foo.js

Right now we try to load foo/index.js and give up. Fallback to trying foo.js.

Make it a normal module which is built on top of a __system builtin.

Most fs functions will be in os anyway, so fs becomes a misnomer.

I want it to be set to the absolute path when installing, so installing to non-default locations works without setting LD_LIBRARY_PATH.

Have a look at mbed TLS

A normalize function for unicode normalization.

https://github.com/walling/unorm

We should set the udata field in duk_create_heap, and then use http://duktape.org/api.html#duk_get_memory_functions to get the pointer back.

Something like sjs_vm_get_vm(duk_context* ctx)

Steal this, to begin with https://github.com/svaarala/duktape/blob/master/examples/cmdline/duk_cmdline.c#L343

https://github.com/inexorabletash/text-encoding

A non-cryptographically safe random helper thingy.

TBD: base it on Math.random (Duktape's implementation here) or something else (Mersene Twister I guess?).

References:
https://docs.python.org/3.6/library/random.html
http://ruby-doc.org/stdlib-2.1.2/libdoc/securerandom/rdoc/SecureRandom.html
https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues
https://github.com/ckknight/random-js
http://ruby-doc.org/core-2.2.0/Random.html
https://github.com/MersenneTwister-Lab/TinyMT
https://github.com/dajobe/libmtwist
https://github.com/cslarsen/mersenne-twister
https://github.com/ruby/ruby/blob/trunk/random.c

svaarala/duktape#772

A wrapper around these:

int getpwnam_r(const char *name, struct passwd *pwd,
            char *buf, size_t buflen, struct passwd **result);

int getpwuid_r(uid_t uid, struct passwd *pwd,
            char *buf, size_t buflen, struct passwd **result);

Also:

os.getuid / geteuid: http://man7.org/linux/man-pages/man2/getuid.2.html
os.setuid: http://man7.org/linux/man-pages/man2/setuid.2.html
os.setgid http://man7.org/linux/man-pages/man2/setgid.2.html

Then use these to add support for uid / gid in process.spawn.

Ideally we'd use objectutil.inspect, but since we are in C and in order to avoid extra dependencies, JSON will do.

This only applies to systems which actually use /dev/urandom.

The idea is to open the fd once, store it in sjs_vm_t and keep it around. Every time we need to read from it do a fstat and check the inode still matches. (This trick is what CPython does)

http://wiki.duktape.org/Configuring.html

We are not ia very constrained environment, so we can turn some on.

The initial version should contain:

• File object for reading / writing and so on
• unlink
• stat
• scandir

• epoll
• kqueue
• selectors (wrapper using the best one on each platform)

Investigate introducing builtin transpilers. It would work with a command line flag, which loads the code into the transpiler:

sjs --transpiler=babel code.js

Transpilers: babel and typescript.

Reference: https://github.com/amol-/dukpy

Since the shebang always needs to be the first line, we can probably get away with it by replacing the first two characters (assuming they are #!) with //. This way we don't alter the line count.

• read name and print hello name
• echo server (non-blocking)
• mini-netcat
• C module
• JS module

Adapt https://github.com/broofa/node-uuid/blob/master/uuid.js

This is exactly what I wanted to build, without knowing it beforehand.

http://ringojs.org/documentation/commonjs_implementation/
https://github.com/ringo/ringojs
https://github.com/olegp/common-node

• Console
• System/1.0
• Filesystem/A
• Sockets/A
• IO/A
• Binary/B ?
• Encodings/A ?

https://github.com/zloirock/core-js

It has more features: Promise, Symbol, etc.

Probably just wrap glob(3)

Not sure how to handle dynamic modules though, what would they link with? The CLI? The embedding application?

On Linux we can create a socket in non-blocking mode in a single syscall by OR-ing the socket type with SOCK_NONBLOCK. Same applies when using accept4. Use it.