--- a/CMakeLists.txt	Wed Oct 05 13:27:15 2016 +0200
+++ b/CMakeLists.txt	Wed Oct 05 20:32:27 2016 +0200
@@ -80,7 +80,11 @@
 add_subdirectory(doc)
 add_subdirectory(libcommon)
 add_subdirectory(libirccd)
-#add_subdirectory(lib)
+
+if (WITH_JS)
+    add_subdirectory(libirccd-js)
+endif ()
+
 #add_subdirectory(irccd)
 #add_subdirectory(irccdctl)
 #add_subdirectory(contrib)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/CMakeLists.txt	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,48 @@
+project(libirccd-js)
+
+set(
+    HEADERS
+    ${libirccd-js_SOURCE_DIR}/irccd/duktape.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-directory.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-elapsed-timer.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-file.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-irccd.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-logger.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-plugin.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-server.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-system.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-timer.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/module.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-unicode.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-util.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/plugin-js.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/timer.hpp
+    ${libirccd-js_SOURCE_DIR}/irccd/unicode.hpp
+)
+
+set(
+    SOURCES
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-directory.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-elapsed-timer.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-file.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-irccd.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-logger.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-plugin.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-server.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-system.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-timer.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-unicode.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/mod-util.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/plugin-js.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/timer.cpp
+    ${libirccd-js_SOURCE_DIR}/irccd/unicode.cpp
+)
+
+irccd_define_library(
+    TARGET libirccd-js
+    SOURCES
+        ${libirccd-js_SOURCE_DIR}/CMakeLists.txt
+        ${HEADERS}
+        ${SOURCES}
+    LIBRARIES extern-duktape libirccd
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/duktape.hpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,484 @@
+/*
+ * duktape.hpp -- Duktape extras
+ *
+ * Copyright (c) 2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef IRCCD_DUKTAPE_HPP
+#define IRCCD_DUKTAPE_HPP
+
+/**
+ * \file duktape.hpp
+ * \brief Bring some extras to Duktape C library.
+ * \author David Demelier <markand@malikania.fr>
+ */
+
+#include <cstdio>
+#include <cstdlib>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <duktape.h>
+
+namespace irccd {
+
+/**
+ * \class StackAssert
+ * \brief Stack sanity checker.
+ *
+ * Instanciate this class where you need to manipulate the Duktape stack outside a Duktape/C function, its destructor
+ * will examinate if the stack size matches the user expected size.
+ *
+ * When compiled with NDEBUG, this class does nothing.
+ *
+ * To use it, just declare an lvalue at the beginning of your function.
+ */
+class StackAssert {
+#if !defined(NDEBUG)
+private:
+    duk_context *m_context;
+    unsigned m_expected;
+    unsigned m_begin;
+#endif
+
+public:
+    /**
+     * Create the stack checker.
+     *
+     * No-op if NDEBUG is set.
+     *
+     * \param ctx the context
+     * \param expected the size expected relative to the already existing values
+     */
+    inline StackAssert(duk_context *ctx, unsigned expected = 0) noexcept
+#if !defined(NDEBUG)
+        : m_context(ctx)
+        , m_expected(expected)
+        , m_begin(static_cast<unsigned>(duk_get_top(ctx)))
+#endif
+    {
+#if defined(NDEBUG)
+        (void)ctx;
+        (void)expected;
+#endif
+    }
+
+    /**
+     * Verify the expected size.
+     *
+     * No-op if NDEBUG is set.
+     */
+    inline ~StackAssert() noexcept
+    {
+#if !defined(NDEBUG)
+        if (static_cast<unsigned>(duk_get_top(m_context)) - m_begin != m_expected) {
+            std::fprintf(stderr, "Corrupt stack detection in StackAssert:\n");
+            std::fprintf(stderr, "  Size at start:            %u\n", m_begin);
+            std::fprintf(stderr, "  Size at end:              %d\n", duk_get_top(m_context));
+            std::fprintf(stderr, "  Expected (user):          %u\n", m_expected);
+            std::fprintf(stderr, "  Expected (adjusted):      %u\n", m_expected + m_begin);
+            std::fprintf(stderr, "  Number of stale values:   %u\n", duk_get_top(m_context) - m_begin - m_expected);
+            std::abort();
+        }
+#endif
+    }
+};
+
+/**
+ * \class Exception
+ * \brief Error description.
+ *
+ * This class fills the fields got in an Error object.
+ */
+class Exception : public std::exception {
+public:
+    std::string name;        //!< name of error
+    std::string message;        //!< error message
+    std::string stack;        //!< stack if available
+    std::string fileName;        //!< filename if applicable
+    int lineNumber{0};        //!< line number if applicable
+
+    /**
+     * Get the error message. This effectively returns message field.
+     *
+     * \return the message
+     */
+    const char *what() const noexcept override
+    {
+        return message.c_str();
+    }
+};
+
+/**
+ * \brief RAII based Duktape handler.
+ *
+ * This class is implicitly convertible to duk_context for convenience.
+ */
+class UniqueContext {
+private:
+    using Deleter = void (*)(duk_context *);
+    using Handle = std::unique_ptr<duk_context, Deleter>;
+
+    Handle m_handle;
+
+    UniqueContext(const UniqueContext &) = delete;
+    UniqueContext &operator=(const UniqueContext &) = delete;
+
+public:
+    /**
+     * Create default context.
+     */
+    inline UniqueContext()
+        : m_handle(duk_create_heap_default(), duk_destroy_heap)
+    {
+    }
+
+    /**
+     * Default move constructor.
+     */
+    UniqueContext(UniqueContext &&) noexcept = default;
+
+    /**
+     * Convert the context to the native Duktape/C type.
+     *
+     * \return the duk_context
+     */
+    inline operator duk_context *() noexcept
+    {
+        return m_handle.get();
+    }
+
+    /**
+     * Convert the context to the native Duktape/C type.
+     *
+     * \return the duk_context
+     */
+    inline operator duk_context *() const noexcept
+    {
+        return m_handle.get();
+    }
+
+    /**
+     * Default move assignment operator.
+     *
+     * \return this
+     */
+    UniqueContext &operator=(UniqueContext &&) noexcept = delete;
+};
+
+/**
+ * \class Error
+ * \brief Base ECMAScript error class.
+ * \warning Override the function create for your own exceptions
+ */
+class Error {
+private:
+    int m_type{DUK_ERR_ERROR};
+    std::string m_message;
+
+protected:
+    /**
+     * Constructor with a type of error specified, specially designed for derived errors.
+     *
+     * \param type of error (e.g. DUK_ERR_ERROR)
+     * \param message the message
+     */
+    inline Error(int type, std::string message) noexcept
+        : m_type(type)
+        , m_message(std::move(message))
+    {
+    }
+
+public:
+    /**
+     * Constructor with a message.
+     *
+     * \param message the message
+     */
+    inline Error(std::string message) noexcept
+        : m_message(std::move(message))
+    {
+    }
+
+    /**
+     * Create the exception on the stack.
+     *
+     * \note the default implementation search for the global variables
+     * \param ctx the context
+     */
+    virtual void raise(duk_context *ctx) const
+    {
+        duk_error(ctx, m_type, "%s", m_message.c_str());
+    }
+};
+
+/**
+ * \class EvalError
+ * \brief Error in eval() function.
+ */
+class EvalError : public Error {
+public:
+    /**
+     * Construct an EvalError.
+     *
+     * \param message the message
+     */
+    inline EvalError(std::string message) noexcept
+        : Error(DUK_ERR_EVAL_ERROR, std::move(message))
+    {
+    }
+};
+
+/**
+ * \class RangeError
+ * \brief Value is out of range.
+ */
+class RangeError : public Error {
+public:
+    /**
+     * Construct an RangeError.
+     *
+     * \param message the message
+     */
+    inline RangeError(std::string message) noexcept
+        : Error(DUK_ERR_RANGE_ERROR, std::move(message))
+    {
+    }
+};
+
+/**
+ * \class ReferenceError
+ * \brief Trying to use a variable that does not exist.
+ */
+class ReferenceError : public Error {
+public:
+    /**
+     * Construct an ReferenceError.
+     *
+     * \param message the message
+     */
+    inline ReferenceError(std::string message) noexcept
+        : Error(DUK_ERR_REFERENCE_ERROR, std::move(message))
+    {
+    }
+};
+
+/**
+ * \class SyntaxError
+ * \brief Syntax error in the script.
+ */
+class SyntaxError : public Error {
+public:
+    /**
+     * Construct an SyntaxError.
+     *
+     * \param message the message
+     */
+    inline SyntaxError(std::string message) noexcept
+        : Error(DUK_ERR_SYNTAX_ERROR, std::move(message))
+    {
+    }
+};
+
+/**
+ * \class TypeError
+ * \brief Invalid type given.
+ */
+class TypeError : public Error {
+public:
+    /**
+     * Construct an TypeError.
+     *
+     * \param message the message
+     */
+    inline TypeError(std::string message) noexcept
+        : Error(DUK_ERR_TYPE_ERROR, std::move(message))
+    {
+    }
+};
+
+/**
+ * \class URIError
+ * \brief URI manipulation failure.
+ */
+class URIError : public Error {
+public:
+    /**
+     * Construct an URIError.
+     *
+     * \param message the message
+     */
+    inline URIError(std::string message) noexcept
+        : Error(DUK_ERR_URI_ERROR, std::move(message))
+    {
+    }
+};
+
+/**
+ * Get the error object when a JavaScript error has been thrown (e.g. eval failure).
+ *
+ * \param ctx the context
+ * \param index the index
+ * \param pop if true, also remove the exception from the stack
+ * \return the information
+ */
+inline Exception dukx_exception(duk_context *ctx, int index, bool pop = true)
+{
+    Exception ex;
+
+    index = duk_normalize_index(ctx, index);
+
+    duk_get_prop_string(ctx, index, "name");
+    ex.name = duk_to_string(ctx, -1);
+    duk_get_prop_string(ctx, index, "message");
+    ex.message = duk_to_string(ctx, -1);
+    duk_get_prop_string(ctx, index, "fileName");
+    ex.fileName = duk_to_string(ctx, -1);
+    duk_get_prop_string(ctx, index, "lineNumber");
+    ex.lineNumber = duk_to_int(ctx, -1);
+    duk_get_prop_string(ctx, index, "stack");
+    ex.stack = duk_to_string(ctx, -1);
+    duk_pop_n(ctx, 5);
+
+    if (pop)
+        duk_remove(ctx, index);
+
+    return ex;
+}
+
+/**
+ * Enumerate an object or an array at the specified index.
+ *
+ * \param ctx the context
+ * \param index the object or array index
+ * \param flags the optional flags to pass to duk_enum
+ * \param getvalue set to true if you want to extract the value
+ * \param func the function to call for each properties
+ */
+template <typename Func>
+void dukx_enumerate(duk_context *ctx, int index, duk_uint_t flags, duk_bool_t getvalue, Func &&func)
+{
+    duk_enum(ctx, index, flags);
+
+    while (duk_next(ctx, -1, getvalue)) {
+        func(ctx);
+        duk_pop_n(ctx, 1 + (getvalue ? 1 : 0));
+    }
+
+    duk_pop(ctx);
+}
+
+/**
+ * Throw an ECMAScript exception.
+ *
+ * \param ctx the context
+ * \param ex the exception
+ */
+template <typename Exception>
+void dukx_throw(duk_context *ctx, const Exception &ex)
+{
+    ex.raise(ctx);
+}
+
+/**
+ * Get a string, return 0 if not a string.
+ *
+ * \param ctx the context
+ * \param index the index
+ * \return the string
+ */
+inline std::string dukx_get_std_string(duk_context *ctx, int index)
+{
+    duk_size_t size;
+    const char *text = duk_get_lstring(ctx, index, &size);
+
+    return std::string(text, size);
+}
+
+/**
+ * Require a string, throws a JavaScript exception if not a string.
+ *
+ * \param ctx the context
+ * \param index the index
+ * \return the string
+ */
+inline std::string dukx_require_std_string(duk_context *ctx, int index)
+{
+    duk_size_t size;
+    const char *text = duk_require_lstring(ctx, index, &size);
+
+    return std::string(text, size);
+}
+
+/**
+ * Push a C++ string.
+ *
+ * \param ctx the context
+ * \param str the string
+ */
+inline void dukx_push_std_string(duk_context *ctx, const std::string &str)
+{
+    duk_push_lstring(ctx, str.data(), str.length());
+}
+
+/**
+ * Get an array.
+ *
+ * \param ctx the context
+ * \param index the array index
+ * \param get the conversion function (e.g. duk_get_int)
+ */
+template <typename Getter>
+auto dukx_get_array(duk_context *ctx, duk_idx_t index, Getter &&get)
+{
+    using T = decltype(get(ctx, 0));
+
+    std::vector<T> result;
+    std::size_t length = duk_get_length(ctx, index);
+
+    for (std::size_t i = 0; i < length; ++i) {
+        duk_get_prop_index(ctx, -1, i);
+        result.push_back(get(ctx, -1));
+        duk_pop(ctx);
+    }
+
+    return result;
+}
+
+/**
+ * Push an array.
+ *
+ * \param ctx the context
+ * \param values the values
+ * \param push the function to push values
+ */
+template <typename T, typename Pusher>
+void dukx_push_array(duk_context *ctx, const std::vector<T> &values, Pusher &&push)
+{
+    duk_push_array(ctx);
+
+    int i = 0;
+    for (auto x : values) {
+        push(ctx, x);
+        duk_put_prop_index(ctx, -2, i++);
+    }
+}
+
+} // !irccd
+
+#endif // !IRCCD_DUKTAPE_HPP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-directory.cpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,391 @@
+/*
+ * js-directory.cpp -- Irccd.Directory API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <regex>
+#include <stdexcept>
+#include <string>
+
+#include "duktape.hpp"
+#include "fs.hpp"
+#include "mod-directory.hpp"
+#include "mod-irccd.hpp"
+#include "path.hpp"
+#include "plugin-js.hpp"
+#include "sysconfig.hpp"
+
+namespace irccd {
+
+namespace {
+
+std::string path(duk_context *ctx)
+{
+    duk_push_this(ctx);
+    duk_get_prop_string(ctx, -1, "path");
+
+    if (duk_get_type(ctx, -1) != DUK_TYPE_STRING)
+        duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Directory object");
+
+    auto ret = dukx_get_std_string(ctx, -1);
+
+    if (ret.empty())
+        duk_error(ctx, DUK_ERR_TYPE_ERROR, "directory object has empty path");
+
+    duk_pop_n(ctx, 2);
+
+    return ret;
+}
+
+/*
+ * Find an entry recursively (or not) in a directory using a predicate which can
+ * be used to test for regular expression, equality.
+ *
+ * Do not use this function directly, use:
+ *
+ * - findName
+ * - findRegex
+ */
+template <typename Pred>
+std::string findPath(const std::string &base, bool recursive, Pred pred)
+{
+    /*
+     * For performance reason, we first iterate over all entries that are
+     * not directories to avoid going deeper recursively if the requested
+     * file is in the current directory.
+     */
+    auto entries = fs::readdir(base);
+
+    for (const auto &entry : entries)
+        if (entry.type != fs::Entry::Dir && pred(entry.name))
+            return base + entry.name;
+
+    if (!recursive)
+        return "";
+
+    for (const auto &entry : entries) {
+        if (entry.type == fs::Entry::Dir) {
+            std::string next = base + entry.name + fs::separator();
+            std::string path = findPath(next, true, pred);
+
+            if (!path.empty())
+                return path;
+        }
+    }
+
+    return "";
+}
+
+/*
+ * Helper for finding by equality.
+ */
+std::string findName(std::string base, const std::string &pattern, bool recursive)
+{
+    return findPath(base, recursive, [&] (const std::string &entryname) -> bool {
+        return pattern == entryname;
+    });
+}
+
+/*
+ * Helper for finding by regular expression
+ */
+std::string findRegex(const std::string &base, std::string pattern, bool recursive)
+{
+    std::regex regexp(pattern, std::regex::ECMAScript);
+    std::smatch smatch;
+
+    return findPath(base, recursive, [&] (const std::string &entryname) -> bool {
+        return std::regex_match(entryname, smatch, regexp);
+    });
+}
+
+/*
+ * Generic find function for:
+ *
+ * - Directory.find
+ * - Directory.prototype.find
+ *
+ * The patternIndex is the argument where to test if the argument is a regex or
+ * a string.
+ */
+duk_ret_t find(duk_context *ctx, std::string base, bool recursive, int patternIndex)
+{
+    base = path::clean(base);
+
+    try {
+        std::string path;
+
+        if (duk_is_string(ctx, patternIndex))
+            path = findName(base, duk_get_string(ctx, patternIndex), recursive);
+        else {
+            // Check if it's a valid RegExp object.
+            duk_get_global_string(ctx, "RegExp");
+            auto isRegex = duk_instanceof(ctx, patternIndex, -1);
+            duk_pop(ctx);
+
+            if (isRegex) {
+                duk_get_prop_string(ctx, patternIndex, "source");
+                auto pattern = duk_to_string(ctx, -1);
+                duk_pop(ctx);
+
+                path = findRegex(base, pattern, recursive);
+            } else
+                duk_error(ctx, DUK_ERR_TYPE_ERROR, "pattern must be a string or a regex expression");
+        }
+
+        if (path.empty())
+            return 0;
+
+        dukx_push_std_string(ctx, path);
+    } catch (const std::exception &ex) {
+        duk_error(ctx, DUK_ERR_ERROR, "%s", ex.what());
+    }
+
+    return 1;
+}
+
+/*
+ * Generic remove function for:
+ *
+ * - Directory.remove
+ * - Directory.prototype.remove
+ */
+duk_ret_t remove(duk_context *ctx, const std::string &path, bool recursive)
+{
+    if (!fs::isDirectory(path))
+        dukx_throw(ctx, SystemError(EINVAL, "not a directory"));
+
+    if (!recursive) {
+#if defined(_WIN32)
+        ::RemoveDirectory(path.c_str());
+#else
+        ::remove(path.c_str());
+#endif
+    } else
+        fs::rmdir(path.c_str());
+
+    return 0;
+}
+
+/*
+ * Method: Directory.find(pattern, recursive)
+ * --------------------------------------------------------
+ *
+ * Synonym of Directory.find(path, pattern, recursive) but the path is taken
+ * from the directory object.
+ *
+ * Arguments:
+ *   - pattern, the regular expression or file name,
+ *   - recursive, set to true to search recursively (default: false).
+ * Returns:
+ *   The path to the file or undefined if not found.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t methodFind(duk_context *ctx)
+{
+    return find(ctx, path(ctx), duk_get_boolean(ctx, 1), 0);
+}
+
+/*
+ * Method: Directory.remove(recursive)
+ * --------------------------------------------------------
+ *
+ * Synonym of Directory.remove(recursive) but the path is taken from the
+ * directory object.
+ *
+ * Arguments:
+ *   - recursive, recursively or not (default: false).
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t methodRemove(duk_context *ctx)
+{
+    return remove(ctx, path(ctx), duk_get_boolean(ctx, 0));
+}
+
+const duk_function_list_entry methods[] = {
+    { "find",       methodFind,     DUK_VARARGS },
+    { "remove",     methodRemove,   1           },
+    { nullptr,      nullptr,        0           }
+};
+
+/*
+ * Directory "static" functions
+ * ------------------------------------------------------------------
+ */
+
+/*
+ * Function: Irccd.Directory(path, flags) [constructor]
+ * --------------------------------------------------------
+ *
+ * Opens and read the directory at the specified path.
+ *
+ * Arguments:
+ *   - path, the path to the directory,
+ *   - flags, the optional flags (default: 0).
+ * Throws:
+ *   - Any exception on error
+ */
+duk_ret_t constructor(duk_context *ctx)
+{
+    if (!duk_is_constructor_call(ctx))
+        return 0;
+
+    try {
+        std::string path = duk_require_string(ctx, 0);
+        std::int8_t flags = duk_get_uint(ctx, 1);
+
+        if (!fs::isDirectory(path))
+            dukx_throw(ctx, SystemError(EINVAL, "not a directory"));
+
+        std::vector<fs::Entry> list = fs::readdir(path, flags);
+
+        duk_push_this(ctx);
+        duk_push_string(ctx, "count");
+        duk_push_int(ctx, list.size());
+        duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE);
+        duk_push_string(ctx, "path");
+        dukx_push_std_string(ctx, path);
+        duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE);
+        duk_push_string(ctx, "entries");
+        duk_push_array(ctx);
+
+        for (unsigned i = 0; i < list.size(); ++i) {
+            duk_push_object(ctx);
+            dukx_push_std_string(ctx, list[i].name);
+            duk_put_prop_string(ctx, -2, "name");
+            duk_push_int(ctx, list[i].type);
+            duk_put_prop_string(ctx, -2, "type");
+            duk_put_prop_index(ctx, -2, i);
+        }
+
+        duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE);
+    } catch (const std::exception &ex) {
+        dukx_throw(ctx, SystemError(errno, ex.what()));
+    }
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.Directory.find(path, pattern, recursive)
+ * --------------------------------------------------------
+ *
+ * Find an entry by a pattern or a regular expression.
+ *
+ * Arguments:
+ *   - path, the base path,
+ *   - pattern, the regular expression or file name,
+ *   - recursive, set to true to search recursively (default: false).
+ * Returns:
+ *   The path to the file or undefined on errors or not found.
+ */
+duk_ret_t funcFind(duk_context *ctx)
+{
+    return find(ctx, duk_require_string(ctx, 0), duk_get_boolean(ctx, 2), 1);
+}
+
+/*
+ * Function: Irccd.Directory.remove(path, recursive)
+ * --------------------------------------------------------
+ *
+ * Remove the directory optionally recursively.
+ *
+ * Arguments:
+ *   - path, the path to the directory,
+ *   - recursive, recursively or not (default: false).
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t funcRemove(duk_context *ctx)
+{
+    return remove(ctx, duk_require_string(ctx, 0), duk_get_boolean(ctx, 1));
+}
+
+/*
+ * Function: Irccd.Directory.mkdir(path, mode = 0700)
+ * --------------------------------------------------------
+ *
+ * Create a directory specified by path. It will create needed subdirectories
+ * just like you have invoked mkdir -p.
+ *
+ * Arguments:
+ *   - path, the path to the directory,
+ *   - mode, the mode, not available on all platforms.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t funcMkdir(duk_context *ctx)
+{
+    try {
+        fs::mkdir(
+            duk_require_string(ctx, 0),
+            duk_is_number(ctx, 1) ? duk_get_int(ctx, 1) : 0700
+        );
+    } catch (const std::exception &ex) {
+        dukx_throw(ctx, SystemError(errno, ex.what()));
+    }
+
+    return 0;
+}
+
+const duk_function_list_entry functions[] = {
+    { "find",           funcFind,   DUK_VARARGS },
+    { "mkdir",          funcMkdir,  DUK_VARARGS },
+    { "remove",         funcRemove, DUK_VARARGS },
+    { nullptr,          nullptr,    0           }
+};
+
+const duk_number_list_entry constants[] = {
+    { "Dot",            static_cast<int>(fs::Dot)               },
+    { "DotDot",         static_cast<int>(fs::DotDot)            },
+    { "TypeUnknown",    static_cast<int>(fs::Entry::Unknown)    },
+    { "TypeDir",        static_cast<int>(fs::Entry::Dir)        },
+    { "TypeFile",       static_cast<int>(fs::Entry::File)       },
+    { "TypeLink",       static_cast<int>(fs::Entry::Link)       },
+    { nullptr,          0                                       }
+};
+
+} // !namespace
+
+DirectoryModule::DirectoryModule() noexcept
+    : Module("Irccd.Directory")
+{
+}
+
+void DirectoryModule::load(Irccd &, const std::shared_ptr<JsPlugin> &plugin)
+{
+    StackAssert sa(plugin->context());
+
+    duk_get_global_string(plugin->context(), "Irccd");
+    duk_push_c_function(plugin->context(), constructor, 2);
+    duk_put_number_list(plugin->context(), -1, constants);
+    duk_put_function_list(plugin->context(), -1, functions);
+    dukx_push_std_string(plugin->context(), std::string{fs::separator()});
+    duk_put_prop_string(plugin->context(), -2, "separator");
+    duk_push_object(plugin->context());
+    duk_put_function_list(plugin->context(), -1, methods);
+    duk_put_prop_string(plugin->context(), -2, "prototype");
+    duk_put_prop_string(plugin->context(), -2, "Directory");
+    duk_pop(plugin->context());
+}
+
+} // !irccd

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-directory.hpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,50 @@
+/*
+ * mod-directory.hpp -- Irccd.Directory API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef IRCCD_MOD_DIRECTORY_HPP
+#define IRCCD_MOD_DIRECTORY_HPP
+
+/**
+ * \file mod-directory.hpp
+ * \brief Irccd.Directory JavaScript API.
+ */
+
+#include "module.hpp"
+
+namespace irccd {
+
+/**
+ * \brief Irccd.Directory JavaScript API.
+ * \ingroup modules
+ */
+class DirectoryModule : public Module {
+public:
+    /**
+     * Irccd.Directory.
+     */
+    IRCCD_EXPORT DirectoryModule() noexcept;
+
+    /**
+     * \copydoc Module::load
+     */
+    IRCCD_EXPORT void load(Irccd &irccd, const std::shared_ptr<JsPlugin> &plugin) override;
+};
+
+} // !irccd
+
+#endif // !IRCCD_MOD_DIRECTORY_HPP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-elapsed-timer.cpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,161 @@
+/*
+ * js-elapsed-timer.cpp -- Irccd.ElapsedTimer API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "elapsed-timer.hpp"
+#include "mod-elapsed-timer.hpp"
+#include "plugin-js.hpp"
+
+namespace irccd {
+
+namespace {
+
+const char *Signature("\xff""\xff""irccd-elapsed-timer-ptr");
+
+ElapsedTimer *self(duk_context *ctx)
+{
+    StackAssert sa(ctx);
+
+    duk_push_this(ctx);
+    duk_get_prop_string(ctx, -1, Signature);
+    auto ptr = static_cast<ElapsedTimer *>(duk_to_pointer(ctx, -1));
+    duk_pop_2(ctx);
+
+    if (!ptr)
+        duk_error(ctx, DUK_ERR_TYPE_ERROR, "not an ElapsedTimer object");
+
+    return ptr;
+}
+
+/*
+ * Method: ElapsedTimer.pause
+ * ------------------------------------------------------------------
+ *
+ * Pause the timer, without resetting the current elapsed time stored.
+ */
+duk_ret_t pause(duk_context *ctx)
+{
+    self(ctx)->pause();
+
+    return 0;
+}
+
+/*
+ * Method: ElapsedTimer.reset
+ * ------------------------------------------------------------------
+ *
+ * Reset the elapsed time to 0, the status is not modified.
+ */
+duk_ret_t reset(duk_context *ctx)
+{
+    self(ctx)->reset();
+
+    return 0;
+}
+
+/*
+ * Method: ElapsedTimer.restart
+ * ------------------------------------------------------------------
+ *
+ * Restart the timer without resetting the current elapsed time.
+ */
+duk_ret_t restart(duk_context *ctx)
+{
+    self(ctx)->restart();
+
+    return 0;
+}
+
+/*
+ * Method: ElapsedTimer.elapsed
+ * ------------------------------------------------------------------
+ *
+ * Get the number of elapsed milliseconds.
+ *
+ * Returns:
+ *   The time elapsed.
+ */
+duk_ret_t elapsed(duk_context *ctx)
+{
+    duk_push_uint(ctx, self(ctx)->elapsed());
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.ElapsedTimer() [constructor]
+ * ------------------------------------------------------------------
+ *
+ * Construct a new ElapsedTimer object.
+ */
+duk_ret_t constructor(duk_context *ctx)
+{
+    duk_push_this(ctx);
+    duk_push_pointer(ctx, new ElapsedTimer);
+    duk_put_prop_string(ctx, -2, Signature);
+    duk_pop(ctx);
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.ElapsedTimer() [destructor]
+ * ------------------------------------------------------------------
+ *
+ * Delete the property.
+ */
+duk_ret_t destructor(duk_context *ctx)
+{
+    duk_get_prop_string(ctx, 0, Signature);
+    delete static_cast<ElapsedTimer *>(duk_to_pointer(ctx, -1));
+    duk_pop(ctx);
+    duk_del_prop_string(ctx, 0, Signature);
+
+    return 0;
+}
+
+const duk_function_list_entry methods[] = {
+    { "elapsed",    elapsed,    0 },
+    { "pause",      pause,      0 },
+    { "reset",      reset,      0 },
+    { "restart",    restart,    0 },
+    { nullptr,      nullptr,    0 }
+};
+
+} // !namespace
+
+ElapsedTimerModule::ElapsedTimerModule() noexcept
+    : Module("Irccd.ElapsedTimer")
+{
+}
+
+void ElapsedTimerModule::load(Irccd &, const std::shared_ptr<JsPlugin> &plugin)
+{
+    StackAssert sa(plugin->context());
+
+    duk_get_global_string(plugin->context(), "Irccd");
+    duk_push_c_function(plugin->context(), constructor, 0);
+    duk_push_object(plugin->context());
+    duk_put_function_list(plugin->context(), -1, methods);
+    duk_push_c_function(plugin->context(), destructor, 1);
+    duk_set_finalizer(plugin->context(), -2);
+    duk_put_prop_string(plugin->context(), -2, "prototype");
+    duk_put_prop_string(plugin->context(), -2, "ElapsedTimer");
+    duk_pop(plugin->context());
+}
+
+} // !irccd

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-elapsed-timer.hpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,50 @@
+/*
+ * mod-elapsed-timer.hpp -- Irccd.ElapsedTimer API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef IRCCD_MOD_ELAPSED_TIMER_HPP
+#define IRCCD_MOD_ELAPSED_TIMER_HPP
+
+/**
+ * \file mod-elapsed-timer.hpp
+ * \brief Irccd.ElapsedTimer JavaScript API.
+ */
+
+#include "module.hpp"
+
+namespace irccd {
+
+/**
+ * \brief Irccd.ElapsedTimer JavaScript API.
+ * \ingroup modules
+ */
+class ElapsedTimerModule : public Module {
+public:
+    /**
+     * Irccd.ElapsedTimer.
+     */
+    IRCCD_EXPORT ElapsedTimerModule() noexcept;
+
+    /**
+     * \copydoc Module::load
+     */
+    IRCCD_EXPORT void load(Irccd &irccd, const std::shared_ptr<JsPlugin> &plugin) override;
+};
+
+} // !irccd
+
+#endif // !IRCCD_MOD_ELAPSED_TIMER_HPP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-file.cpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,693 @@
+/*
+ * js-file.cpp -- Irccd.File API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <iterator>
+#include <vector>
+
+#include "sysconfig.hpp"
+
+#if defined(HAVE_STAT)
+#  include <sys/types.h>
+#  include <sys/stat.h>
+#endif
+
+#include "fs.hpp"
+#include "mod-file.hpp"
+#include "mod-irccd.hpp"
+#include "plugin-js.hpp"
+
+namespace irccd {
+
+namespace {
+
+const char *Signature("\xff""\xff""irccd-file-ptr");
+const char *Prototype("\xff""\xff""irccd-file-prototype");
+
+#if defined(HAVE_STAT)
+
+/*
+ * pushStat
+ * ------------------------------------------------------------------
+ */
+
+void pushStat(duk_context *ctx, const struct stat &st)
+{
+    StackAssert sa(ctx, 1);
+
+    duk_push_object(ctx);
+
+#if defined(HAVE_STAT_ST_ATIME)
+    duk_push_int(ctx, st.st_atime);
+    duk_put_prop_string(ctx, -2, "atime");
+#endif
+#if defined(HAVE_STAT_ST_BLKSIZE)
+    duk_push_int(ctx, st.st_blksize);
+    duk_put_prop_string(ctx, -2, "blksize");
+#endif
+#if defined(HAVE_STAT_ST_BLOCKS)
+    duk_push_int(ctx, st.st_blocks);
+    duk_put_prop_string(ctx, -2, "blocks");
+#endif
+#if defined(HAVE_STAT_ST_CTIME)
+    duk_push_int(ctx, st.st_ctime);
+    duk_put_prop_string(ctx, -2, "ctime");
+#endif
+#if defined(HAVE_STAT_ST_DEV)
+    duk_push_int(ctx, st.st_dev);
+    duk_put_prop_string(ctx, -2, "dev");
+#endif
+#if defined(HAVE_STAT_ST_GID)
+    duk_push_int(ctx, st.st_gid);
+    duk_put_prop_string(ctx, -2, "gid");
+#endif
+#if defined(HAVE_STAT_ST_INO)
+    duk_push_int(ctx, st.st_ino);
+    duk_put_prop_string(ctx, -2, "ino");
+#endif
+#if defined(HAVE_STAT_ST_MODE)
+    duk_push_int(ctx, st.st_mode);
+    duk_put_prop_string(ctx, -2, "mode");
+#endif
+#if defined(HAVE_STAT_ST_MTIME)
+    duk_push_int(ctx, st.st_mtime);
+    duk_put_prop_string(ctx, -2, "mtime");
+#endif
+#if defined(HAVE_STAT_ST_NLINK)
+    duk_push_int(ctx, st.st_nlink);
+    duk_put_prop_string(ctx, -2, "nlink");
+#endif
+#if defined(HAVE_STAT_ST_RDEV)
+    duk_push_int(ctx, st.st_rdev);
+    duk_put_prop_string(ctx, -2, "rdev");
+#endif
+#if defined(HAVE_STAT_ST_SIZE)
+    duk_push_int(ctx, st.st_size);
+    duk_put_prop_string(ctx, -2, "size");
+#endif
+#if defined(HAVE_STAT_ST_UID)
+    duk_push_int(ctx, st.st_uid);
+    duk_put_prop_string(ctx, -2, "uid");
+#endif
+}
+
+#endif // !HAVE_STAT
+
+// Remove trailing \r for CRLF line style.
+inline std::string clearCr(std::string input)
+{
+    if (input.length() > 0 && input.back() == '\r')
+        input.pop_back();
+
+    return input;
+}
+
+File *self(duk_context *ctx)
+{
+    StackAssert sa(ctx);
+
+    duk_push_this(ctx);
+    duk_get_prop_string(ctx, -1, Signature);
+    auto ptr = static_cast<File *>(duk_to_pointer(ctx, -1));
+    duk_pop_2(ctx);
+
+    if (!ptr)
+        duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a File object");
+
+    return ptr;
+}
+
+/*
+ * File methods.
+ * ------------------------------------------------------------------
+ */
+
+/*
+ * Method: File.basename()
+ * --------------------------------------------------------
+ *
+ * Synonym of `Irccd.File.basename(path)` but with the path from the file.
+ *
+ * duk_ret_turns:
+ *   The base name.
+ */
+duk_ret_t methodBasename(duk_context *ctx)
+{
+    dukx_push_std_string(ctx, fs::baseName(self(ctx)->path()));
+
+    return 1;
+}
+
+/*
+ * Method: File.close()
+ * --------------------------------------------------------
+ *
+ * Force close of the file, automatically called when object is collected.
+ */
+duk_ret_t methodClose(duk_context *ctx)
+{
+    self(ctx)->close();
+
+    return 0;
+}
+
+/*
+ * Method: File.dirname()
+ * --------------------------------------------------------
+ *
+ * Synonym of `Irccd.File.dirname(path)` but with the path from the file.
+ *
+ * duk_ret_turns:
+ *   The directory name.
+ */
+duk_ret_t methodDirname(duk_context *ctx)
+{
+    dukx_push_std_string(ctx, fs::dirName(self(ctx)->path()));
+
+    return 1;
+}
+
+/*
+ * Method: File.lines()
+ * --------------------------------------------------------
+ *
+ * Read all lines and return an array.
+ *
+ * duk_ret_turns:
+ *   An array with all lines.
+ * Throws
+ *   - Any exception on error.
+ */
+duk_ret_t methodLines(duk_context *ctx)
+{
+    duk_push_array(ctx);
+
+    std::FILE *fp = self(ctx)->handle();
+    std::string buffer;
+    std::array<char, 128> data;
+    std::int32_t i = 0;
+
+    while (std::fgets(&data[0], data.size(), fp) != nullptr) {
+        buffer += data.data();
+
+        auto pos = buffer.find('\n');
+
+        if (pos != std::string::npos) {
+            dukx_push_std_string(ctx, clearCr(buffer.substr(0, pos)));
+            duk_put_prop_index(ctx, -2, i++);
+
+            buffer.erase(0, pos + 1);
+        }
+    }
+
+    // Maybe an error in the stream.
+    if (std::ferror(fp))
+        dukx_throw(ctx, SystemError());
+
+    // Missing '\n' in end of file.
+    if (!buffer.empty()) {
+        dukx_push_std_string(ctx, clearCr(buffer));
+        duk_put_prop_index(ctx, -2, i++);
+    }
+
+    return 1;
+}
+
+/*
+ * Method: File.read(amount)
+ * --------------------------------------------------------
+ *
+ * Read the specified amount of characters or the whole file.
+ *
+ * Arguments:
+ *   - amount, the amount of characters or -1 to read all (Optional, default: -1).
+ * duk_ret_turns:
+ *   The string.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t methodRead(duk_context *ctx)
+{
+    auto file = self(ctx);
+    auto amount = duk_is_number(ctx, 0) ? duk_get_int(ctx, 0) : -1;
+
+    if (amount == 0 || file->handle() == nullptr)
+        return 0;
+
+    try {
+        std::string data;
+        std::size_t total = 0;
+
+        if (amount < 0) {
+            std::array<char, 128> buffer;
+            std::size_t nread;
+
+            while ((nread = std::fread(&buffer[0], sizeof (buffer[0]), buffer.size(), file->handle())) > 0) {
+                if (std::ferror(file->handle()))
+                    dukx_throw(ctx, SystemError());
+
+                std::copy(buffer.begin(), buffer.begin() + nread, std::back_inserter(data));
+                total += nread;
+            }
+        } else {
+            data.resize((std::size_t)amount);
+            total = std::fread(&data[0], sizeof (data[0]), (std::size_t)amount, file->handle());
+
+            if (std::ferror(file->handle()))
+                dukx_throw(ctx, SystemError());
+
+            data.resize(total);
+        }
+
+        dukx_push_std_string(ctx, data);
+    } catch (const std::exception &) {
+        dukx_throw(ctx, SystemError());
+    }
+
+    return 1;
+}
+
+/*
+ * Method: File.readline()
+ * --------------------------------------------------------
+ *
+ * Read the next line available.
+ *
+ * duk_ret_turns:
+ *   The next line or undefined if eof.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t methodReadline(duk_context *ctx)
+{
+    std::FILE *fp = self(ctx)->handle();
+    std::string result;
+
+    if (fp == nullptr || std::feof(fp))
+        return 0;
+    for (int ch; (ch = std::fgetc(fp)) != EOF && ch != '\n'; )
+        result += (char)ch;
+    if (std::ferror(fp))
+        dukx_throw(ctx, SystemError());
+
+    dukx_push_std_string(ctx, clearCr(result));
+
+    return 1;
+}
+
+/*
+ * Method: File.remove()
+ * --------------------------------------------------------
+ *
+ * Synonym of File.remove(path) but with the path from the file.
+ *
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t methodRemove(duk_context *ctx)
+{
+    if (::remove(self(ctx)->path().c_str()) < 0)
+        dukx_throw(ctx, SystemError());
+
+    return 0;
+}
+
+/*
+ * Method: File.seek(type, amount)
+ * --------------------------------------------------------
+ *
+ * Sets the position in the file.
+ *
+ * Arguments:
+ *   - type, the type of setting (File.SeekSet, File.SeekCur, File.SeekSet),
+ *   - amount, the new offset.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t methodSeek(duk_context *ctx)
+{
+    auto fp = self(ctx)->handle();
+    auto type = duk_require_int(ctx, 0);
+    auto amount = duk_require_int(ctx, 1);
+
+    if (fp != nullptr && std::fseek(fp, amount, type) != 0)
+        dukx_throw(ctx, SystemError());
+
+    return 0;
+}
+
+#if defined(HAVE_STAT)
+
+/*
+ * Method: File.stat() [optional]
+ * --------------------------------------------------------
+ *
+ * Synonym of File.stat(path) but with the path from the file.
+ *
+ * duk_ret_turns:
+ *   The stat information.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t methodStat(duk_context *ctx)
+{
+    auto file = self(ctx);
+    struct stat st;
+
+    if (file->handle() == nullptr && ::stat(file->path().c_str(), &st) < 0)
+        dukx_throw(ctx, SystemError());
+    else
+        pushStat(ctx, st);
+
+    return 1;
+}
+
+#endif // !HAVE_STAT
+
+/*
+ * Method: File.tell()
+ * --------------------------------------------------------
+ *
+ * Get the actual position in the file.
+ *
+ * duk_ret_turns:
+ *   The position.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t methodTell(duk_context *ctx)
+{
+    auto fp = self(ctx)->handle();
+    long pos;
+
+    if (fp == nullptr)
+        return 0;
+
+    if ((pos = std::ftell(fp)) == -1L)
+        dukx_throw(ctx, SystemError());
+    else
+        duk_push_int(ctx, pos);
+
+    return 1;
+}
+
+/*
+ * Method: File.write(data)
+ * --------------------------------------------------------
+ *
+ * Write some characters to the file.
+ *
+ * Arguments:
+ *   - data, the character to write.
+ * duk_ret_turns:
+ *   The number of bytes written.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t methodWrite(duk_context *ctx)
+{
+    std::FILE *fp = self(ctx)->handle();
+    std::string data = duk_require_string(ctx, 0);
+
+    if (fp == nullptr)
+        return 0;
+
+    std::size_t nwritten = std::fwrite(data.c_str(), 1, data.length(), fp);
+
+    if (std::ferror(fp))
+        dukx_throw(ctx, SystemError());
+
+    duk_push_uint(ctx, nwritten);
+
+    return 1;
+}
+
+const duk_function_list_entry methods[] = {
+    { "basename",   methodBasename, 0 },
+    { "close",      methodClose,    0 },
+    { "dirname",    methodDirname,  0 },
+    { "lines",      methodLines,    0 },
+    { "read",       methodRead,     1 },
+    { "readline",   methodReadline, 0 },
+    { "remove",     methodRemove,   0 },
+    { "seek",       methodSeek,     2 },
+#if defined(HAVE_STAT)
+    { "stat",       methodStat,     0 },
+#endif
+    { "tell",       methodTell,     0 },
+    { "write",      methodWrite,    1 },
+    { nullptr,      nullptr,        0 }
+};
+
+/*
+ * File "static" functions
+ * ------------------------------------------------------------------
+ */
+
+/*
+ * Function: Irccd.File(path, mode) [constructor]
+ * --------------------------------------------------------
+ *
+ * Open a file specified by path with the specified mode.
+ *
+ * Arguments:
+ *   - path, the path to the file,
+ *   - mode, the mode string.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t constructor(duk_context *ctx)
+{
+    if (!duk_is_constructor_call(ctx))
+        return 0;
+
+    try {
+        dukx_new_file(ctx, new File(duk_require_string(ctx, 0), duk_require_string(ctx, 1)));
+    } catch (const std::exception &) {
+        dukx_throw(ctx, SystemError());
+    }
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.File() [destructor]
+ * ------------------------------------------------------------------
+ *
+ * Delete the property.
+ */
+duk_ret_t destructor(duk_context *ctx)
+{
+    duk_get_prop_string(ctx, 0, Signature);
+    delete static_cast<File *>(duk_to_pointer(ctx, -1));
+    duk_pop(ctx);
+    duk_del_prop_string(ctx, 0, Signature);
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.File.basename(path)
+ * --------------------------------------------------------
+ *
+ * duk_ret_turn the file basename as specified in `basename(3)` C function.
+ *
+ * Arguments:
+ *   - path, the path to the file.
+ * duk_ret_turns:
+ *   The base name.
+ */
+duk_ret_t functionBasename(duk_context *ctx)
+{
+    dukx_push_std_string(ctx, fs::baseName(duk_require_string(ctx, 0)));
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.File.dirname(path)
+ * --------------------------------------------------------
+ *
+ * duk_ret_turn the file directory name as specified in `dirname(3)` C function.
+ *
+ * Arguments:
+ *   - path, the path to the file.
+ * duk_ret_turns:
+ *   The directory name.
+ */
+duk_ret_t functionDirname(duk_context *ctx)
+{
+    dukx_push_std_string(ctx, fs::dirName(duk_require_string(ctx, 0)));
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.File.exists(path)
+ * --------------------------------------------------------
+ *
+ * Check if the file exists.
+ *
+ * Arguments:
+ *   - path, the path to the file.
+ * duk_ret_turns:
+ *   True if exists.
+ * Throws:
+ *   - Any exception if we don't have access.
+ */
+duk_ret_t functionExists(duk_context *ctx)
+{
+    duk_push_boolean(ctx, fs::exists(duk_require_string(ctx, 0)));
+
+    return 1;
+}
+
+/*
+ * function Irccd.File.remove(path)
+ * --------------------------------------------------------
+ *
+ * Remove the file at the specified path.
+ *
+ * Arguments:
+ *   - path, the path to the file.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t functionRemove(duk_context *ctx)
+{
+    if (::remove(duk_require_string(ctx, 0)) < 0)
+        dukx_throw(ctx, SystemError());
+
+    return 0;
+}
+
+#if defined(HAVE_STAT)
+
+/*
+ * function Irccd.File.stat(path) [optional]
+ * --------------------------------------------------------
+ *
+ * Get file information at the specified path.
+ *
+ * Arguments:
+ *   - path, the path to the file.
+ * duk_ret_turns:
+ *   The stat information.
+ * Throws:
+ *   - Any exception on error.
+ */
+duk_ret_t functionStat(duk_context *ctx)
+{
+    struct stat st;
+
+    if (::stat(duk_require_string(ctx, 0), &st) < 0)
+        dukx_throw(ctx, SystemError());
+
+    pushStat(ctx, st);
+
+    return 1;
+}
+
+#endif // !HAVE_STAT
+
+const duk_function_list_entry functions[] = {
+    { "basename",   functionBasename,   1 },
+    { "dirname",    functionDirname,    1 },
+    { "exists",     functionExists,     1 },
+    { "remove",     functionRemove,     1 },
+#if defined(HAVE_STAT)
+    { "stat",       functionStat,       1 },
+#endif
+    { nullptr,      nullptr,            0 }
+};
+
+const duk_number_list_entry constants[] = {
+    { "SeekCur",    SEEK_CUR },
+    { "SeekEnd",    SEEK_END },
+    { "SeekSet",    SEEK_SET },
+    { nullptr,      0        }
+};
+
+} // !namespace
+
+FileModule::FileModule() noexcept
+    : Module("Irccd.File")
+{
+}
+
+void FileModule::load(Irccd &, const std::shared_ptr<JsPlugin> &plugin)
+{
+    StackAssert sa(plugin->context());
+
+    duk_get_global_string(plugin->context(), "Irccd");
+    duk_push_c_function(plugin->context(), constructor, 2);
+    duk_put_number_list(plugin->context(), -1, constants);
+    duk_put_function_list(plugin->context(), -1, functions);
+    duk_push_object(plugin->context());
+    duk_put_function_list(plugin->context(), -1, methods);
+    duk_push_c_function(plugin->context(), destructor, 1);
+    duk_set_finalizer(plugin->context(), -2);
+    duk_dup(plugin->context(), -1);
+    duk_put_global_string(plugin->context(), Prototype);
+    duk_put_prop_string(plugin->context(), -2, "prototype");
+    duk_put_prop_string(plugin->context(), -2, "File");
+    duk_pop(plugin->context());
+}
+
+void dukx_new_file(duk_context *ctx, File *fp)
+{
+    assert(ctx);
+    assert(fp);
+
+    StackAssert sa(ctx);
+
+    duk_push_this(ctx);
+    duk_push_pointer(ctx, fp);
+    duk_put_prop_string(ctx, -2, Signature);
+    duk_pop(ctx);
+}
+
+void dukx_push_file(duk_context *ctx, File *fp)
+{
+    assert(ctx);
+    assert(fp);
+
+    StackAssert sa(ctx, 1);
+
+    duk_push_object(ctx);
+    duk_push_pointer(ctx, fp);
+    duk_put_prop_string(ctx, -2, Signature);
+    duk_get_global_string(ctx, Prototype);
+    duk_set_prototype(ctx, -2);
+}
+
+File *dukx_require_file(duk_context *ctx, duk_idx_t index)
+{
+    if (!duk_is_object(ctx, index) || !duk_has_prop_string(ctx, index, Signature))
+        duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a File object");
+
+    duk_get_prop_string(ctx, index, Signature);
+    File *file = static_cast<File *>(duk_to_pointer(ctx, -1));
+    duk_pop(ctx);
+
+    return file;
+}
+
+} // !irccd

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-file.hpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,185 @@
+/*
+ * mod-file.hpp -- Irccd.File API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef IRCCD_MOD_FILE_HPP
+#define IRCCD_MOD_FILE_HPP
+
+/**
+ * \file mod-file.hpp
+ * \brief Irccd.File JavaScript API.
+ */
+
+#include <cassert>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <functional>
+#include <stdexcept>
+#include <string>
+
+#include "duktape.hpp"
+#include "module.hpp"
+
+namespace irccd {
+
+/**
+ * \class File
+ * \brief Object for Javascript to perform I/O.
+ *
+ * This class can be constructed to Javascript.
+ *
+ * It is used in:
+ *
+ * - Irccd.File [constructor]
+ * - Irccd.System.popen (optional)
+ */
+class File {
+private:
+    File(const File &) = delete;
+    File &operator=(const File &) = delete;
+
+    File(File &&) = delete;
+    File &operator=(File &&) = delete;
+
+private:
+    std::string m_path;
+    std::FILE *m_stream;
+    std::function<void (std::FILE *)> m_destructor;
+
+public:
+    /**
+     * Construct a file specified by path
+     *
+     * \param path the path
+     * \param mode the mode string (for std::fopen)
+     * \throw std::runtime_error on failures
+     */
+    inline File(std::string path, const std::string &mode)
+        : m_path(std::move(path))
+        , m_destructor([] (std::FILE *fp) { std::fclose(fp); })
+    {
+        if ((m_stream = std::fopen(m_path.c_str(), mode.c_str())) == nullptr)
+            throw std::runtime_error(std::strerror(errno));
+    }
+
+    /**
+     * Construct a file from a already created FILE pointer (e.g. popen).
+     *
+     * The class takes ownership of fp and will close it.
+     *
+     * \pre destructor must not be null
+     * \param fp the file pointer
+     * \param destructor the function to close fp (e.g. std::fclose)
+     */
+    inline File(std::FILE *fp, std::function<void (std::FILE *)> destructor) noexcept
+        : m_stream(fp)
+        , m_destructor(std::move(destructor))
+    {
+        assert(m_destructor != nullptr);
+    }
+
+    /**
+     * Closes the file.
+     */
+    virtual ~File() noexcept
+    {
+        close();
+    }
+
+    /**
+     * Get the path.
+     *
+     * \return the path
+     * \warning empty when constructed from the FILE constructor
+     */
+    inline const std::string &path() const noexcept
+    {
+        return m_path;
+    }
+
+    /**
+     * Get the handle.
+     *
+     * \return the handle or nullptr if the stream was closed
+     */
+    inline std::FILE *handle() noexcept
+    {
+        return m_stream;
+    }
+
+    /**
+     * Force close, can be safely called multiple times.
+     */
+    inline void close() noexcept
+    {
+        if (m_stream) {
+            m_destructor(m_stream);
+            m_stream = nullptr;
+        }
+    }
+};
+
+/**
+ * \brief Irccd.File JavaScript API.
+ * \ingroup modules
+ */
+class FileModule : public Module {
+public:
+    /**
+     * Irccd.File.
+     */
+    IRCCD_EXPORT FileModule() noexcept;
+
+    /**
+     * \copydoc Module::load
+     */
+    IRCCD_EXPORT void load(Irccd &irccd, const std::shared_ptr<JsPlugin> &plugin) override;
+};
+
+/**
+ * Construct the file as this.
+ *
+ * The object prototype takes ownership of fp and will be deleted once
+ * collected.
+ *
+ * \pre fp != nullptr
+ * \param ctx the the context
+ * \param fp the file
+ */
+IRCCD_EXPORT void dukx_new_file(duk_context *ctx, File *fp);
+
+/**
+ * Push a file.
+ *
+ * \pre fp != nullptr
+ * \param ctx the the context
+ * \param fp the file
+ */
+IRCCD_EXPORT void dukx_push_file(duk_context *ctx, File *fp);
+
+/**
+ * Require a file. Raises a JavaScript error if not a File.
+ *
+ * \param ctx the context
+ * \param index the index
+ */
+IRCCD_EXPORT File *dukx_require_file(duk_context *ctx, duk_idx_t index);
+
+} // !irccd
+
+#endif // !IRCCD_MOD_FILE_HPP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-irccd.cpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,211 @@
+/*
+ * js-irccd.cpp -- Irccd API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <cerrno>
+#include <string>
+#include <unordered_map>
+
+#include "mod-irccd.hpp"
+#include "plugin-js.hpp"
+#include "sysconfig.hpp"
+
+namespace irccd {
+
+namespace {
+
+const std::unordered_map<std::string, int> errors{
+    { "E2BIG",              E2BIG           },
+    { "EACCES",             EACCES          },
+    { "EADDRINUSE",         EADDRINUSE      },
+    { "EADDRNOTAVAIL",      EADDRNOTAVAIL   },
+    { "EAFNOSUPPORT",       EAFNOSUPPORT    },
+    { "EAGAIN",             EAGAIN          },
+    { "EALREADY",           EALREADY        },
+    { "EBADF",              EBADF           },
+    { "EBADMSG",            EBADMSG         },
+    { "EBUSY",              EBUSY           },
+    { "ECANCELED",          ECANCELED       },
+    { "ECHILD",             ECHILD          },
+    { "ECONNABORTED",       ECONNABORTED    },
+    { "ECONNREFUSED",       ECONNREFUSED    },
+    { "ECONNRESET",         ECONNRESET      },
+    { "EDEADLK",            EDEADLK         },
+    { "EDESTADDRREQ",       EDESTADDRREQ    },
+    { "EDOM",               EDOM            },
+    { "EEXIST",             EEXIST          },
+    { "EFAULT",             EFAULT          },
+    { "EFBIG",              EFBIG           },
+    { "EHOSTUNREACH",       EHOSTUNREACH    },
+    { "EIDRM",              EIDRM           },
+    { "EILSEQ",             EILSEQ          },
+    { "EINPROGRESS",        EINPROGRESS     },
+    { "EINTR",              EINTR           },
+    { "EINVAL",             EINVAL          },
+    { "EIO",                EIO             },
+    { "EISCONN",            EISCONN         },
+    { "EISDIR",             EISDIR          },
+    { "ELOOP",              ELOOP           },
+    { "EMFILE",             EMFILE          },
+    { "EMLINK",             EMLINK          },
+    { "EMSGSIZE",           EMSGSIZE        },
+    { "ENAMETOOLONG",       ENAMETOOLONG    },
+    { "ENETDOWN",           ENETDOWN        },
+    { "ENETRESET",          ENETRESET       },
+    { "ENETUNREACH",        ENETUNREACH     },
+    { "ENFILE",             ENFILE          },
+    { "ENOBUFS",            ENOBUFS         },
+    { "ENODATA",            ENODATA         },
+    { "ENODEV",             ENODEV          },
+    { "ENOENT",             ENOENT          },
+    { "ENOEXEC",            ENOEXEC         },
+    { "ENOLCK",             ENOLCK          },
+    { "ENOLINK",            ENOLINK         },
+    { "ENOMEM",             ENOMEM          },
+    { "ENOMSG",             ENOMSG          },
+    { "ENOPROTOOPT",        ENOPROTOOPT     },
+    { "ENOSPC",             ENOSPC          },
+    { "ENOSR",              ENOSR           },
+    { "ENOSTR",             ENOSTR          },
+    { "ENOSYS",             ENOSYS          },
+    { "ENOTCONN",           ENOTCONN        },
+    { "ENOTDIR",            ENOTDIR         },
+    { "ENOTEMPTY",          ENOTEMPTY       },
+    { "ENOTRECOVERABLE",    ENOTRECOVERABLE },
+    { "ENOTSOCK",           ENOTSOCK        },
+    { "ENOTSUP",            ENOTSUP         },
+    { "ENOTTY",             ENOTTY          },
+    { "ENXIO",              ENXIO           },
+    { "EOPNOTSUPP",         EOPNOTSUPP      },
+    { "EOVERFLOW",          EOVERFLOW       },
+    { "EOWNERDEAD",         EOWNERDEAD      },
+    { "EPERM",              EPERM           },
+    { "EPIPE",              EPIPE           },
+    { "EPROTO",             EPROTO          },
+    { "EPROTONOSUPPORT",    EPROTONOSUPPORT },
+    { "EPROTOTYPE",         EPROTOTYPE      },
+    { "ERANGE",             ERANGE          },
+    { "EROFS",              EROFS           },
+    { "ESPIPE",             ESPIPE          },
+    { "ESRCH",              ESRCH           },
+    { "ETIME",              ETIME           },
+    { "ETIMEDOUT",          ETIMEDOUT       },
+    { "ETXTBSY",            ETXTBSY         },
+    { "EWOULDBLOCK",        EWOULDBLOCK     },
+    { "EXDEV",              EXDEV           }
+};
+
+duk_ret_t constructor(duk_context *ctx)
+{
+    duk_push_this(ctx);
+    duk_push_int(ctx, duk_require_int(ctx, 0));
+    duk_put_prop_string(ctx, -2, "errno");
+    duk_push_string(ctx, duk_require_string(ctx, 1));
+    duk_put_prop_string(ctx, -2, "message");
+    duk_push_string(ctx, "SystemError");
+    duk_put_prop_string(ctx, -2, "name");
+    duk_pop(ctx);
+
+    return 0;
+}
+
+} // !namespace
+
+SystemError::SystemError()
+    : m_errno(errno)
+    , m_message(std::strerror(m_errno))
+{
+}
+
+SystemError::SystemError(int e, std::string message)
+    : m_errno(e)
+    , m_message(std::move(message))
+{
+}
+
+void SystemError::raise(duk_context *ctx) const
+{
+    StackAssert sa(ctx, 0);
+
+    duk_get_global_string(ctx, "Irccd");
+    duk_get_prop_string(ctx, -1, "SystemError");
+    duk_remove(ctx, -2);
+    duk_push_int(ctx, m_errno);
+    dukx_push_std_string(ctx, m_message);
+    duk_new(ctx, 2);
+    duk_throw(ctx);
+}
+
+IrccdModule::IrccdModule() noexcept
+    : Module("Irccd")
+{
+}
+
+void IrccdModule::load(Irccd &irccd, const std::shared_ptr<JsPlugin> &plugin)
+{
+    StackAssert sa(plugin->context());
+
+    // Irccd.
+    duk_push_object(plugin->context());
+
+    // Version.
+    duk_push_object(plugin->context());
+    duk_push_int(plugin->context(), IRCCD_VERSION_MAJOR);
+    duk_put_prop_string(plugin->context(), -2, "major");
+    duk_push_int(plugin->context(), IRCCD_VERSION_MINOR);
+    duk_put_prop_string(plugin->context(), -2, "minor");
+    duk_push_int(plugin->context(), IRCCD_VERSION_PATCH);
+    duk_put_prop_string(plugin->context(), -2, "patch");
+    duk_put_prop_string(plugin->context(), -2, "version");
+
+    // Create the SystemError that inherits from Error.
+    duk_push_c_function(plugin->context(), constructor, 2);
+
+    // Put errno codes into the Irccd.SystemError object.
+    for (const auto &pair : errors) {
+        duk_push_int(plugin->context(), pair.second);
+        duk_put_prop_string(plugin->context(), -2, pair.first.c_str());
+    }
+
+    duk_push_object(plugin->context());
+    duk_get_global_string(plugin->context(), "Error");
+    duk_get_prop_string(plugin->context(), -1, "prototype");
+    duk_remove(plugin->context(), -2);
+    duk_set_prototype(plugin->context(), -2);
+    duk_put_prop_string(plugin->context(), -2, "prototype");
+    duk_put_prop_string(plugin->context(), -2, "SystemError");
+
+    // Set Irccd as global.
+    duk_put_global_string(plugin->context(), "Irccd");
+
+    // Store global instance.
+    duk_push_pointer(plugin->context(), &irccd);
+    duk_put_global_string(plugin->context(), "\xff""\xff""irccd-ref");
+}
+
+Irccd &dukx_get_irccd(duk_context *ctx)
+{
+    StackAssert sa(ctx);
+
+    duk_get_global_string(ctx, "\xff""\xff""irccd-ref");
+    Irccd *irccd = static_cast<Irccd *>(duk_to_pointer(ctx, -1));
+    duk_pop(ctx);
+
+    return *irccd;
+}
+
+} // !irccd

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-irccd.hpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,93 @@
+/*
+ * mod-irccd.hpp -- Irccd API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef IRCCD_MOD_IRCCD_HPP
+#define IRCCD_MOD_IRCCD_HPP
+
+/**
+ * \file mod-irccd.hpp
+ * \brief Irccd JavaScript API.
+ */
+
+#include <cerrno>
+#include <cstring>
+#include <string>
+
+#include "duktape.hpp"
+#include "module.hpp"
+
+namespace irccd {
+
+/**
+ * \brief Custom JavaScript exception for system error.
+ */
+class SystemError {
+private:
+    int m_errno;
+    std::string m_message;
+
+public:
+    /**
+     * Create a system error from the current errno value.
+     */
+    IRCCD_EXPORT SystemError();
+
+    /**
+     * Create a system error with the given errno and message.
+     *
+     * \param e the errno number
+     * \param message the message
+     */
+    IRCCD_EXPORT SystemError(int e, std::string message);
+
+    /**
+     * Raise the SystemError.
+     *
+     * \param ctx the context
+     */
+    IRCCD_EXPORT void raise(duk_context *ctx) const;
+};
+
+/**
+ * \brief Irccd JavaScript API.
+ * \ingroup modules
+ */
+class IrccdModule : public Module {
+public:
+    /**
+     * Irccd.
+     */
+    IRCCD_EXPORT IrccdModule() noexcept;
+
+    /**
+     * \copydoc Module::load
+     */
+    IRCCD_EXPORT void load(Irccd &irccd, const std::shared_ptr<JsPlugin> &plugin) override;
+};
+
+/**
+ * Get irccd instance stored in this context.
+ *
+ * \param ctx the context
+ * \return the irccd reference
+ */
+Irccd &dukx_get_irccd(duk_context *ctx);
+
+} // !irccd
+
+#endif // !IRCCD_MOD_IRCCD_HPP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-logger.cpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,102 @@
+/*
+ * mod-logger.cpp -- Irccd.Logger API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "mod-logger.hpp"
+#include "mod-plugin.hpp"
+#include "logger.hpp"
+#include "plugin-js.hpp"
+
+namespace irccd {
+
+namespace {
+
+duk_ret_t print(duk_context *ctx, std::ostream &out)
+{
+    out << "plugin " << dukx_get_plugin(ctx)->name() << ": " << duk_require_string(ctx, 0) << std::endl;
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.Logger.info(message)
+ * --------------------------------------------------------
+ *
+ * Write a verbose message.
+ *
+ * Arguments:
+ *   - message, the message.
+ */
+duk_ret_t info(duk_context *ctx)
+{
+    return print(ctx, log::info());
+}
+
+/*
+ * Function: Irccd.Logger.warning(message)
+ * --------------------------------------------------------
+ *
+ * Write a warning message.
+ *
+ * Arguments:
+ *   - message, the warning.
+ */
+duk_ret_t warning(duk_context *ctx)
+{
+    return print(ctx, log::warning());
+}
+
+/*
+ * Function: Logger.debug(message)
+ * --------------------------------------------------------
+ *
+ * Write a debug message, only shown if irccd is compiled in debug.
+ *
+ * Arguments:
+ *   - message, the message.
+ */
+duk_ret_t debug(duk_context *ctx)
+{
+    return print(ctx, log::debug());
+}
+
+const duk_function_list_entry functions[] = {
+    { "info",       info,       1 },
+    { "warning",    warning,    1 },
+    { "debug",      debug,      1 },
+    { nullptr,      nullptr,    0 }
+};
+
+} // !namespace
+
+LoggerModule::LoggerModule() noexcept
+    : Module("Irccd.Logger")
+{
+}
+
+void LoggerModule::load(Irccd &, const std::shared_ptr<JsPlugin> &plugin)
+{
+    StackAssert sa(plugin->context());
+
+    duk_get_global_string(plugin->context(), "Irccd");
+    duk_push_object(plugin->context());
+    duk_put_function_list(plugin->context(), -1, functions);
+    duk_put_prop_string(plugin->context(), -2, "Logger");
+    duk_pop(plugin->context());
+}
+
+} // !irccd

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-logger.hpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,50 @@
+/*
+ * mod-logger.hpp -- Irccd.Logger API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef IRCCD_MOD_LOGGER_HPP
+#define IRCCD_MOD_LOGGER_HPP
+
+/**
+ * \file mod-logger.hpp
+ * \brief Irccd.Logger JavaScript API.
+ */
+
+#include "module.hpp"
+
+namespace irccd {
+
+/**
+ * \brief Irccd.Logger JavaScript API.
+ * \ingroup modules
+ */
+class LoggerModule : public Module {
+public:
+    /**
+     * Irccd.Logger.
+     */
+    IRCCD_EXPORT LoggerModule() noexcept;
+
+    /**
+     * \copydoc Module::load
+     */
+    IRCCD_EXPORT void load(Irccd &irccd, const std::shared_ptr<JsPlugin> &plugin) override;
+};
+
+} // !irccd
+
+#endif // !IRCCD_MOD_LOGGER_HPP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-plugin.cpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,356 @@
+/*
+ * js-plugin.cpp -- Irccd.Plugin API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "irccd.hpp"
+#include "plugin-js.hpp"
+#include "service-plugin.hpp"
+#include "mod-irccd.hpp"
+#include "mod-plugin.hpp"
+
+namespace irccd {
+
+namespace {
+
+const char PluginGlobal[] = "\xff""\xff""irccd-plugin-ptr";
+
+/*
+ * wrap
+ * ------------------------------------------------------------------
+ *
+ * Wrap function for these functions because they all takes the same arguments.
+ *
+ * - load,
+ * - reload,
+ * - unload.
+ */
+template <typename Func>
+duk_idx_t wrap(duk_context *ctx, int nret, Func &&func)
+{
+    std::string name = duk_require_string(ctx, 0);
+
+    try {
+        func(dukx_get_irccd(ctx), name);
+    } catch (const std::out_of_range &ex) {
+        dukx_throw(ctx, ReferenceError(ex.what()));
+    } catch (const std::exception &ex) {
+        dukx_throw(ctx, Error(ex.what()));
+    }
+
+    return nret;
+}
+
+/*
+ * set
+ * ------------------------------------------------------------------
+ *
+ * This setter is used to replace the Irccd.Plugin.(config|format) property when
+ * the plugin assign a new one.
+ *
+ * Because the plugin configuration always has higher priority, when a new
+ * object is assigned to 'config' or to the 'format' property, the plugin
+ * configuration is merged to the assigned one, adding or replacing any values.
+ *
+ * Example:
+ *
+ * Plugin 'xyz' does:
+ *
+ * Irccd.Plugin.config = {
+ *      mode: "simple",
+ *      level: "123"
+ * };
+ *
+ * The user configuration is:
+ *
+ * [plugin.xyz]
+ * mode = "hard"
+ * path = "/var"
+ *
+ * The final user table looks like this:
+ *
+ * Irccd.Plugin.config = {
+ *      mode: "hard",
+ *      level: "123",
+ *      path: "/var"
+ */
+duk_ret_t set(duk_context *ctx, const char *name)
+{
+    if (!duk_is_object(ctx, 0))
+        duk_error(ctx, DUK_ERR_TYPE_ERROR, "'%s' property must be object", name);
+
+    // Merge old table with new one.
+    duk_get_global_string(ctx, name);
+    duk_enum(ctx, -1, 0);
+
+    while (duk_next(ctx, -1, true))
+        duk_put_prop(ctx, 0);
+
+    // Pop enum and old table.
+    duk_pop_2(ctx);
+
+    // Replace the old table with the new assigned one.
+    duk_put_global_string(ctx, name);
+
+    return 0;
+}
+
+/*
+ * get
+ * ------------------------------------------------------------------
+ *
+ * Get the Irccd.Plugin.(config|format) property.
+ */
+duk_ret_t get(duk_context *ctx, const char *name)
+{
+    duk_get_global_string(ctx, name);
+
+    return 1;
+}
+
+/*
+ * setConfig
+ * ------------------------------------------------------------------
+ *
+ * Wrap setter for Irccd.Plugin.config property.
+ */
+duk_ret_t setConfig(duk_context *ctx)
+{
+    return set(ctx, JsPlugin::ConfigProperty);
+}
+
+/*
+ * getConfig
+ * ------------------------------------------------------------------
+ *
+ * Wrap getter for Irccd.Plugin.config property.
+ */
+duk_ret_t getConfig(duk_context *ctx)
+{
+    return get(ctx, JsPlugin::ConfigProperty);
+}
+
+/*
+ * setFormat
+ * ------------------------------------------------------------------
+ *
+ * Wrap setter for Irccd.Plugin.format property.
+ */
+duk_ret_t setFormat(duk_context *ctx)
+{
+    return set(ctx, JsPlugin::FormatProperty);
+}
+
+/*
+ * getFormat
+ * ------------------------------------------------------------------
+ *
+ * Wrap getter for Irccd.Plugin.format property.
+ */
+duk_ret_t getFormat(duk_context *ctx)
+{
+    return get(ctx, JsPlugin::FormatProperty);
+}
+
+/*
+ * Function: Irccd.Plugin.info([name])
+ * ------------------------------------------------------------------
+ *
+ * Get information about a plugin.
+ *
+ * The returned object as the following properties:
+ *
+ * - name: (string) the plugin identifier,
+ * - author: (string) the author,
+ * - license: (string) the license,
+ * - summary: (string) a short description,
+ * - version: (string) the version
+ *
+ * Arguments:
+ *   - name, the plugin identifier, if not specified the current plugin is
+ *     selected.
+ * Returns:
+ *   The plugin information or undefined if the plugin was not found.
+ */
+duk_idx_t info(duk_context *ctx)
+{
+    std::shared_ptr<Plugin> plugin;
+
+    if (duk_get_top(ctx) >= 1)
+        plugin = dukx_get_irccd(ctx).plugins().get(duk_require_string(ctx, 0));
+    else
+        plugin = dukx_get_plugin(ctx);
+
+    if (!plugin)
+        return 0;
+
+    duk_push_object(ctx);
+    dukx_push_std_string(ctx, plugin->name());
+    duk_put_prop_string(ctx, -2, "name");
+    dukx_push_std_string(ctx, plugin->author());
+    duk_put_prop_string(ctx, -2, "author");
+    dukx_push_std_string(ctx, plugin->license());
+    duk_put_prop_string(ctx, -2, "license");
+    dukx_push_std_string(ctx, plugin->summary());
+    duk_put_prop_string(ctx, -2, "summary");
+    dukx_push_std_string(ctx, plugin->version());
+    duk_put_prop_string(ctx, -2, "version");
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.Plugin.list()
+ * ------------------------------------------------------------------
+ *
+ * Get the list of plugins, the array returned contains all plugin names.
+ *
+ * Returns:
+ *   The list of all plugin names.
+ */
+duk_idx_t list(duk_context *ctx)
+{
+    dukx_push_array(ctx, dukx_get_irccd(ctx).plugins().list(), [] (auto ctx, auto plugin) {
+        dukx_push_std_string(ctx, plugin->name());
+    });
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.Plugin.load(name)
+ * ------------------------------------------------------------------
+ *
+ * Load a plugin by name. This function will search through the standard
+ * directories.
+ *
+ * Arguments:
+ *   - name, the plugin identifier.
+ * Throws:
+ *   - Error on errors,
+ *   - ReferenceError if the plugin was not found.
+ */
+duk_idx_t load(duk_context *ctx)
+{
+    return wrap(ctx, 0, [&] (Irccd &irccd, const std::string &name) {
+        irccd.plugins().load(name);
+    });
+}
+
+/*
+ * Function: Irccd.Plugin.reload(name)
+ * ------------------------------------------------------------------
+ *
+ * Reload a plugin by name.
+ *
+ * Arguments:
+ *   - name, the plugin identifier.
+ * Throws:
+ *   - Error on errors,
+ *   - ReferenceError if the plugin was not found.
+ */
+duk_idx_t reload(duk_context *ctx)
+{
+    return wrap(ctx, 0, [&] (Irccd &irccd, const std::string &name) {
+        irccd.plugins().reload(name);
+    });
+}
+
+/*
+ * Function: Irccd.Plugin.unload(name)
+ * ------------------------------------------------------------------
+ *
+ * Unload a plugin by name.
+ *
+ * Arguments:
+ *   - name, the plugin identifier.
+ * Throws:
+ *   - Error on errors,
+ *   - ReferenceError if the plugin was not found.
+ */
+duk_idx_t unload(duk_context *ctx)
+{
+    return wrap(ctx, 0, [&] (Irccd &irccd, const std::string &name) {
+        irccd.plugins().unload(name);
+    });
+}
+
+const duk_function_list_entry functions[] = {
+    { "info",   info,       DUK_VARARGS     },
+    { "list",   list,       0               },
+    { "load",   load,       1               },
+    { "reload", reload,     1               },
+    { "unload", unload,     1               },
+    { nullptr,  nullptr,    0               }
+};
+
+} // !namespace
+
+PluginModule::PluginModule() noexcept
+    : Module("Irccd.Plugin")
+{
+}
+
+void PluginModule::load(Irccd &, const std::shared_ptr<JsPlugin> &plugin)
+{
+    StackAssert sa(plugin->context());
+
+    duk_push_pointer(plugin->context(), new std::shared_ptr<JsPlugin>(plugin));
+    duk_put_global_string(plugin->context(), PluginGlobal);
+    duk_get_global_string(plugin->context(), "Irccd");
+    duk_push_object(plugin->context());
+    duk_put_function_list(plugin->context(), -1, functions);
+
+    // 'config' property.
+    duk_push_string(plugin->context(), "config");
+    duk_push_c_function(plugin->context(), getConfig, 0);
+    duk_push_c_function(plugin->context(), setConfig, 1);
+    duk_def_prop(plugin->context(), -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);
+
+    // 'format' property.
+    duk_push_string(plugin->context(), "format");
+    duk_push_c_function(plugin->context(), getFormat, 0);
+    duk_push_c_function(plugin->context(), setFormat, 1);
+    duk_def_prop(plugin->context(), -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);
+
+    duk_put_prop_string(plugin->context(), -2, "Plugin");
+    duk_pop(plugin->context());
+}
+
+void PluginModule::unload(Irccd &, const std::shared_ptr<JsPlugin> &plugin)
+{
+    StackAssert sa(plugin->context());
+
+    duk_push_global_object(plugin->context());
+    duk_get_prop_string(plugin->context(), -1, PluginGlobal);
+    delete static_cast<std::shared_ptr<JsPlugin> *>(duk_to_pointer(plugin->context(), -1));
+    duk_pop(plugin->context());
+    duk_del_prop_string(plugin->context(), -1, PluginGlobal);
+    duk_pop(plugin->context());
+}
+
+std::shared_ptr<JsPlugin> dukx_get_plugin(duk_context *ctx)
+{
+    StackAssert sa(ctx);
+
+    duk_get_global_string(ctx, PluginGlobal);
+    auto plugin = static_cast<std::shared_ptr<JsPlugin> *>(duk_to_pointer(ctx, -1));
+    duk_pop(ctx);
+
+    return *plugin;
+}
+
+} // !irccd

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-plugin.hpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,64 @@
+/*
+ * mod-plugin.hpp -- Irccd.Plugin API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef IRCCD_MOD_PLUGIN_HPP
+#define IRCCD_MOD_PLUGIN_HPP
+
+/**
+ * \file mod-plugin.hpp
+ * \brief Irccd.Plugin JavaScript API.
+ */
+
+#include "duktape.hpp"
+#include "module.hpp"
+
+namespace irccd {
+
+/**
+ * \brief Irccd.Plugin JavaScript API.
+ * \ingroup modules
+ */
+class PluginModule : public Module {
+public:
+    /**
+     * Irccd.Plugin.
+     */
+    IRCCD_EXPORT PluginModule() noexcept;
+
+    /**
+     * \copydoc Module::load
+     */
+    IRCCD_EXPORT void load(Irccd &irccd, const std::shared_ptr<JsPlugin> &plugin) override;
+
+    /**
+     * \copydoc Module::unload
+     */
+    IRCCD_EXPORT void unload(Irccd &irccd, const std::shared_ptr<JsPlugin> &plugin) override;
+};
+
+/**
+ * Access the plugin stored in this context.
+ *
+ * \param ctx the context
+ * \return the plugin
+ */
+std::shared_ptr<JsPlugin> dukx_get_plugin(duk_context *ctx);
+
+} // !irccd
+
+#endif // !IRCCD_MOD_PLUGIN_HPP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-server.cpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,580 @@
+/*
+ * js-server.cpp -- Irccd.Server API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <cassert>
+#include <sstream>
+#include <unordered_map>
+
+#include "irccd.hpp"
+#include "mod-irccd.hpp"
+#include "mod-server.hpp"
+#include "plugin-js.hpp"
+#include "server.hpp"
+#include "service-server.hpp"
+
+namespace irccd {
+
+namespace {
+
+const char *Signature("\xff""\xff""irccd-server-ptr");
+const char *Prototype("\xff""\xff""irccd-server-prototype");
+
+std::shared_ptr<Server> self(duk_context *ctx)
+{
+    StackAssert sa(ctx);
+
+    duk_push_this(ctx);
+    duk_get_prop_string(ctx, -1, Signature);
+    auto ptr = duk_to_pointer(ctx, -1);
+    duk_pop_2(ctx);
+
+    if (!ptr)
+        duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Server object");
+
+    return *static_cast<std::shared_ptr<Server> *>(ptr);
+}
+
+/*
+ * Method: Server.cmode(channel, mode)
+ * ------------------------------------------------------------------
+ *
+ * Change a channel mode.
+ *
+ * Arguments:
+ *   - channel, the channel,
+ *   - mode, the mode.
+ */
+duk_ret_t cmode(duk_context *ctx)
+{
+    self(ctx)->cmode(duk_require_string(ctx, 0), duk_require_string(ctx, 1));
+
+    return 0;
+}
+
+/*
+ * Method: Server.cnotice(channel, message)
+ * ------------------------------------------------------------------
+ *
+ * Send a channel notice.
+ *
+ * Arguments:
+ *   - channel, the channel,
+ *   - message, the message.
+ */
+duk_ret_t cnotice(duk_context *ctx)
+{
+    self(ctx)->cnotice(duk_require_string(ctx, 0), duk_require_string(ctx, 1));
+
+    return 0;
+}
+
+/*
+ * Method: Server.info()
+ * ------------------------------------------------------------------
+ *
+ * Get the server information as an object containing the following properties:
+ *
+ * name: the server unique name
+ * host: the host name
+ * port: the port number
+ * ssl: true if using ssl
+ * sslVerify: true if ssl was verified
+ * channels: an array of all channels
+ */
+duk_ret_t info(duk_context *ctx)
+{
+    auto server = self(ctx);
+
+    duk_push_object(ctx);
+    dukx_push_std_string(ctx, server->name());
+    duk_put_prop_string(ctx, -2, "name");
+    dukx_push_std_string(ctx, server->host());
+    duk_put_prop_string(ctx, -2, "host");
+    duk_push_int(ctx, server->port());
+    duk_put_prop_string(ctx, -2, "port");
+    duk_push_boolean(ctx, server->flags() & Server::Ssl);
+    duk_put_prop_string(ctx, -2, "ssl");
+    duk_push_boolean(ctx, server->flags() & Server::SslVerify);
+    duk_put_prop_string(ctx, -2, "sslVerify");
+    dukx_push_std_string(ctx, server->commandCharacter());
+    duk_put_prop_string(ctx, -2, "commandChar");
+    dukx_push_std_string(ctx, server->realname());
+    duk_put_prop_string(ctx, -2, "realname");
+    dukx_push_std_string(ctx, server->nickname());
+    duk_put_prop_string(ctx, -2, "nickname");
+    dukx_push_std_string(ctx, server->username());
+    duk_put_prop_string(ctx, -2, "username");
+    dukx_push_array(ctx, server->channels(), [&] (auto ctx, auto channel) {
+        dukx_push_std_string(ctx, channel);
+    });
+    duk_put_prop_string(ctx, -2, "channels");
+
+    return 1;
+}
+
+/*
+ * Method: Server.invite(target, channel)
+ * ------------------------------------------------------------------
+ *
+ * Invite someone to a channel.
+ *
+ * Arguments:
+ *   - target, the target to invite,
+ *   - channel, the channel.
+ */
+duk_ret_t invite(duk_context *ctx)
+{
+    self(ctx)->invite(duk_require_string(ctx, 0), duk_require_string(ctx, 1));
+
+    return 0;
+}
+
+/*
+ * Method: Server.join(channel, password = undefined)
+ * ------------------------------------------------------------------
+ *
+ * Join a channel with an optional password.
+ *
+ * Arguments:
+ *   - channel, the channel to join,
+ *   - password, the password or undefined to not use.
+ */
+duk_ret_t join(duk_context *ctx)
+{
+    self(ctx)->join(duk_require_string(ctx, 0), dukx_get_std_string(ctx, 1));
+
+    return 0;
+}
+
+/*
+ * Method: Server.kick(target, channel, reason = undefined)
+ * ------------------------------------------------------------------
+ *
+ * Kick someone from a channel.
+ *
+ * Arguments:
+ *   - target, the target to kick,
+ *   - channel, the channel,
+ *   - reason, the optional reason or undefined to not set.
+ */
+duk_ret_t kick(duk_context *ctx)
+{
+    self(ctx)->kick(duk_require_string(ctx, 0), duk_require_string(ctx, 1), dukx_get_std_string(ctx, 2));
+
+    return 0;
+}
+
+/*
+ * Method: Server.me(target, message)
+ * ------------------------------------------------------------------
+ *
+ * Send a CTCP Action.
+ *
+ * Arguments:
+ *   - target, the target or a channel,
+ *   - message, the message.
+ */
+duk_ret_t me(duk_context *ctx)
+{
+    self(ctx)->me(duk_require_string(ctx, 0), duk_require_string(ctx, 1));
+
+    return 0;
+}
+
+/*
+ * Method: Server.message(target, message)
+ * ------------------------------------------------------------------
+ *
+ * Send a message.
+ *
+ * Arguments:
+ *   - target, the target or a channel,
+ *   - message, the message.
+ */
+duk_ret_t message(duk_context *ctx)
+{
+    self(ctx)->message(duk_require_string(ctx, 0), duk_require_string(ctx, 1));
+
+    return 0;
+}
+
+/*
+ * Method: Server.mode(mode)
+ * ------------------------------------------------------------------
+ *
+ * Change your mode.
+ *
+ * Arguments:
+ *   - mode, the new mode.
+ */
+duk_ret_t mode(duk_context *ctx)
+{
+    self(ctx)->mode(duk_require_string(ctx, 0));
+
+    return 0;
+}
+
+/*
+ * Method: Server.names(channel)
+ * ------------------------------------------------------------------
+ *
+ * Get the list of names from a channel.
+ *
+ * Arguments:
+ *   - channel, the channel.
+ */
+duk_ret_t names(duk_context *ctx)
+{
+    self(ctx)->names(duk_require_string(ctx, 0));
+
+    return 0;
+}
+
+/*
+ * Method: Server.nick(nickname)
+ * ------------------------------------------------------------------
+ *
+ * Change the nickname.
+ *
+ * Arguments:
+ *   - nickname, the nickname.
+ */
+duk_ret_t nick(duk_context *ctx)
+{
+    self(ctx)->setNickname(duk_require_string(ctx, 0));
+
+    return 0;
+}
+
+/*
+ * Method: Server.notice(target, message)
+ * ------------------------------------------------------------------
+ *
+ * Send a private notice.
+ *
+ * Arguments:
+ *   - target, the target,
+ *   - message, the notice message.
+ */
+duk_ret_t notice(duk_context *ctx)
+{
+    self(ctx)->notice(duk_require_string(ctx, 0), duk_require_string(ctx, 1));
+
+    return 0;
+}
+
+/*
+ * Method: Server.part(channel, reason = undefined)
+ * ------------------------------------------------------------------
+ *
+ * Leave a channel.
+ *
+ * Arguments:
+ *   - channel, the channel to leave,
+ *   - reason, the optional reason, keep undefined for portability.
+ */
+duk_ret_t part(duk_context *ctx)
+{
+    self(ctx)->part(duk_require_string(ctx, 0), dukx_get_std_string(ctx, 1));
+
+    return 0;
+}
+
+/*
+ * Method: Server.send(raw)
+ * ------------------------------------------------------------------
+ *
+ * Send a raw message to the IRC server.
+ *
+ * Arguments:
+ *   - raw, the raw message (without terminators).
+ */
+duk_ret_t send(duk_context *ctx)
+{
+    self(ctx)->send(duk_require_string(ctx, 0));
+
+    return 0;
+}
+
+/*
+ * Method: Server.topic(channel, topic)
+ * ------------------------------------------------------------------
+ *
+ * Change a channel topic.
+ *
+ * Arguments:
+ *   - channel, the channel,
+ *   - topic, the new topic.
+ */
+duk_ret_t topic(duk_context *ctx)
+{
+    self(ctx)->topic(duk_require_string(ctx, 0), duk_require_string(ctx, 1));
+
+    return 0;
+}
+
+/*
+ * Method: Server.whois(target)
+ * ------------------------------------------------------------------
+ *
+ * Get whois information.
+ *
+ * Arguments:
+ *   - target, the target.
+ */
+duk_ret_t whois(duk_context *ctx)
+{
+    self(ctx)->whois(duk_require_string(ctx, 0));
+
+    return 0;
+}
+
+/*
+ * Method: Server.toString()
+ * ------------------------------------------------------------------
+ *
+ * Convert the object to std::string, convenience for adding the object
+ * as property key.
+ *
+ * duk_ret_turns:
+ *   The server name (unique).
+ */
+duk_ret_t toString(duk_context *ctx)
+{
+    dukx_push_std_string(ctx, self(ctx)->name());
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.Server(params) [constructor]
+ * ------------------------------------------------------------------
+ *
+ * Construct a new server.
+ *
+ * Params must be filled with the following properties:
+ *
+ * name: the name,
+ * host: the host,
+ * ipv6: true to use ipv6,      (Optional: default false)
+ * port: the port number,       (Optional: default 6667)
+ * password: the password,      (Optional: default none)
+ * channels: array of channels  (Optiona: default empty)
+ * ssl: true to use ssl,        (Optional: default false)
+ * sslVerify: true to verify    (Optional: default true)
+ * nickname: "nickname",        (Optional, default: irccd)
+ * username: "user name",       (Optional, default: irccd)
+ * realname: "real name",       (Optional, default: IRC Client Daemon)
+ * commandChar: "!",            (Optional, the command char, default: "!")
+ */
+duk_ret_t constructor(duk_context *ctx)
+{
+    if (!duk_is_constructor_call(ctx))
+        return 0;
+
+    duk_check_type(ctx, 0, DUK_TYPE_OBJECT);
+
+    try {
+        auto json = duk_json_encode(ctx, 0);
+        auto s = Server::fromJson(nlohmann::json::parse(json));
+
+        duk_push_this(ctx);
+        duk_push_pointer(ctx, new std::shared_ptr<Server>(std::move(s)));
+        duk_put_prop_string(ctx, -2, Signature);
+        duk_pop(ctx);
+    } catch (const std::exception &ex) {
+        duk_error(ctx, DUK_ERR_ERROR, "%s", ex.what());
+    }
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.Server() [destructor]
+ * ------------------------------------------------------------------
+ *
+ * Delete the property.
+ */
+duk_ret_t destructor(duk_context *ctx)
+{
+    duk_get_prop_string(ctx, 0, Signature);
+    delete static_cast<std::shared_ptr<Server> *>(duk_to_pointer(ctx, -1));
+    duk_pop(ctx);
+    duk_del_prop_string(ctx, 0, Signature);
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.Server.add(s)
+ * ------------------------------------------------------------------
+ *
+ * Register a new server to the irccd instance.
+ *
+ * Arguments:
+ *   - s, the server to add.
+ */
+duk_ret_t add(duk_context *ctx)
+{
+    dukx_get_irccd(ctx).servers().add(dukx_require_server(ctx, 0));
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.Server.find(name)
+ * ------------------------------------------------------------------
+ *
+ * Find a server by name.
+ *
+ * Arguments:
+ *   - name, the server name
+ * duk_ret_turns:
+ *   The server object or undefined if not found.
+ */
+duk_ret_t find(duk_context *ctx)
+{
+    auto server = dukx_get_irccd(ctx).servers().get(duk_require_string(ctx, 0));
+
+    if (!server)
+        return 0;
+
+    dukx_push_server(ctx, server);
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.Server.list()
+ * ------------------------------------------------------------------
+ *
+ * Get the map of all loaded servers.
+ *
+ * duk_ret_turns:
+ *   An object with string-to-servers pairs.
+ */
+duk_ret_t list(duk_context *ctx)
+{
+    duk_push_object(ctx);
+
+    for (const auto &server : dukx_get_irccd(ctx).servers().servers()) {
+        dukx_push_server(ctx, server);
+        duk_put_prop_string(ctx, -2, server->name().c_str());
+    }
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.Server.remove(name)
+ * ------------------------------------------------------------------
+ *
+ * Remove a server from the irccd instance. You can pass the server object since
+ * it's coercible to a string.
+ *
+ * Arguments:
+ *   - name the server name.
+ */
+duk_ret_t remove(duk_context *ctx)
+{
+    dukx_get_irccd(ctx).servers().remove(duk_require_string(ctx, 0));
+
+    return 0;
+}
+
+const duk_function_list_entry methods[] = {
+    { "cmode",      cmode,      2           },
+    { "cnotice",    cnotice,    2           },
+    { "info",       info,       0           },
+    { "invite",     invite,     2           },
+    { "join",       join,       DUK_VARARGS },
+    { "kick",       kick,       DUK_VARARGS },
+    { "me",         me,         2           },
+    { "message",    message,    2           },
+    { "mode",       mode,       1           },
+    { "names",      names,      1           },
+    { "nick",       nick,       1           },
+    { "notice",     notice,     2           },
+    { "part",       part,       DUK_VARARGS },
+    { "send",       send,       1           },
+    { "topic",      topic,      2           },
+    { "whois",      whois,      1           },
+    { "toString",   toString,   0           },
+    { nullptr,      nullptr,    0           }
+};
+
+const duk_function_list_entry functions[] = {
+    { "add",        add,        1           },
+    { "find",       find,       1           },
+    { "list",       list,       0           },
+    { "remove",     remove,     1           },
+    { nullptr,      nullptr,    0           }
+};
+
+} // !namespace
+
+ServerModule::ServerModule() noexcept
+    : Module("Irccd.Server")
+{
+}
+
+void ServerModule::load(Irccd &, const std::shared_ptr<JsPlugin> &plugin)
+{
+    StackAssert sa(plugin->context());
+
+    duk_get_global_string(plugin->context(), "Irccd");
+    duk_push_c_function(plugin->context(), constructor, 1);
+    duk_put_function_list(plugin->context(), -1, functions);
+    duk_push_object(plugin->context());
+    duk_put_function_list(plugin->context(), -1, methods);
+    duk_push_c_function(plugin->context(), destructor, 1);
+    duk_set_finalizer(plugin->context(), -2);
+    duk_dup_top(plugin->context());
+    duk_put_global_string(plugin->context(), Prototype);
+    duk_put_prop_string(plugin->context(), -2, "prototype");
+    duk_put_prop_string(plugin->context(), -2, "Server");
+    duk_pop(plugin->context());
+}
+
+void dukx_push_server(duk_context *ctx, std::shared_ptr<Server> server)
+{
+    assert(ctx);
+    assert(server);
+
+    StackAssert sa(ctx, 1);
+
+    duk_push_object(ctx);
+    duk_push_pointer(ctx, new std::shared_ptr<Server>(std::move(server)));
+    duk_put_prop_string(ctx, -2, Signature);
+    duk_get_global_string(ctx, Prototype);
+    duk_set_prototype(ctx, -2);
+}
+
+std::shared_ptr<Server> dukx_require_server(duk_context *ctx, duk_idx_t index)
+{
+    if (!duk_is_object(ctx, index) || !duk_has_prop_string(ctx, index, Signature))
+        duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Server object");
+
+    duk_get_prop_string(ctx, index, Signature);
+    auto file = *static_cast<std::shared_ptr<Server> *>(duk_to_pointer(ctx, -1));
+    duk_pop(ctx);
+
+    return file;
+}
+
+} // !irccd

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-server.hpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,70 @@
+/*
+ * mod-server.hpp -- Irccd.Server API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef IRCCD_MOD_SERVER_HPP
+#define IRCCD_MOD_SERVER_HPP
+
+/**
+ * \file mod-server.hpp
+ * \brief Irccd.Server JavaScript API.
+ */
+
+#include "duktape.hpp"
+#include "module.hpp"
+#include "server.hpp"
+
+namespace irccd {
+
+/**
+ * \brief Irccd.Server JavaScript API.
+ * \ingroup modules
+ */
+class ServerModule : public Module {
+public:
+    /**
+     * Irccd.Server.
+     */
+    IRCCD_EXPORT ServerModule() noexcept;
+
+    /**
+     * \copydoc Module::load
+     */
+    IRCCD_EXPORT void load(Irccd &irccd, const std::shared_ptr<JsPlugin> &plugin) override;
+};
+
+/**
+ * Push a server.
+ *
+ * \pre server != nullptr
+ * \param ctx the context
+ * \param server the server
+ */
+IRCCD_EXPORT void dukx_push_server(duk_context *ctx, std::shared_ptr<Server> server);
+
+/**
+ * Require a server. Raise a JavaScript error if not a Server.
+ *
+ * \param ctx the context
+ * \param index the index
+ * \return the server
+ */
+IRCCD_EXPORT std::shared_ptr<Server> dukx_require_server(duk_context *ctx, duk_idx_t index);
+
+} // !irccd
+
+#endif // !IRCCD_JS_SERVER_HPP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libirccd-js/irccd/mod-system.cpp	Wed Oct 05 20:32:27 2016 +0200
@@ -0,0 +1,243 @@
+/*
+ * js-system.cpp -- Irccd.System API
+ *
+ * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <chrono>
+#include <cstdlib>
+#include <thread>
+
+#include "sysconfig.hpp"
+
+#if defined(HAVE_POPEN)
+#  include <cstdio>
+#endif
+
+#include "mod-file.hpp"
+#include "mod-irccd.hpp"
+#include "mod-system.hpp"
+#include "plugin-js.hpp"
+#include "system.hpp"
+
+namespace irccd {
+
+namespace {
+
+/*
+ * Function: Irccd.System.env(key)
+ * ------------------------------------------------------------------
+ *
+ * Get an environment system variable.
+ *
+ * Arguments:
+ *   - key, the environment variable.
+ * Returns:
+ *   The value.
+ */
+duk_ret_t env(duk_context *ctx)
+{
+    dukx_push_std_string(ctx, sys::env(dukx_get_std_string(ctx, 0)));
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.System.exec(cmd)
+ * ------------------------------------------------------------------
+ *
+ * Execute a system command.
+ *
+ * Arguments:
+ *   - cmd, the command to execute.
+ */
+duk_ret_t exec(duk_context *ctx)
+{
+    std::system(duk_get_string(ctx, 0));
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.System.home()
+ * ------------------------------------------------------------------
+ *
+ * Get the operating system user's home.
+ *
+ * Returns:
+ *   The user home directory.
+ */
+duk_ret_t home(duk_context *ctx)
+{
+    dukx_push_std_string(ctx, sys::home());
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.System.name()
+ * ------------------------------------------------------------------
+ *
+ * Get the operating system name.
+ *
+ * Returns:
+ *   The system name.
+ */
+duk_ret_t name(duk_context *ctx)
+{
+    dukx_push_std_string(ctx, sys::name());
+
+    return 1;
+}
+
+#if defined(HAVE_POPEN)
+
+/*
+ * Function: Irccd.System.popen(cmd, mode) [optional]
+ * ------------------------------------------------------------------
+ *
+ * Wrapper for popen(3) if the function is available.
+ *
+ * Arguments:
+ *   - cmd, the command to execute,
+ *   - mode, the mode (e.g. "r").
+ * Returns:
+ *   A Irccd.File object.
+ * Throws
+ *   - Irccd.SystemError on failures.
+ */
+duk_ret_t popen(duk_context *ctx)
+{
+    auto fp = ::popen(duk_require_string(ctx, 0), duk_require_string(ctx, 1));
+
+    if (fp == nullptr)
+        dukx_throw(ctx, SystemError());
+
+    dukx_push_file(ctx, new File(fp, [] (std::FILE *fp) { ::pclose(fp); }));
+
+    return 1;
+}
+
+#endif // !HAVE_POPEN
+
+/*
+ * Function: Irccd.System.sleep(delay)
+ * ------------------------------------------------------------------
+ *
+ * Sleep the main loop for the specific delay in seconds.
+ */
+duk_ret_t sleep(duk_context *ctx)
+{
+    std::this_thread::sleep_for(std::chrono::seconds(duk_get_int(ctx, 0)));
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.System.ticks()
+ * ------------------------------------------------------------------
+ *
+ * Get the number of milliseconds since irccd was started.
+ *
+ * Returns:
+ *   The number of milliseconds.
+ */
+duk_ret_t ticks(duk_context *ctx)
+{
+    duk_push_int(ctx, sys::ticks());
+
+    return 1;
+}
+
+/*
+ * Function: Irccd.System.usleep(delay)
+ * ------------------------------------------------------------------
+ *
+ * Sleep the main loop for the specific delay in microseconds.
+ */
+duk_ret_t usleep(duk_context *ctx)
+{
+    std::this_thread::sleep_for(std::chrono::microseconds(duk_get_int(ctx, 0)));
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.System.uptime()
+ * ------------------------------------------------------------------
+ *
+ * Get the system uptime.
+ *
+ * Returns:
+ *   The system uptime.
+ */
+duk_ret_t uptime(duk_context *ctx)
+{
+    duk_push_int(ctx, sys::uptime());
+
+    return 0;
+}
+
+/*
+ * Function: Irccd.System.version()
+ * ------------------------------------------------------------------
+ *
+ * Get the operating system version.
+ *
+ * Returns:
+ *   The system version.
+ */
+duk_ret_t version(duk_context *ctx)
+{
+    dukx_push_std_string(ctx, sys::version());
+
+    return 1;
+}
+
+const duk_function_list_entry functions[] = {
+    { "env",        env,        1 },
+    { "exec",       exec,       1 },
+    { "home",       home,       0 },
+    { "name",       name,       0 },
+#if defined(HAVE_POPEN)
+    { "popen",      popen,      2 },
+#endif
+    { "sleep",      sleep,      1 },
+    { "ticks",      ticks,      0 },
+    { "uptime",     uptime,     0 },
+    { "usleep",     usleep,     1 },
+    { "version",    version,    0 },
+    { nullptr,      nullptr,    0 }
+};
+
+} // !namespace
+
+SystemModule::SystemModule() noexcept
+    : Module("Irccd.System")
+{
+}
+
+void SystemModule::load(Irccd &, const std::shared_ptr<JsPlugin> &plugin)
+{
+    StackAssert sa(plugin->context());
+
+    duk_get_global_string(plugin->context(), "Irccd");
+    duk_push_object(plugin->context());
+    duk_put_function_list(plugin->context(), -1, functions);
+    duk_put_prop_string(plugin->context(), -2, "System");
+    duk_pop(plugin->context());
+}
+
+} // !irccd