--- a/irccd/CMakeLists.txt	Fri Jan 29 13:50:44 2021 +0100
+++ b/irccd/CMakeLists.txt	Fri Jan 29 15:03:23 2021 +0100
@@ -17,5 +17,55 @@
 #
 
 project(irccd)
-add_executable(irccd main.c)
-target_link_libraries(irccd libirccd)
+
+set(
+	SOURCES
+	${irccd_SOURCE_DIR}/dl-plugin.c
+	${irccd_SOURCE_DIR}/dl-plugin.h
+)
+
+if (IRCCD_WITH_JS)
+	list(
+		APPEND SOURCES
+		${irccd_SOURCE_DIR}/js-plugin.c
+		${irccd_SOURCE_DIR}/js-plugin.h
+		${irccd_SOURCE_DIR}/jsapi-chrono.c
+		${irccd_SOURCE_DIR}/jsapi-chrono.h
+		${irccd_SOURCE_DIR}/jsapi-directory.c
+		${irccd_SOURCE_DIR}/jsapi-directory.h
+		${irccd_SOURCE_DIR}/jsapi-file.c
+		${irccd_SOURCE_DIR}/jsapi-file.h
+		${irccd_SOURCE_DIR}/jsapi-irccd.c
+		${irccd_SOURCE_DIR}/jsapi-irccd.h
+		${irccd_SOURCE_DIR}/jsapi-logger.c
+		${irccd_SOURCE_DIR}/jsapi-logger.h
+		${irccd_SOURCE_DIR}/jsapi-plugin.c
+		${irccd_SOURCE_DIR}/jsapi-plugin.h
+		${irccd_SOURCE_DIR}/jsapi-server.c
+		${irccd_SOURCE_DIR}/jsapi-server.h
+		${irccd_SOURCE_DIR}/jsapi-system.c
+		${irccd_SOURCE_DIR}/jsapi-system.h
+		${irccd_SOURCE_DIR}/jsapi-timer.c
+		${irccd_SOURCE_DIR}/jsapi-timer.h
+		${irccd_SOURCE_DIR}/jsapi-unicode.c
+		${irccd_SOURCE_DIR}/jsapi-unicode.h
+		${irccd_SOURCE_DIR}/jsapi-util.c
+		${irccd_SOURCE_DIR}/jsapi-util.h
+		${irccd_SOURCE_DIR}/unicode.c
+		${irccd_SOURCE_DIR}/unicode.h
+	)
+endif ()
+
+# This is required for unit tests.
+add_library(irccd-fe OBJECT ${SOURCES})
+target_link_libraries(irccd-fe libirccd)
+target_include_directories(irccd-fe PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>)
+
+if (IRCCD_WITH_JS)
+	target_link_libraries(irccd-fe libirccd-duktape)
+endif ()
+
+add_executable(irccd ${irccd_SOURCE_DIR}/main.c)
+target_link_libraries(irccd irccd-fe)
+
+source_group(TREE ${irccd_SOURCE_DIR} FILES ${SOURCES})

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/dl-plugin.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,267 @@
+/*
+ * dl-plugin.c -- native C plugins for irccd
+ *
+ * Copyright (c) 2013-2021 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 <sys/stat.h>
+#include <assert.h>
+#include <ctype.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <config.h>
+
+#include <irccd/log.h>
+#include <irccd/plugin.h>
+#include <irccd/util.h>
+
+#include "dl-plugin.h"
+
+#define INVOKE(pg, name, sig, ...)                                              \
+do {                                                                            \
+        struct self *self = pg->data;                                           \
+        sig fn;                                                                 \
+                                                                                \
+        if (self->handle && (fn = dlsym(self->handle, symbol(self, name))))     \
+                return fn(__VA_ARGS__);                                         \
+} while (0)
+
+struct self {
+	struct irc_plugin plugin;
+	char prefix[32];
+	void *handle;
+};
+
+typedef const char *    (*get_option_fn)(const char *);
+typedef const char *    (*get_path_fn)(const char *);
+typedef const char *    (*get_template_fn)(const char *);
+typedef const char **   (*get_options_fn)(void);
+typedef const char **   (*get_paths_fn)(void);
+typedef const char **   (*get_templates_fn)(void);
+typedef void            (*event_fn)(const struct irc_event *);
+typedef void            (*load_fn)(void);
+typedef void            (*reload_fn)(void);
+typedef void            (*unload_fn)(void);
+typedef void            (*set_option_fn)(const char *, const char *);
+typedef void            (*set_path_fn)(const char *, const char *);
+typedef void            (*set_template_fn)(const char *, const char *);
+
+static const char *
+symbol(const struct self *self, const char *func)
+{
+	static char sym[128];
+
+	snprintf(sym, sizeof (sym), "%s_%s",self->prefix, func);
+
+	return sym;
+}
+
+static void
+set_template(struct irc_plugin *plg, const char *key, const char *value)
+{
+	INVOKE(plg, "set_template", set_template_fn, key, value);
+}
+
+static const char *
+get_template(struct irc_plugin *plg, const char *key)
+{
+	INVOKE(plg, "get_template", get_template_fn, key);
+
+	return NULL;
+}
+
+static const char **
+get_templates(struct irc_plugin *plg)
+{
+	INVOKE(plg, "get_templates", get_templates_fn);
+
+	return NULL;
+}
+
+static void
+set_path(struct irc_plugin *plg, const char *key, const char *value)
+{
+	INVOKE(plg, "set_path", set_path_fn, key, value);
+}
+
+static const char *
+get_path(struct irc_plugin *plg, const char *key)
+{
+	INVOKE(plg, "get_path", get_path_fn, key);
+
+	return NULL;
+}
+
+static const char **
+get_paths(struct irc_plugin *plg)
+{
+	INVOKE(plg, "get_paths", get_paths_fn);
+
+	return NULL;
+}
+
+static void
+set_option(struct irc_plugin *plg, const char *key, const char *value)
+{
+	INVOKE(plg, "set_option", set_option_fn, key, value);
+}
+
+static const char *
+get_option(struct irc_plugin *plg, const char *key)
+{
+	INVOKE(plg, "get_option", get_option_fn, key);
+
+	return NULL;
+}
+
+static const char **
+get_options(struct irc_plugin *plg)
+{
+	INVOKE(plg, "get_options", get_options_fn);
+
+	return NULL;
+}
+
+static void
+load(struct irc_plugin *plg)
+{
+	INVOKE(plg, "load", load_fn);
+}
+
+static void
+reload(struct irc_plugin *plg)
+{
+	INVOKE(plg, "reload", reload_fn);
+}
+
+static void
+unload(struct irc_plugin *plg)
+{
+	INVOKE(plg, "unload", unload_fn);
+}
+
+static void
+handle(struct irc_plugin *plg, const struct irc_event *ev)
+{
+	INVOKE(plg, "event", event_fn, ev);
+}
+
+static void
+finish(struct irc_plugin *plg)
+{
+	struct self *self = plg->data;
+
+	if (self->handle)
+		dlclose(self->handle);
+
+	free(self);
+	memset(self, 0, sizeof (*self));
+}
+
+static struct self *
+init(const char *path)
+{
+	struct self self;
+	struct stat st;
+
+	/*
+	 * It's not possible to get the exact error code when loading a plugin
+	 * using dlopen, since we're trying a lot of files that potentially not
+	 * exist we check presence before even though there's a possible
+	 * condition but at least we can print an error message if there are
+	 * other errors than missing file.
+	 */
+	if (stat(path, &st) < 0 && errno == ENOENT)
+		return NULL;
+
+	if (!(self.handle = dlopen(path, RTLD_NOW))) {
+		irc_log_warn("plugin: %s: %s", path, dlerror());
+		return NULL;
+	}
+
+	/* Compute prefix name */
+	strlcpy(self.prefix, irc_util_basename(path), sizeof (self.prefix));
+
+	/* Remove plugin extension. */
+	self.prefix[strcspn(self.prefix, ".")] = '\0';
+
+	/* Remove every invalid identifiers. */
+	for (char *p = self.prefix; *p; ++p)
+		if (!isalnum(*p))
+			*p = '_';
+
+	return irc_util_memdup(&self, sizeof (self));
+}
+
+static struct irc_plugin *
+wrap_open(struct irc_plugin_loader *ldr, const char *path)
+{
+	(void)ldr;
+
+	return dl_plugin_open(path);
+}
+
+struct irc_plugin *
+dl_plugin_open(const char *path)
+{
+	struct self *self;
+
+	if (!(self = init(path)))
+		return false;
+
+	/* Data and all callbacks. */
+	self->plugin.data = self;
+	self->plugin.set_template = set_template;
+	self->plugin.get_template = get_template;
+	self->plugin.get_templates = get_templates;
+	self->plugin.set_path = set_path;
+	self->plugin.get_path = get_path;
+	self->plugin.get_paths = get_paths;
+	self->plugin.set_option = set_option;
+	self->plugin.get_option = get_option;
+	self->plugin.get_options = get_options;
+	self->plugin.load = load;
+	self->plugin.reload = reload;
+	self->plugin.unload = unload;
+	self->plugin.handle = handle;
+	self->plugin.finish = finish;
+
+	return &self->plugin;
+}
+
+struct irc_plugin_loader *
+dl_plugin_loader_new(void)
+{
+	struct irc_plugin_loader *ldr;
+
+	ldr = irc_util_calloc(1, sizeof (*ldr));
+	ldr->open = wrap_open;
+
+#if defined(_WIN32)
+	strlcpy(ldr->extensions, "dll", sizeof (ldr->extensions));
+#elif defined(__APPLE__)
+	strlcpy(ldr->extensions, "so:dylib", sizeof (ldr->extensions));
+#else
+	strlcpy(ldr->extensions, "so", sizeof (ldr->extensions));
+#endif
+
+	strlcpy(ldr->paths, IRCCD_LIBDIR "/irccd", sizeof (ldr->paths));
+
+	return ldr;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/dl-plugin.h	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,31 @@
+/*
+ * dl-plugin.c -- native C plugins for irccd
+ *
+ * Copyright (c) 2013-2021 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_DL_PLUGIN_H
+#define IRCCD_DL_PLUGIN_H
+
+struct irc_plugin;
+struct irc_plugin_loader;
+
+struct irc_plugin *
+dl_plugin_open(const char *);
+
+struct irc_plugin_loader *
+dl_plugin_loader_new(void);
+
+#endif /* !IRCCD_DL_PLUGIN_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/js-plugin.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,584 @@
+/*
+ * jsapi-plugin.c -- Javascript plugins
+ *
+ * Copyright (c) 2013-2021 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 <sys/stat.h>
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <irccd/channel.h>
+#include <irccd/event.h>
+#include <irccd/log.h>
+#include <irccd/plugin.h>
+#include <irccd/server.h>
+#include <irccd/util.h>
+
+#include "js-plugin.h"
+#include "jsapi-chrono.h"
+#include "jsapi-directory.h"
+#include "jsapi-file.h"
+#include "jsapi-irccd.h"
+#include "jsapi-logger.h"
+#include "jsapi-plugin.h"
+#include "jsapi-plugin.h"
+#include "jsapi-server.h"
+#include "jsapi-system.h"
+#include "jsapi-timer.h"
+#include "jsapi-unicode.h"
+#include "jsapi-util.h"
+
+
+struct self {
+	struct irc_plugin plugin;
+	duk_context *ctx;
+	char **options;
+	char **templates;
+	char **paths;
+	char *license;
+	char *version;
+	char *author;
+	char *description;
+};
+
+static void
+freelist(char **table)
+{
+	if (!table)
+		return;
+
+	for (char **p = table; *p; ++p)
+		free(*p);
+
+	free(table);
+}
+
+static char *
+metadata(duk_context *ctx, const char *name)
+{
+	char *ret = NULL;
+
+	duk_get_global_string(ctx, "info");
+
+	if (duk_get_type(ctx, -1) == DUK_TYPE_OBJECT) {
+		duk_get_prop_string(ctx, -1, name);
+
+		if (duk_get_type(ctx, -1) == DUK_TYPE_STRING)
+			ret = irc_util_strdup(duk_get_string(ctx, -1));
+
+		duk_pop(ctx);
+	}
+
+	duk_pop(ctx);
+
+	return ret ? ret : irc_util_strdup("unknown");
+}
+
+static void
+push_names(duk_context *ctx, const struct irc_event *ev)
+{
+	const char *token;
+	char *p = ev->names.names;
+
+	duk_push_array(ctx);
+
+	for (size_t i = 0; (token = strtok_r(p, " ", &p)); ++i) {
+		irc_server_strip(ev->server, &token, NULL, NULL);
+		duk_push_string(ctx, token);
+		duk_put_prop_index(ctx, -2, i);
+	}
+}
+
+static void
+push_whois(duk_context *ctx, const struct irc_event *ev)
+{
+	const char *token;
+	char *p = ev->whois.channels;
+
+	duk_push_object(ctx);
+	duk_push_string(ctx, ev->whois.nickname);
+	duk_put_prop_string(ctx, -2, "nickname");
+	duk_push_string(ctx, ev->whois.username);
+	duk_put_prop_string(ctx, -2, "username");
+	duk_push_string(ctx, ev->whois.realname);
+	duk_put_prop_string(ctx, -2, "realname");
+	duk_push_string(ctx, ev->whois.hostname);
+	duk_put_prop_string(ctx, -2, "hostname");
+	duk_push_array(ctx);
+	for (size_t i = 0; (token = strtok_r(p, " ", &p)); ++i) {
+		char mode = 0, prefix = 0;
+
+		irc_server_strip(ev->server, &token, &mode, &prefix);
+		duk_push_object(ctx);
+		duk_push_string(ctx, token);
+		duk_put_prop_string(ctx, -2, "channel");
+		duk_push_sprintf(ctx, "%c", mode);
+		duk_put_prop_string(ctx, -2, "mode");
+		duk_push_sprintf(ctx, "%c", prefix);
+		duk_put_prop_string(ctx, -2, "prefix");
+		duk_put_prop_index(ctx, -2, i);
+	}
+	duk_put_prop_string(ctx, -2, "channels");
+}
+
+static const char **
+get_table(duk_context *ctx, const char *name, char ***ptable)
+{
+	char **list;
+	size_t listsz;
+
+	duk_get_global_string(ctx, name);
+
+	if (!(listsz = duk_get_length(ctx, -1))) {
+		duk_pop(ctx);
+		return NULL;
+	}
+
+	list = irc_util_calloc(listsz + 1, sizeof (char *));
+
+	duk_enum(ctx, -1, 0);
+
+	for (size_t i = 0; i < listsz && duk_next(ctx, -1, true); ++i) {
+		list[i] = irc_util_strdup(duk_to_string(ctx, -2));
+		duk_pop_n(ctx, 2);
+	}
+
+	duk_pop_n(ctx, 2);
+
+	freelist(*ptable);
+	*ptable = list;
+
+	return (const char **)list;
+}
+
+static void
+set_key_value(duk_context *ctx, const char *table, const char *key, const char *value)
+{
+	duk_get_global_string(ctx, table);
+	duk_push_string(ctx, value);
+	duk_put_prop_string(ctx, -2, key);
+	duk_pop(ctx);
+}
+
+static const char *
+get_value(duk_context *ctx, const char *table, const char *key)
+{
+	const char *ret;
+
+	duk_get_global_string(ctx, table);
+	duk_get_prop_string(ctx, -1, key);
+	ret = duk_to_string(ctx, -1);
+	duk_pop_n(ctx, 2);
+
+	return ret;
+}
+
+static void
+set_template(struct irc_plugin *plg, const char *key, const char *value)
+{
+	struct self *js = plg->data;
+
+	set_key_value(js->ctx, JSAPI_PLUGIN_PROP_TEMPLATES, key, value);
+}
+
+static const char *
+get_template(struct irc_plugin *plg, const char *key)
+{
+	struct self *js = plg->data;
+
+	return get_value(js->ctx, JSAPI_PLUGIN_PROP_TEMPLATES, key);
+}
+
+static const char **
+get_templates(struct irc_plugin *plg)
+{
+	struct self *js = plg->data;
+
+	return get_table(js->ctx, JSAPI_PLUGIN_PROP_TEMPLATES, &js->templates);
+}
+
+static void
+set_path(struct irc_plugin *plg, const char *key, const char *value)
+{
+	struct self *js = plg->data;
+
+	set_key_value(js->ctx, JSAPI_PLUGIN_PROP_PATHS, key, value);
+}
+
+static const char *
+get_path(struct irc_plugin *plg, const char *key)
+{
+	struct self *js = plg->data;
+
+	return get_value(js->ctx, JSAPI_PLUGIN_PROP_PATHS, key);
+}
+
+static const char **
+get_paths(struct irc_plugin *plg)
+{
+	struct self *js = plg->data;
+
+	return get_table(js->ctx, JSAPI_PLUGIN_PROP_PATHS, &js->paths);
+}
+
+static void
+set_option(struct irc_plugin *plg, const char *key, const char *value)
+{
+	struct self *js = plg->data;
+
+	set_key_value(js->ctx, JSAPI_PLUGIN_PROP_OPTIONS, key, value);
+}
+
+static const char *
+get_option(struct irc_plugin *plg, const char *key)
+{
+	struct self *js = plg->data;
+
+	return get_value(js->ctx, JSAPI_PLUGIN_PROP_OPTIONS, key);
+}
+
+static const char **
+get_options(struct irc_plugin *plg)
+{
+	struct self *js = plg->data;
+
+	return get_table(js->ctx, JSAPI_PLUGIN_PROP_OPTIONS, &js->options);
+}
+
+static void
+vcall(struct irc_plugin *plg, const char *function, const char *fmt, va_list ap)
+{
+	struct self *self = plg->data;
+	int nargs = 0;
+
+	duk_get_global_string(self->ctx, function);
+
+	if (!duk_is_function(self->ctx, -1)) {
+		duk_pop(self->ctx);
+		return;
+	}
+
+	for (const char *f = fmt; *f; ++f) {
+		void (*push)(duk_context *, void *);
+
+		switch (*f) {
+		case 'S':
+			jsapi_server_push(self->ctx, va_arg(ap, struct irc_server *));
+			break;
+		case 's':
+			duk_push_string(self->ctx, va_arg(ap, const char *));
+			break;
+		case 'x':
+			push = va_arg(ap, void (*)(duk_context *, void *));
+			push(self->ctx, va_arg(ap, void *));
+			break;
+		default:
+			continue;
+		}
+
+		++nargs;
+	}
+
+	if (duk_pcall(self->ctx, nargs) != 0)
+		irc_log_warn("plugin %s: %s\n", duk_to_string(self->ctx, -1));
+
+	duk_pop(self->ctx);
+}
+
+static void
+call(struct irc_plugin *plg, const char *function, const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	vcall(plg, function, fmt, ap);
+	va_end(ap);
+}
+
+static void
+handle(struct irc_plugin *plg, const struct irc_event *ev)
+{
+	(void)plg;
+	(void)ev;
+
+	switch (ev->type) {
+	case IRC_EVENT_COMMAND:
+		call(plg, "onCommand", "Ss ss", ev->server, ev->message.origin,
+		    ev->message.channel, ev->message.message);
+		break;
+	case IRC_EVENT_CONNECT:
+		call(plg, "onConnect", "S", ev->server);
+		break;
+	case IRC_EVENT_DISCONNECT:
+		call(plg, "onDisconnect", "S", ev->server);
+		break;
+	case IRC_EVENT_INVITE:
+		call(plg, "onInvite", "Ss s", ev->server, ev->invite.origin,
+		     ev->invite.channel);
+		break;
+	case IRC_EVENT_JOIN:
+		call(plg, "onJoin", "Ss s", ev->server, ev->join.origin,
+		    ev->join.channel);
+		break;
+	case IRC_EVENT_KICK:
+		call(plg, "onKick", "Ss sss", ev->server, ev->kick.origin,
+		    ev->kick.channel, ev->kick.target, ev->kick.reason);
+		break;
+	case IRC_EVENT_ME:
+		call(plg, "onMe", "Ss ss", ev->server, ev->message.origin,
+		    ev->message.channel, ev->message.message);
+		break;
+	case IRC_EVENT_MESSAGE:
+		call(plg, "onMessage", "Ss ss", ev->server, ev->message.origin,
+		    ev->message.channel, ev->message.message);
+		break;
+	case IRC_EVENT_MODE:
+		call(plg, "onMode", "Ss sss ss", ev->server, ev->mode.origin,
+		    ev->mode.channel, ev->mode.mode, ev->mode.limit,
+		    ev->mode.user, ev->mode.mask);
+		break;
+	case IRC_EVENT_NAMES:
+		call(plg, "onNames", "Ss x", ev->server, ev->names.channel,
+		    push_names, ev);
+		break;
+	case IRC_EVENT_NICK:
+		call(plg, "onNick", "Ss s", ev->server, ev->nick.origin,
+		    ev->nick.nickname);
+		break;
+	case IRC_EVENT_NOTICE:
+		call(plg, "onNotice", "Ss ss", ev->server, ev->notice.origin,
+		    ev->notice.channel, ev->notice.notice);
+		break;
+	case IRC_EVENT_PART:
+		call(plg, "onPart", "Ss ss", ev->server, ev->part.origin,
+		    ev->part.channel, ev->part.reason);
+		break;
+	case IRC_EVENT_TOPIC:
+		call(plg, "onTopic", "Ss ss", ev->server, ev->topic.origin,
+		    ev->topic.channel, ev->topic.topic);
+		break;
+	case IRC_EVENT_WHOIS:
+		call(plg, "onWhois", "Sx", ev->server, push_whois, ev);
+		break;
+	default:
+		break;
+	}
+}
+
+static char *
+eat(const char *path)
+{
+	int fd = -1;
+	char *ret = NULL;
+	struct stat st;
+
+	if ((fd = open(path, O_RDONLY)) < 0)
+		goto err;
+	if (fstat(fd, &st) < 0)
+		goto err;
+	if (!(ret = calloc(1, st.st_size + 1)))
+		goto err;
+	if (read(fd, ret, st.st_size) != st.st_size)
+		goto err;
+
+	close(fd);
+
+	return ret;
+
+err:
+	if (fd != -1)
+		close(fd);
+
+	free(ret);
+
+	return false;
+}
+
+static void *
+wrap_malloc(void *udata, size_t size)
+{
+	(void)udata;
+
+	return irc_util_malloc(size);
+}
+
+static void *
+wrap_realloc(void *udata, void *ptr, size_t size)
+{
+	(void)udata;
+
+	return irc_util_realloc(ptr, size);
+}
+
+static void
+wrap_free(void *udata, void *ptr)
+{
+	(void)udata;
+
+	free(ptr);
+}
+
+static struct self *
+init(const char *path, const char *script)
+{
+	struct self *js;
+
+	js = irc_util_calloc(1, sizeof (*js));
+	js->ctx = duk_create_heap(wrap_malloc, wrap_realloc, wrap_free, NULL, NULL);
+
+	jsapi_load(js->ctx);
+	jsapi_chrono_load(js->ctx);
+	jsapi_directory_load(js->ctx);
+	jsapi_file_load(js->ctx);
+	jsapi_logger_load(js->ctx);
+	jsapi_plugin_load(js->ctx, &js->plugin);
+	jsapi_server_load(js->ctx);
+	jsapi_system_load(js->ctx);
+	jsapi_timer_load(js->ctx);
+	jsapi_unicode_load(js->ctx);
+	jsapi_util_load(js->ctx);
+
+	if (duk_peval_string(js->ctx, script) != 0) {
+		irc_log_warn("plugin: %s: %s", path, duk_to_string(js->ctx, -1));
+		duk_destroy_heap(js->ctx);
+		free(js);
+		return NULL;
+	}
+
+	js->plugin.license = js->license = metadata(js->ctx, "license");
+	js->plugin.version = js->version = metadata(js->ctx, "version");
+	js->plugin.author = js->author = metadata(js->ctx, "author");
+	js->plugin.description = js->description = metadata(js->ctx, "summary");
+
+	return js;
+}
+
+static void
+load(struct irc_plugin *plg)
+{
+	call(plg, "onLoad", "");
+}
+
+static void
+reload(struct irc_plugin *plg)
+{
+	call(plg, "onReload", "");
+}
+
+static void
+unload(struct irc_plugin *plg)
+{
+	call(plg, "onUnload", "");
+}
+
+static void
+finish(struct irc_plugin *plg)
+{
+	struct self *self = plg->data;
+
+	if (self->ctx)
+		duk_destroy_heap(self->ctx);
+
+	freelist(self->options);
+	freelist(self->templates);
+	freelist(self->paths);
+
+	free(self->license);
+	free(self->version);
+	free(self->author);
+	free(self->description);
+	free(self);
+}
+
+static struct irc_plugin *
+wrap_open(struct irc_plugin_loader *ldr, const char *path)
+{
+	(void)ldr;
+
+	return js_plugin_open(path);
+}
+
+duk_context *
+js_plugin_get_context(struct irc_plugin *js)
+{
+	struct self *self = js->data;
+
+	return self->ctx;
+}
+
+struct irc_plugin *
+js_plugin_open(const char *path)
+{
+	assert(path);
+
+	char *script = NULL;
+	struct self *self;
+
+	/*
+	 * Duktape can't open script from file path so we need to read the
+	 * whole script at once.
+	 */
+	if (!(script = eat(path))) {
+		if (errno != ENOENT)
+			irc_log_warn("irccd: %s: %s", path, strerror(errno));
+
+		return NULL;
+	}
+
+	/* Init already log errors. */
+	if (!(self = init(path, script))) {
+		free(script);
+		return NULL;
+	}
+
+	self->plugin.data = self;
+	self->plugin.set_template = set_template;
+	self->plugin.get_template = get_template;
+	self->plugin.get_templates = get_templates;
+	self->plugin.set_path = set_path;
+	self->plugin.get_path = get_path;
+	self->plugin.get_paths = get_paths;
+	self->plugin.set_option = set_option;
+	self->plugin.get_option = get_option;
+	self->plugin.get_options = get_options;
+	self->plugin.load = load;
+	self->plugin.reload = reload;
+	self->plugin.unload = unload;
+	self->plugin.handle = handle;
+	self->plugin.finish = finish;
+
+	/* No longer needed. */
+	free(script);
+
+	return &self->plugin;
+}
+
+struct irc_plugin_loader *
+js_plugin_loader_new(void)
+{
+	struct irc_plugin_loader *ldr;
+
+	ldr = irc_util_calloc(1, sizeof (*ldr));
+	ldr->open = wrap_open;
+	strlcpy(ldr->extensions, "js", sizeof (ldr->extensions));
+	strlcpy(ldr->paths, IRCCD_LIBDIR "/irccd", sizeof (ldr->paths));
+
+	return ldr;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/js-plugin.h	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,35 @@
+/*
+ * js-plugin.h -- Javascript plugins
+ *
+ * Copyright (c) 2013-2021 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_JS_PLUGIN_H
+#define IRCCD_JS_PLUGIN_H
+
+#include <duktape.h>
+
+struct irc_plugin;
+
+duk_context *
+js_plugin_get_context(struct irc_plugin *);
+
+struct irc_plugin *
+js_plugin_open(const char *);
+
+struct irc_plugin_loader *
+js_plugin_loader_new(void);
+
+#endif /* !IRCCD_JS_PLUGIN_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-chrono.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,120 @@
+/*
+ * jsapi-chrono.c -- Irccd.Chrono API
+ *
+ * Copyright (c) 2013-2021 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 <stdbool.h>
+#include <time.h>
+
+#include <duktape.h>
+
+#include <irccd/util.h>
+
+#define SIGNATURE DUK_HIDDEN_SYMBOL("Irccd.Chrono")
+
+struct timer {
+	struct timespec start;
+};
+
+static struct timer *
+self(duk_context *ctx)
+{
+	struct timer *self;
+
+	duk_push_this(ctx);
+	duk_get_prop_string(ctx, -1, SIGNATURE);
+	self = duk_to_pointer(ctx, -1);
+	duk_pop_2(ctx);
+
+	if (!self)
+		(void)duk_error(ctx, DUK_ERR_TYPE_ERROR, "not an Chrono object");
+
+	return self;
+}
+
+static duk_ret_t
+Chrono_prototype_elapsed(duk_context *ctx)
+{
+	struct timer *timer = self(ctx);
+	struct timespec now = {0};
+
+	timespec_get(&now, TIME_UTC);
+
+	duk_push_uint(ctx,
+		((now.tv_sec * 1000) - (timer->start.tv_sec * 1000)) +
+		((now.tv_nsec / 1000000) - (timer->start.tv_nsec / 1000000)));
+
+	return 1;
+}
+
+static duk_ret_t
+Chrono_prototype_reset(duk_context *ctx)
+{
+	timespec_get(&self(ctx)->start, TIME_UTC);
+
+	return 0;
+}
+
+static duk_ret_t
+Chrono_constructor(duk_context *ctx)
+{
+	struct timer *timer;
+
+	timer = irc_util_calloc(1, sizeof (*timer));
+	timespec_get(&timer->start, TIME_UTC);
+
+	duk_push_this(ctx);
+	duk_push_pointer(ctx, timer);
+	duk_put_prop_string(ctx, -2, SIGNATURE);
+
+	/* this.elapsed property. */
+	duk_push_string(ctx, "elapsed");
+	duk_push_c_function(ctx, Chrono_prototype_elapsed, 0);
+	duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_GETTER);
+	duk_pop(ctx);
+
+	return 0;
+}
+
+static duk_ret_t
+Chrono_destructor(duk_context *ctx)
+{
+	duk_get_prop_string(ctx, 0, SIGNATURE);
+	free(duk_to_pointer(ctx, -1));
+	duk_pop(ctx);
+	duk_del_prop_string(ctx, 0, SIGNATURE);
+
+	return 0;
+}
+
+static const duk_function_list_entry methods[] = {
+	{ "reset",      Chrono_prototype_reset,         0 },
+	{ NULL,         NULL,                           0 }
+};
+
+void
+jsapi_chrono_load(duk_context *ctx)
+{
+	duk_get_global_string(ctx, "Irccd");
+	duk_push_c_function(ctx, Chrono_constructor, 0);
+	duk_push_object(ctx);
+	duk_put_function_list(ctx, -1, methods);
+	duk_push_c_function(ctx, Chrono_destructor, 1);
+	duk_set_finalizer(ctx, -2);
+	duk_put_prop_string(ctx, -2, "prototype");
+	duk_put_prop_string(ctx, -2, "Chrono");
+	duk_pop(ctx);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-chrono.h	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,27 @@
+/*
+ * jsapi-chrono.h -- Irccd.Chrono API
+ *
+ * Copyright (c) 2013-2021 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_JSAPI_CHRONO_H
+#define IRCCD_JSAPI_CHRONO_H
+
+#include <duktape.h>
+
+void
+jsapi_chrono_load(duk_context *);
+
+#endif /* !IRCCD_JSAPI_CHRONO_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-directory.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,425 @@
+/*
+ * jsapi-directory.c -- Irccd.Directory API
+ *
+ * Copyright (c) 2013-2021 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 <sys/stat.h>
+#include <assert.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <regex.h>
+#include <stdbool.h>
+#include <unistd.h>
+
+#if defined(_WIN32)
+#       include <windows.h>
+#endif
+
+#include <duktape.h>
+
+#include "jsapi-system.h"
+
+enum {
+	LIST_DOT = (1 << 0),
+	LIST_DOT_DOT = (1 << 1)
+};
+
+struct cursor {
+	char path[PATH_MAX];
+	char entry[FILENAME_MAX];
+	bool recursive;
+	void *data;
+	bool (*fn)(const struct cursor *);
+};
+
+struct finder {
+	union {
+		const char *pattern;
+		regex_t regex;
+	};
+	struct cursor curs;
+	void (*finish)(struct finder *);
+};
+
+static int
+recursedir(int dirfd, struct cursor *cs)
+{
+	DIR *dp;
+	struct dirent *entry;
+	struct stat st;
+	size_t entrylen;
+	int childfd, ret = 0;
+
+	if (!(dp = fdopendir(dirfd)))
+		return -1;
+
+	while ((entry = readdir(dp))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		if (fstatat(dirfd, entry->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
+			continue;
+
+		entrylen = strlen(entry->d_name);
+
+		/*
+		 * Append full path for the given entry.
+		 * e.g. /foo/bar/ -> /foo/bar/quux.txt
+		 */
+		strlcat(cs->path, entry->d_name, sizeof (cs->path));
+
+		/* Go recursively if it's a directory and activated. */
+		if (S_ISDIR(st.st_mode) && cs->recursive) {
+			strlcat(cs->path, "/", sizeof (cs->path));
+
+			entrylen += 1;
+	
+			if ((childfd = openat(dirfd, entry->d_name, O_RDONLY | O_DIRECTORY)) < 0)
+				continue;
+			if ((ret = recursedir(childfd, cs))) {
+				close(childfd);
+				goto stop;
+			}
+
+			close(childfd);
+		}
+
+		strlcpy(cs->entry, entry->d_name, sizeof (cs->entry));
+
+		if (cs->fn(cs)) {
+			ret = 1;
+			goto stop;
+		}
+
+		cs->path[strlen(cs->path) - entrylen] = '\0';
+	}
+stop:
+	closedir(dp);
+
+	return ret;
+}
+
+static int
+recurse(const char *path, struct cursor *cs)
+{
+	int fd, ret;
+	size_t pathlen;
+
+	if ((fd = open(path, O_RDONLY | O_DIRECTORY)) < 0)
+		return -1;
+
+	pathlen = strlen(path);
+
+	if (strlcpy(cs->path, path, sizeof (cs->path)) >= sizeof (cs->path))
+		return errno = ENOMEM, -1;
+	if (cs->path[pathlen - 1] != '/' && strlcat(cs->path, "/", sizeof (cs->path)) >= sizeof (cs->path))
+		return errno = ENOMEM, -1;
+
+	ret = recursedir(fd, cs);
+	close(fd);
+
+	return ret;
+}
+
+static inline const char *
+path(duk_context *ctx)
+{
+	const char *ret;
+
+	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");
+
+	ret = duk_get_string(ctx, -1);
+
+	if (!ret || !ret[0])
+		duk_error(ctx, DUK_ERR_TYPE_ERROR, "directory object has empty path");
+
+	duk_pop_n(ctx, 2);
+
+	return ret;
+}
+
+static bool
+find_regex(const struct cursor *curs)
+{
+	const struct finder *fd = curs->data;
+
+	return regexec(&fd->regex, curs->entry, 0, NULL, 0) == 0;
+}
+
+static bool
+find_name(const struct cursor *curs)
+{
+	const struct finder *fd = curs->data;
+
+	return strcmp(curs->entry, fd->pattern) == 0;
+}
+
+static void
+find_regex_finish(struct finder *fd)
+{
+	regfree(&fd->regex);
+}
+
+static int
+find_helper(duk_context *ctx, const char *base, bool recursive, int pattern_index)
+{
+	struct finder finder = {
+		.curs = {
+			.recursive = recursive,
+			.data = &finder,
+		}
+	};
+	int status;
+
+	if (duk_is_string(ctx, pattern_index)) {
+		finder.pattern = duk_get_string(ctx, pattern_index);
+		finder.curs.fn = find_name;
+	} else {
+		/* Check if it's a RegExp object. */
+		duk_get_global_string(ctx, "RegExp");
+
+		if (!duk_instanceof(ctx, pattern_index, -1))
+			/* TODO: better error. */
+			return duk_error(ctx, DUK_ERR_TYPE_ERROR, "pattern arg error");
+
+		duk_get_prop_string(ctx, pattern_index, "source");
+
+		if (regcomp(&finder.regex, duk_to_string(ctx, -1), REG_EXTENDED) != 0)
+			return duk_error(ctx, DUK_ERR_ERROR, "RegExp error");
+
+		finder.curs.fn = find_regex;
+		finder.finish = find_regex_finish;
+		duk_pop_n(ctx, 2);
+	}
+
+	status = recurse(base, &finder.curs);
+
+	if (finder.finish)
+		finder.finish(&finder);
+
+	if (status == 1)
+		duk_push_string(ctx, finder.curs.path);
+	else
+		duk_push_null(ctx);
+
+	return 1;
+}
+
+static bool
+rm(const struct cursor *curs)
+{
+	return remove(curs->path), false;
+}
+
+static int
+rm_helper(duk_context *ctx, const char *base, bool recursive)
+{
+	struct stat st;
+	struct cursor curs = {
+		.recursive = true,
+		.fn = rm
+	};
+
+	if (stat(base, &st) < 0)
+		return jsapi_system_raise(ctx), 0;
+	else if (!S_ISDIR(st.st_mode)) {
+		errno = ENOTDIR;
+		return jsapi_system_raise(ctx), 0;
+	}
+
+	if (recursive)
+		recurse(base, &curs);
+
+	remove(base);
+
+	return 0;
+}
+
+static inline void
+mkpath(duk_context *ctx, const char *path)
+{
+#ifdef _WIN32
+	/* TODO: convert code to errno. */
+	if (!CreateDirectoryA(path, NULL) && GetLastError() != ERROR_ALREADY_EXISTS) {
+		errno = EPERM;
+		jsapi_system_raise(ctx);
+#else
+	if (mkdir(path, 0755) < 0 && errno != EEXIST)
+		jsapi_system_raise(ctx);
+#endif
+}
+
+static inline char *
+normalize(char *str)
+{
+	for (char *p = str; *p; ++p)
+		if (*p == '\\')
+			*p = '/';
+
+	return str;
+}
+
+static int
+Directory_prototype_find(duk_context *ctx)
+{
+	return find_helper(ctx, path(ctx), duk_opt_boolean(ctx, 1, false), 0);
+}
+
+static int
+Directory_prototype_remove(duk_context *ctx)
+{
+	return rm_helper(ctx, path(ctx), duk_opt_boolean(ctx, 0, false));
+}
+
+static int
+Directory_constructor(duk_context *ctx)
+{
+	const char *path = duk_require_string(ctx, 0);
+	const int flags = duk_opt_int(ctx, 1, 0);
+	DIR *dp;
+	struct dirent *entry;
+
+	if (!duk_is_constructor_call(ctx))
+		return 0;
+
+	duk_push_this(ctx);
+
+	/* this.entries property. */
+	duk_push_string(ctx, "entries");
+	duk_push_array(ctx);
+
+	if (!(dp = opendir(path)))
+		jsapi_system_raise(ctx);
+
+	for (int i = 0; (entry = readdir(dp)); ) {
+		if (strcmp(entry->d_name, ".") == 0 && !(flags & LIST_DOT))
+			continue;
+		if (strcmp(entry->d_name, "..") == 0 && !(flags & LIST_DOT_DOT))
+			continue;
+
+		duk_push_object(ctx);
+		duk_push_string(ctx, entry->d_name);
+		duk_put_prop_string(ctx, -2, "name");
+		duk_push_int(ctx, entry->d_type);
+		duk_put_prop_string(ctx, -2, "type");
+		duk_put_prop_index(ctx, -2, i++);
+	}
+
+	closedir(dp);
+	duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE);
+
+	/* this.path property. */
+	duk_push_string(ctx, "path");
+	duk_push_string(ctx, path);
+	duk_def_prop(ctx, -3, DUK_DEFPROP_ENUMERABLE | DUK_DEFPROP_HAVE_VALUE);
+	duk_pop(ctx);
+
+	return 0;
+}
+
+static duk_ret_t
+Directory_find(duk_context *ctx)
+{
+	const char *path = duk_require_string(ctx, 0);
+	bool recursive = duk_opt_boolean(ctx, 2, false);
+
+	return find_helper(ctx, path, recursive, 1);
+}
+
+static duk_ret_t
+Directory_remove(duk_context* ctx)
+{
+	return rm_helper(ctx, duk_require_string(ctx, 0), duk_opt_boolean(ctx, 1, false));
+}
+
+static duk_ret_t
+Directory_mkdir(duk_context* ctx)
+{
+	char path[PATH_MAX], *p;
+
+	/* Copy the directory to normalize and iterate over '/'. */
+	strlcpy(path, duk_require_string(ctx, 0), sizeof (path));
+	normalize(path);
+
+#if defined(_WIN32)
+	/* Remove drive letter that we don't need. */
+	if ((p = strchr(path, ':')))
+		++p;
+	else
+		p = path;
+#else
+	p = path;
+#endif
+
+	for (p = p + 1; *p; ++p) {
+		if (*p == '/') {
+			*p = 0;
+			mkpath(ctx, path);
+			*p = '/';
+		}
+	}
+
+	mkpath(ctx, path);
+
+	return 0;
+}
+
+static const duk_function_list_entry methods[] = {
+	{ "find",               Directory_prototype_find,       DUK_VARARGS     },
+	{ "remove",             Directory_prototype_remove,     1               },
+	{ NULL,                 NULL,                           0               }
+};
+
+static const duk_function_list_entry functions[] = {
+	{ "find",               Directory_find,                 DUK_VARARGS     },
+	{ "mkdir",              Directory_mkdir,                DUK_VARARGS     },
+	{ "remove",             Directory_remove,               DUK_VARARGS     },
+	{ NULL,                 NULL,                           0               }
+};
+
+static const duk_number_list_entry constants[] = {
+	{ "Dot",                LIST_DOT        },
+	{ "DotDot",             LIST_DOT_DOT    },
+	{ "TypeFile",           DT_REG          },
+	{ "TypeDir",            DT_DIR          },
+	{ "TypeLink",           DT_LNK          },
+	{ "TypeBlock",          DT_BLK          },
+	{ "TypeCharacter",      DT_CHR          },
+	{ "TypeFifo",           DT_FIFO         },
+	{ "TypeSocket",         DT_SOCK         },
+	{ "TypeUnknown",        DT_UNKNOWN      },
+	{ NULL,                 0               }
+};
+
+void
+jsapi_directory_load(duk_context *ctx)
+{
+	assert(ctx);
+
+	duk_get_global_string(ctx, "Irccd");
+	duk_push_c_function(ctx, Directory_constructor, 2);
+	duk_put_number_list(ctx, -1, constants);
+	duk_put_function_list(ctx, -1, functions);
+	duk_push_object(ctx);
+	duk_put_function_list(ctx, -1, methods);
+	duk_put_prop_string(ctx, -2, "prototype");
+	duk_put_prop_string(ctx, -2, "Directory");
+	duk_pop(ctx);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-directory.h	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,27 @@
+/*
+ * jsapi-directory.h -- Irccd.Directory API
+ *
+ * Copyright (c) 2013-2021 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_JSAPI_DIRECTORY_H
+#define IRCCD_JSAPI_DIRECTORY_H
+
+#include <duktape.h>
+
+void
+jsapi_directory_load(duk_context *);
+
+#endif /* !IRCCD_JSAPI_DIRECTORY_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-file.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,521 @@
+/*
+ * jsapi-file.c -- Irccd.File API
+ *
+ * Copyright (c) 2013-2021 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 <compat.h>
+
+#include <sys/stat.h>
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <duktape.h>
+
+#include <irccd/util.h>
+
+#include "jsapi-file.h"
+#include "jsapi-system.h"
+
+#define SIGNATURE DUK_HIDDEN_SYMBOL("Irccd.File")
+#define PROTOTYPE DUK_HIDDEN_SYMBOL("Irccd.File.prototype")
+
+struct file {
+	char path[PATH_MAX];
+	FILE *fp;
+	int (*finalizer)(FILE *);
+};
+
+static int
+read_until_eof(duk_context *ctx, struct file *file)
+{
+	char *ret = NULL, *newret, buf[BUFSIZ];
+	size_t retsz = 0, nread;
+
+	/*
+	 * This function is shared with popen which can not be used with stat
+	 * so read the file by small piece of chunks and concat them until we
+	 * reach the end.
+	 */
+	while ((nread = fread(buf, 1, sizeof (buf), file->fp)) > 0) {
+		if (!(newret = realloc(ret, retsz + nread))) {
+			free(ret);
+			jsapi_system_raise(ctx);
+		}
+
+		ret = newret;
+		memcpy(ret + retsz, buf, nread);
+		retsz += nread;
+	}
+
+	if (ferror(file->fp)) {
+		free(ret);
+		jsapi_system_raise(ctx);
+	}
+
+	duk_push_lstring(ctx, ret, retsz);
+	free(ret);
+
+	return 1;
+}
+
+static int
+read_amount(duk_context *ctx, struct file *file, unsigned int amount)
+{
+	char *ret;
+	size_t nread;
+
+	if (!(ret = malloc(amount)))
+		jsapi_system_raise(ctx);
+
+	if ((nread = fread(ret, 1, amount, file->fp)) <= 0 || ferror(file->fp)) {
+		free(ret);
+		jsapi_system_raise(ctx);
+	}
+
+	duk_push_lstring(ctx, ret, nread);
+	free(ret);
+
+	return 1;
+}
+
+static void
+push_stat(duk_context *ctx, const struct stat *st)
+{
+	duk_push_object(ctx);
+
+#if defined(COMPAT_HAVE_STAT_ST_ATIME)
+	duk_push_int(ctx, st->st_atime);
+	duk_put_prop_string(ctx, -2, "atime");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_BLKSIZE)
+	duk_push_int(ctx, st->st_blksize);
+	duk_put_prop_string(ctx, -2, "blksize");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_BLOCKS)
+	duk_push_int(ctx, st->st_blocks);
+	duk_put_prop_string(ctx, -2, "blocks");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_CTIME)
+	duk_push_int(ctx, st->st_ctime);
+	duk_put_prop_string(ctx, -2, "ctime");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_DEV)
+	duk_push_int(ctx, st->st_dev);
+	duk_put_prop_string(ctx, -2, "dev");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_GID)
+	duk_push_int(ctx, st->st_gid);
+	duk_put_prop_string(ctx, -2, "gid");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_INO)
+	duk_push_int(ctx, st->st_ino);
+	duk_put_prop_string(ctx, -2, "ino");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_MODE)
+	duk_push_int(ctx, st->st_mode);
+	duk_put_prop_string(ctx, -2, "mode");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_MTIME)
+	duk_push_int(ctx, st->st_mtime);
+	duk_put_prop_string(ctx, -2, "mtime");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_NLINK)
+	duk_push_int(ctx, st->st_nlink);
+	duk_put_prop_string(ctx, -2, "nlink");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_RDEV)
+	duk_push_int(ctx, st->st_rdev);
+	duk_put_prop_string(ctx, -2, "rdev");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_SIZE)
+	duk_push_int(ctx, st->st_size);
+	duk_put_prop_string(ctx, -2, "size");
+#endif
+#if defined(COMPAT_HAVE_STAT_ST_UID)
+	duk_push_int(ctx, st->st_uid);
+	duk_put_prop_string(ctx, -2, "uid");
+#endif
+}
+
+static struct file *
+self(duk_context *ctx)
+{
+	struct file *file;
+
+	duk_push_this(ctx);
+	duk_get_prop_string(ctx, -1, SIGNATURE);
+	file = duk_to_pointer(ctx, -1);
+	duk_pop_2(ctx);
+
+	if (!file)
+		(void)duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a File object");
+
+	return file;
+}
+
+static duk_ret_t
+File_prototype_basename(duk_context *ctx)
+{
+	const struct file *file = self(ctx);
+
+	duk_push_string(ctx, irc_util_basename(file->path));
+
+	return 1;
+}
+
+static duk_ret_t
+File_prototype_close(duk_context *ctx)
+{
+	struct file *file = self(ctx);
+
+	if (file->fp) {
+		file->finalizer(file->fp);
+		file->fp = NULL;
+	}
+
+	return 0;
+}
+
+static duk_ret_t
+File_prototype_dirname(duk_context *ctx)
+{
+	const struct file *file = self(ctx);
+
+	duk_push_string(ctx, irc_util_dirname(file->path));
+
+	return 1;
+}
+
+static duk_ret_t
+File_prototype_lines(duk_context *ctx)
+{
+	struct file *file = self(ctx);
+	char *line = NULL;
+	size_t linesz = 0;
+
+	if (!file->fp) {
+		errno = EBADF;
+		jsapi_system_raise(ctx);
+	}
+
+	duk_push_array(ctx);
+
+	for (int i = 0; getline(&line, &linesz, file->fp) >= 0; ++i) {
+		line[strcspn(line, "\r\n")] = 0;
+
+		duk_push_string(ctx, line);
+		duk_put_prop_index(ctx, -2, i);
+	}
+
+	free(line);
+
+	if (ferror(file->fp))
+		jsapi_system_raise(ctx);
+
+	return 1;
+}
+
+static duk_ret_t
+File_prototype_read(duk_context *ctx)
+{
+	struct file *file = self(ctx);
+	unsigned int amount = duk_opt_uint(ctx, 0, -1);
+
+	if (!file->fp) {
+		errno = EBADF;
+		jsapi_system_raise(ctx);
+	}
+
+	return amount == -1U
+	    ? read_until_eof(ctx, file)
+	    : read_amount(ctx, file, amount);
+}
+
+static duk_ret_t
+File_prototype_readline(duk_context *ctx)
+{
+	const struct file *file = self(ctx);
+	char *line = NULL;
+	size_t linesz = 0;
+
+	if (!file->fp) {
+		errno = EBADF;
+		jsapi_system_raise(ctx);
+	}
+
+	if (getline(&line, &linesz, file->fp) < 0) {
+		free(line);
+
+		if (feof(file->fp))
+			return 0;
+
+		jsapi_system_raise(ctx);
+	}
+
+	line[strcspn(line, "\r\n")] = 0;
+	duk_push_string(ctx, line);
+	free(line);
+
+	return 1;
+}
+
+static duk_ret_t
+File_prototype_remove(duk_context *ctx)
+{
+	if (remove(self(ctx)->path) < 0)
+		jsapi_system_raise(ctx);
+
+	return 0;
+}
+
+static duk_ret_t
+File_prototype_seek(duk_context *ctx)
+{
+	const struct file *file = self(ctx);
+	const int type = duk_require_int(ctx, 0);
+	const long offset = duk_require_int(ctx, 1);
+
+	if (!file->fp || fseek(file->fp, offset, type) < 0)
+		jsapi_system_raise(ctx);
+
+	return 0;
+}
+
+static duk_ret_t
+File_prototype_stat(duk_context *ctx)
+{
+	const struct file *file = self(ctx);
+	struct stat st;
+
+	if (!file->fp || fstat(fileno(file->fp), &st) < 0)
+		jsapi_system_raise(ctx);
+
+	push_stat(ctx, &st);
+
+	return 0;
+}
+
+static duk_ret_t
+File_prototype_tell(duk_context *ctx)
+{
+	const struct file *file = self(ctx);
+	long position;
+
+	if (!file->fp || (position = ftell(file->fp)) < 0)
+		return jsapi_system_raise(ctx), 0;
+
+	duk_push_number(ctx, position);
+
+	return 1;
+}
+
+static duk_ret_t
+File_prototype_write(duk_context *ctx)
+{
+	const struct file *file = self(ctx);
+	size_t datasz = 0, written;
+	const char *data = duk_require_lstring(ctx, 0, &datasz);
+
+	if (!file->fp)
+		jsapi_system_raise(ctx);
+
+	written = fwrite(data, 1, datasz, file->fp);
+
+	if (ferror(file->fp))
+		jsapi_system_raise(ctx);
+
+	duk_push_uint(ctx, written);
+
+	return 1;
+}
+
+static duk_ret_t
+File_constructor(duk_context *ctx)
+{
+	const char *path = duk_require_string(ctx, 0);
+	const char *mode = duk_require_string(ctx, 1);
+	FILE *fp;
+	struct file *file;
+
+	if (!duk_is_constructor_call(ctx))
+		return 0;
+
+	if (!(fp = fopen(path, mode)))
+		jsapi_system_raise(ctx);
+
+	file = irc_util_calloc(1, sizeof (*file));
+	file->fp = fp;
+	file->finalizer = fclose;
+	strlcpy(file->path, path, sizeof (file->path));
+
+	duk_push_this(ctx);
+	duk_push_pointer(ctx, file);
+	duk_put_prop_string(ctx, -2, SIGNATURE);
+	duk_pop(ctx);
+
+	return 0;
+}
+
+static duk_ret_t
+File_destructor(duk_context *ctx)
+{
+	struct file *file;
+
+	duk_get_prop_string(ctx, 0, SIGNATURE);
+
+	if ((file = duk_to_pointer(ctx, -1)) && file->fp) {
+		file->finalizer(file->fp);
+		file->fp = NULL;
+		free(file);
+	}
+
+	duk_pop(ctx);
+	duk_del_prop_string(ctx, 0, SIGNATURE);
+
+	return 0;
+}
+
+static duk_ret_t
+File_basename(duk_context *ctx)
+{
+	const char *path = duk_require_string(ctx, 0);
+
+	duk_push_string(ctx, irc_util_basename(path));
+
+	return 1;
+}
+
+static duk_ret_t
+File_dirname(duk_context *ctx)
+{
+	const char *path = duk_require_string(ctx, 0);
+
+	duk_push_string(ctx, irc_util_dirname(path));
+
+	return 1;
+}
+
+static duk_ret_t
+File_exists(duk_context *ctx)
+{
+	const char *path = duk_require_string(ctx, 0);
+	struct stat st;
+
+	duk_push_boolean(ctx, stat(path, &st) == 0);
+
+	return 1;
+}
+
+static duk_ret_t
+File_remove(duk_context *ctx)
+{
+	const char *path = duk_require_string(ctx, 0);
+
+	if (remove(path) < 0)
+		jsapi_system_raise(ctx);
+
+	return 0;
+}
+
+static duk_ret_t
+File_stat(duk_context *ctx)
+{
+	const char *path = duk_require_string(ctx, 0);
+	struct stat st;
+
+	if (stat(path, &st) < 0)
+		jsapi_system_raise(ctx);
+
+	push_stat(ctx, &st);
+
+	return 0;
+}
+
+static const duk_function_list_entry methods[] = {
+	{ "basename",   File_prototype_basename,        0 },
+	{ "close",      File_prototype_close,           0 },
+	{ "dirname",    File_prototype_dirname,         0 },
+	{ "lines",      File_prototype_lines,           0 },
+	{ "read",       File_prototype_read,            1 },
+	{ "readline",   File_prototype_readline,        0 },
+	{ "remove",     File_prototype_remove,          0 },
+	{ "seek",       File_prototype_seek,            2 },
+	{ "stat",       File_prototype_stat,            0 },
+	{ "tell",       File_prototype_tell,            0 },
+	{ "write",      File_prototype_write,           1 },
+	{ NULL,         NULL,                           0 }
+};
+
+static const duk_function_list_entry functions[] = {
+	{ "basename",   File_basename,                  1 },
+	{ "dirname",    File_dirname,                   1 },
+	{ "exists",     File_exists,                    1 },
+	{ "remove",     File_remove,                    1 },
+	{ "stat",       File_stat,                      1 },
+	{ NULL,         NULL,                           0 }
+};
+
+static const duk_number_list_entry constants[] = {
+	{ "SeekCur",    SEEK_CUR                          },
+	{ "SeekEnd",    SEEK_END                          },
+	{ "SeekSet",    SEEK_SET                          },
+	{ NULL,         0                                 }
+};
+
+void
+jsapi_file_load(duk_context *ctx)
+{
+	assert(ctx);
+
+	duk_get_global_string(ctx, "Irccd");
+	duk_push_c_function(ctx, File_constructor, 2);
+	duk_put_number_list(ctx, -1, constants);
+	duk_put_function_list(ctx, -1, functions);
+	duk_push_object(ctx);
+	duk_put_function_list(ctx, -1, methods);
+	duk_push_c_function(ctx, File_destructor, 1);
+	duk_set_finalizer(ctx, -2);
+	duk_dup(ctx, -1);
+	duk_put_global_string(ctx, PROTOTYPE);
+	duk_put_prop_string(ctx, -2, "prototype");
+	duk_put_prop_string(ctx, -2, "File");
+	duk_pop(ctx);
+}
+
+void
+jsapi_file_push(duk_context *ctx, const char *path, FILE *fp, int (*finalizer)(FILE *))
+{
+	assert(ctx);
+	assert(fp);
+	assert(finalizer);
+
+	struct file file = {
+		.fp = fp,
+		.finalizer = finalizer
+	};
+
+	if (path)
+		strlcpy(file.path, path, sizeof (file.path));
+
+	duk_push_object(ctx);
+	duk_push_pointer(ctx, irc_util_memdup(&file, sizeof (file)));
+	duk_put_prop_string(ctx, -2, SIGNATURE);
+	duk_get_global_string(ctx, PROTOTYPE);
+	duk_set_prototype(ctx, -2);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-file.h	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,30 @@
+/*
+ * jsapi-file.h -- Irccd.File API
+ *
+ * Copyright (c) 2013-2021 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_JSAPI_FILE_H
+#define IRCCD_JSAPI_FILE_H
+
+#include <duktape.h>
+
+void
+jsapi_file_load(duk_context *);
+
+void
+jsapi_file_push(duk_context *, const char *, FILE *, int (*)(FILE *));
+
+#endif /* !IRCCD_JSAPI_FILE_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-irccd.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,334 @@
+/*
+ * jsapi-irccd.c -- Irccd API
+ *
+ * Copyright (c) 2013-2021 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 <errno.h>
+#include <string.h>
+
+#include <duktape.h>
+
+#include <irccd/util.h>
+
+#include "config.h"
+
+static int
+SystemError_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;
+}
+
+/* {{{ Constants for errno. */
+
+static const struct {
+	const char *name;
+	int value;
+} errors[] = {
+#if defined(E2BIG)
+	{ "E2BIG",              E2BIG           },
+#endif
+#if defined(EACCES)
+	{ "EACCES",             EACCES          },
+#endif
+#if defined(EADDRINUSE)
+	{ "EADDRINUSE",         EADDRINUSE      },
+#endif
+#if defined(EADDRNOTAVAIL)
+	{ "EADDRNOTAVAIL",      EADDRNOTAVAIL   },
+#endif
+#if defined(EAFNOSUPPORT)
+	{ "EAFNOSUPPORT",       EAFNOSUPPORT    },
+#endif
+#if defined(EAGAIN)
+	{ "EAGAIN",             EAGAIN          },
+#endif
+#if defined(EALREADY)
+	{ "EALREADY",           EALREADY        },
+#endif
+#if defined(EBADF)
+	{ "EBADF",              EBADF           },
+#endif
+#if defined(EBADMSG)
+	{ "EBADMSG",            EBADMSG         },
+#endif
+#if defined(EBUSY)
+	{ "EBUSY",              EBUSY           },
+#endif
+#if defined(ECANCELED)
+	{ "ECANCELED",          ECANCELED       },
+#endif
+#if defined(ECHILD)
+	{ "ECHILD",             ECHILD          },
+#endif
+#if defined(ECONNABORTED)
+	{ "ECONNABORTED",       ECONNABORTED    },
+#endif
+#if defined(ECONNREFUSED)
+	{ "ECONNREFUSED",       ECONNREFUSED    },
+#endif
+#if defined(ECONNREFUSED)
+	{ "ECONNRESET",         ECONNRESET      },
+#endif
+#if defined(EDEADLK)
+	{ "EDEADLK",            EDEADLK         },
+#endif
+#if defined(EDESTADDRREQ)
+	{ "EDESTADDRREQ",       EDESTADDRREQ    },
+#endif
+#if defined(EDOM)
+	{ "EDOM",               EDOM            },
+#endif
+#if defined(EEXIST)
+	{ "EEXIST",             EEXIST          },
+#endif
+#if defined(EFAULT)
+	{ "EFAULT",             EFAULT          },
+#endif
+#if defined(EFBIG)
+	{ "EFBIG",              EFBIG           },
+#endif
+#if defined(EHOSTUNREACH)
+	{ "EHOSTUNREACH",       EHOSTUNREACH    },
+#endif
+#if defined(EIDRM)
+	{ "EIDRM",              EIDRM           },
+#endif
+#if defined(EILSEQ)
+	{ "EILSEQ",             EILSEQ          },
+#endif
+#if defined(EINPROGRESS)
+	{ "EINPROGRESS",        EINPROGRESS     },
+#endif
+#if defined(EINTR)
+	{ "EINTR",              EINTR           },
+#endif
+#if defined(EINVAL)
+	{ "EINVAL",             EINVAL          },
+#endif
+#if defined(EIO)
+	{ "EIO",                EIO             },
+#endif
+#if defined(EISCONN)
+	{ "EISCONN",            EISCONN         },
+#endif
+#if defined(EISDIR)
+	{ "EISDIR",             EISDIR          },
+#endif
+#if defined(ELOOP)
+	{ "ELOOP",              ELOOP           },
+#endif
+#if defined(EMFILE)
+	{ "EMFILE",             EMFILE          },
+#endif
+#if defined(EMLINK)
+	{ "EMLINK",             EMLINK          },
+#endif
+#if defined(EMSGSIZE)
+	{ "EMSGSIZE",           EMSGSIZE        },
+#endif
+#if defined(ENAMETOOLONG)
+	{ "ENAMETOOLONG",       ENAMETOOLONG    },
+#endif
+#if defined(ENETDOWN)
+	{ "ENETDOWN",           ENETDOWN        },
+#endif
+#if defined(ENETRESET)
+	{ "ENETRESET",          ENETRESET       },
+#endif
+#if defined(ENETUNREACH)
+	{ "ENETUNREACH",        ENETUNREACH     },
+#endif
+#if defined(ENFILE)
+	{ "ENFILE",             ENFILE          },
+#endif
+#if defined(ENOBUFS)
+	{ "ENOBUFS",            ENOBUFS         },
+#endif
+#if defined(ENODATA)
+	{ "ENODATA",            ENODATA         },
+#endif
+#if defined(ENODEV)
+	{ "ENODEV",             ENODEV          },
+#endif
+#if defined(ENOENT)
+	{ "ENOENT",             ENOENT          },
+#endif
+#if defined(ENOEXEC)
+	{ "ENOEXEC",            ENOEXEC         },
+#endif
+#if defined(ENOLCK)
+	{ "ENOLCK",             ENOLCK          },
+#endif
+#if defined(ENOLINK)
+	{ "ENOLINK",            ENOLINK         },
+#endif
+#if defined(ENOMEM)
+	{ "ENOMEM",             ENOMEM          },
+#endif
+#if defined(ENOMSG)
+	{ "ENOMSG",             ENOMSG          },
+#endif
+#if defined(ENOPROTOOPT)
+	{ "ENOPROTOOPT",        ENOPROTOOPT     },
+#endif
+#if defined(ENOSPC)
+	{ "ENOSPC",             ENOSPC          },
+#endif
+#if defined(ENOSR)
+	{ "ENOSR",              ENOSR           },
+#endif
+#if defined(ENOSTR)
+	{ "ENOSTR",             ENOSTR          },
+#endif
+#if defined(ENOSYS)
+	{ "ENOSYS",             ENOSYS          },
+#endif
+#if defined(ENOTCONN)
+	{ "ENOTCONN",           ENOTCONN        },
+#endif
+#if defined(ENOTDIR)
+	{ "ENOTDIR",            ENOTDIR         },
+#endif
+#if defined(ENOTEMPTY)
+	{ "ENOTEMPTY",          ENOTEMPTY       },
+#endif
+#if defined(ENOTRECOVERABLE)
+	{ "ENOTRECOVERABLE",    ENOTRECOVERABLE },
+#endif
+#if defined(ENOTSOCK)
+	{ "ENOTSOCK",           ENOTSOCK        },
+#endif
+#if defined(ENOTSUP)
+	{ "ENOTSUP",            ENOTSUP         },
+#endif
+#if defined(ENOTTY)
+	{ "ENOTTY",             ENOTTY          },
+#endif
+#if defined(ENXIO)
+	{ "ENXIO",              ENXIO           },
+#endif
+#if defined(EOPNOTSUPP)
+	{ "EOPNOTSUPP",         EOPNOTSUPP      },
+#endif
+#if defined(EOVERFLOW)
+	{ "EOVERFLOW",          EOVERFLOW       },
+#endif
+#if defined(EOWNERDEAD)
+	{ "EOWNERDEAD",         EOWNERDEAD      },
+#endif
+#if defined(EPERM)
+	{ "EPERM",              EPERM           },
+#endif
+#if defined(EPIPE)
+	{ "EPIPE",              EPIPE           },
+#endif
+#if defined(EPROTO)
+	{ "EPROTO",             EPROTO          },
+#endif
+#if defined(EPROTONOSUPPORT)
+	{ "EPROTONOSUPPORT",    EPROTONOSUPPORT },
+#endif
+#if defined(EPROTOTYPE)
+	{ "EPROTOTYPE",         EPROTOTYPE      },
+#endif
+#if defined(ERANGE)
+	{ "ERANGE",             ERANGE          },
+#endif
+#if defined(EROFS)
+	{ "EROFS",              EROFS           },
+#endif
+#if defined(ESPIPE)
+	{ "ESPIPE",             ESPIPE          },
+#endif
+#if defined(ESRCH)
+	{ "ESRCH",              ESRCH           },
+#endif
+#if defined(ETIME)
+	{ "ETIME",              ETIME           },
+#endif
+#if defined(ETIMEDOUT)
+	{ "ETIMEDOUT",          ETIMEDOUT       },
+#endif
+#if defined(ETXTBSY)
+	{ "ETXTBSY",            ETXTBSY         },
+#endif
+#if defined(EWOULDBLOCK)
+	{ "EWOULDBLOCK",        EWOULDBLOCK     },
+#endif
+#if defined(EXDEV)
+	{ "EXDEV",              EXDEV           }
+#endif
+};
+
+/* }}} */
+
+static int
+print(duk_context *ctx)
+{
+	puts(duk_require_string(ctx, 0));
+
+	return 0;
+}
+
+void
+jsapi_load(duk_context *ctx)
+{
+	/* Irccd (global object) */
+	duk_push_object(ctx);
+
+	/* Irccd.version (property) */
+	duk_push_object(ctx);
+	duk_push_int(ctx, IRCCD_VERSION_MAJOR);
+	duk_put_prop_string(ctx, -2, "major");
+	duk_push_int(ctx, IRCCD_VERSION_MINOR);
+	duk_put_prop_string(ctx, -2, "minor");
+	duk_push_int(ctx, IRCCD_VERSION_PATCH);
+	duk_put_prop_string(ctx, -2, "patch");
+	duk_put_prop_string(ctx, -2, "version");
+
+	/* Create the system_error that inherits from Error. */
+	duk_push_c_function(ctx, SystemError_constructor, 2);
+
+	/* Put errno codes into the Irccd.SystemError object. */
+	for (size_t i = 0; i < IRC_UTIL_SIZE(errors); ++i) {
+		duk_push_int(ctx, errors[i].value);
+		duk_put_prop_string(ctx, -2, errors[i].name);
+	}
+
+	duk_push_object(ctx);
+	duk_get_global_string(ctx, "Error");
+	duk_get_prop_string(ctx, -1, "prototype");
+	duk_remove(ctx, -2);
+	duk_set_prototype(ctx, -2);
+	duk_put_prop_string(ctx, -2, "prototype");
+	duk_put_prop_string(ctx, -2, "SystemError");
+
+	/* Set Irccd as global. */
+	duk_put_global_string(ctx, "Irccd");
+
+	/* Convenient global "print" function. */
+	duk_push_c_function(ctx, print, 1);
+	duk_put_global_string(ctx, "print");
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-irccd.h	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,27 @@
+/*
+ * jsapi-irccd.h -- Irccd API
+ *
+ * Copyright (c) 2013-2021 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_JSAPI_IRCCD_H
+#define IRCCD_JSAPI_IRCCD_H
+
+#include <duktape.h>
+
+void
+jsapi_load(duk_context *);
+
+#endif /* !IRCCD_JSAPI_IRCCD_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-logger.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,74 @@
+/*
+ * jsapi-logger.c -- Irccd.Logger API
+ *
+ * Copyright (c) 2013-2021 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 <duktape.h>
+
+#include <irccd/plugin.h>
+#include <irccd/log.h>
+
+#include "jsapi-logger.h"
+#include "jsapi-plugin.h"
+
+#define LOG(c, f)                                                       \
+do {                                                                    \
+        const struct irc_plugin *p = jsapi_plugin_self(c);              \
+        const char *message = duk_require_string(c, 0);                 \
+                                                                        \
+        f("plugin %s: %s", p->name, message);                           \
+} while (0)                                                             \
+
+static duk_ret_t
+Logger_info(duk_context *ctx)
+{
+	LOG(ctx, irc_log_info);
+
+	return 0;
+}
+
+static duk_ret_t
+Logger_warning(duk_context *ctx)
+{
+	LOG(ctx, irc_log_warn);
+
+	return 0;
+}
+
+static duk_ret_t
+Logger_debug(duk_context *ctx)
+{
+	LOG(ctx, irc_log_debug);
+
+	return 0;
+}
+
+static const duk_function_list_entry functions[] = {
+	{ "info",       Logger_info,    1 },
+	{ "warning",    Logger_warning, 1 },
+	{ "debug",      Logger_debug,   1 },
+	{ NULL,         NULL,           0 }
+};
+
+void
+jsapi_logger_load(duk_context *ctx)
+{
+	duk_get_global_string(ctx, "Irccd");
+	duk_push_object(ctx);
+	duk_put_function_list(ctx, -1, functions);
+	duk_put_prop_string(ctx, -2, "Logger");
+	duk_pop(ctx);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-logger.h	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,27 @@
+/*
+ * jsapi-logger.h -- Irccd.Logger API
+ *
+ * Copyright (c) 2013-2021 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_JSAPI_LOGGER_H
+#define IRCCD_JSAPI_LOGGER_H
+
+#include <duktape.h>
+
+void
+jsapi_logger_load(duk_context *);
+
+#endif /* !IRCCD_JSAPI_LOGGER_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-plugin.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,265 @@
+/*
+ * jsapi-plugin.c -- Irccd.Plugin API
+ *
+ * Copyright (c) 2013-2021 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 <stdbool.h>
+
+#include <irccd/irccd.h>
+#include <irccd/plugin.h>
+
+#include "jsapi-plugin.h"
+
+#define SIGNATURE DUK_HIDDEN_SYMBOL("Irccd.Plugin")
+
+/*
+ * set
+ * ------------------------------------------------------------------
+ *
+ * This setter is used to replace the Irccd.Plugin.(config|templates|paths)
+ * 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 'templates' 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 sets:
+ *
+ *     mode = "hard"
+ *     path = "/var"
+ *
+ * The final user table looks like this:
+ *
+ * Irccd.Plugin.config = {
+ *     mode: "hard",
+ *     level: "123",
+ *     path: "/var"
+ * };
+ */
+static duk_ret_t
+set(duk_context *ctx, const char *name)
+{
+	/* This is the object received in argument from the property setter. */
+	if (!duk_is_object(ctx, 0))
+		return 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|templates|paths) property.
+ */
+static duk_ret_t
+get(duk_context *ctx, const char *name)
+{
+	duk_get_global_string(ctx, name);
+
+	return 1;
+}
+
+static duk_ret_t
+set_config(duk_context *ctx)
+{
+	return set(ctx, JSAPI_PLUGIN_PROP_OPTIONS);
+}
+
+static duk_ret_t
+get_config(duk_context *ctx)
+{
+	return get(ctx, JSAPI_PLUGIN_PROP_OPTIONS);
+}
+
+static duk_ret_t
+set_template(duk_context *ctx)
+{
+	return set(ctx, JSAPI_PLUGIN_PROP_TEMPLATES);
+}
+
+static duk_ret_t
+get_template(duk_context *ctx)
+{
+	return get(ctx, JSAPI_PLUGIN_PROP_TEMPLATES);
+}
+
+static duk_ret_t
+set_paths(duk_context *ctx)
+{
+	return set(ctx, JSAPI_PLUGIN_PROP_PATHS);
+}
+
+static duk_ret_t
+get_paths(duk_context *ctx)
+{
+	return get(ctx, JSAPI_PLUGIN_PROP_PATHS);
+}
+
+static struct irc_plugin *
+find(duk_context *ctx)
+{
+	const char *name = duk_require_string(ctx, 0);
+	struct irc_plugin *plg = irc_bot_plugin_get(name);
+
+	if (!plg)
+		(void)duk_error(ctx, DUK_ERR_REFERENCE_ERROR, "plugin %s not found", name);
+
+	return plg;
+}
+
+static duk_ret_t
+Plugin_info(duk_context *ctx)
+{
+	struct irc_plugin *p;
+
+	if (duk_get_top(ctx) >= 1)
+		p = find(ctx);
+	else
+		p = jsapi_plugin_self(ctx);
+
+	if (!p)
+		return 0;
+
+	duk_push_object(ctx);
+	duk_push_string(ctx, p->author);
+	duk_put_prop_string(ctx, -2, "author");
+	duk_push_string(ctx, p->license);
+	duk_put_prop_string(ctx, -2, "license");
+	duk_push_string(ctx, p->description);
+	duk_put_prop_string(ctx, -2, "summary");
+	duk_push_string(ctx, p->version);
+	duk_put_prop_string(ctx, -2, "version");
+
+	return 1;
+}
+
+static duk_ret_t
+Plugin_list(duk_context *ctx)
+{
+	size_t i = 0;
+	struct irc_plugin *p;
+
+	duk_push_array(ctx);
+
+	LIST_FOREACH(p, &irc.plugins, link) {
+		duk_push_string(ctx, p->name);
+		duk_put_prop_index(ctx, -2, i++);
+	}
+
+	return 1;
+}
+
+static duk_ret_t
+Plugin_load(duk_context *ctx)
+{
+	(void)ctx;
+
+	return 0;
+}
+
+static duk_ret_t
+Plugin_reload(duk_context *ctx)
+{
+	irc_plugin_reload(find(ctx));
+
+	return 0;
+}
+
+static duk_ret_t
+Plugin_unload(duk_context *ctx)
+{
+	/* Use find so it can raise ReferenceError if not found. */
+	irc_bot_plugin_remove(find(ctx)->name);
+
+	return 0;
+}
+
+static const duk_function_list_entry functions[] = {
+	{ "info",       Plugin_info,    DUK_VARARGS     },
+	{ "list",       Plugin_list,    0               },
+	{ "load",       Plugin_load,    1               },
+	{ "reload",     Plugin_reload,  1               },
+	{ "unload",     Plugin_unload,  1               },
+	{ NULL,         NULL,           0               }
+};
+
+void
+jsapi_plugin_load(duk_context *ctx, struct irc_plugin *p)
+{
+	/* Store plugin. */
+	duk_push_pointer(ctx, p);
+	duk_put_global_string(ctx, SIGNATURE);
+
+	duk_get_global_string(ctx, "Irccd");
+	duk_push_object(ctx);
+	duk_put_function_list(ctx, -1, functions);
+
+	/* 'config' property. */
+	duk_push_string(ctx, "config");
+	duk_push_c_function(ctx, get_config, 0);
+	duk_push_c_function(ctx, set_config, 1);
+	duk_def_prop(ctx, -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);
+
+	/* 'templates' property. */
+	duk_push_string(ctx, "templates");
+	duk_push_c_function(ctx, get_template, 0);
+	duk_push_c_function(ctx, set_template, 1);
+	duk_def_prop(ctx, -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);
+
+	/* 'paths' property. */
+	duk_push_string(ctx, "paths");
+	duk_push_c_function(ctx, get_paths, 0);
+	duk_push_c_function(ctx, set_paths, 1);
+	duk_def_prop(ctx, -4, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);
+
+	duk_put_prop_string(ctx, -2, "Plugin");
+	duk_pop(ctx);
+}
+
+struct irc_plugin *
+jsapi_plugin_self(duk_context *ctx)
+{
+	struct irc_plugin *p;
+
+	duk_get_global_string(ctx, SIGNATURE);
+	p = duk_to_pointer(ctx, -1);
+	duk_pop(ctx);
+
+	return p;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-plugin.h	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,36 @@
+/*
+ * jsapi-plugin.h -- Javascript plugins
+ *
+ * Copyright (c) 2013-2021 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_JSAPI_PLUGIN_H
+#define IRCCD_JSAPI_PLUGIN_H
+
+#include <duktape.h>
+
+#define JSAPI_PLUGIN_PROP_OPTIONS       DUK_HIDDEN_SYMBOL("options")
+#define JSAPI_PLUGIN_PROP_TEMPLATES     DUK_HIDDEN_SYMBOL("templates")
+#define JSAPI_PLUGIN_PROP_PATHS         DUK_HIDDEN_SYMBOL("paths")
+
+struct irc_plugin;
+
+void
+jsapi_plugin_load(duk_context *, struct irc_plugin *);
+
+struct irc_plugin *
+jsapi_plugin_self(duk_context *);
+
+#endif /* !IRCCD_JSAPI_PLUGIN_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-server.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,601 @@
+/*
+ * jsapi-server.c -- Irccd.Server API
+ *
+ * Copyright (c) 2013-2021 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 <assert.h>
+
+#include <duktape.h>
+
+#include <irccd/channel.h>
+#include <irccd/irccd.h>
+#include <irccd/server.h>
+#include <irccd/util.h>
+
+#include "jsapi-server.h"
+
+#define SIGNATURE DUK_HIDDEN_SYMBOL("Irccd.Server")
+#define PROTOTYPE DUK_HIDDEN_SYMBOL("Irccd.Server.prototype")
+
+static struct irc_server *
+self(duk_context *ctx)
+{
+	struct irc_server *sv;
+
+	duk_push_this(ctx);
+	duk_get_prop_string(ctx, -1, SIGNATURE);
+	sv = duk_to_pointer(ctx, -1);
+	duk_pop_2(ctx);
+
+	if (!sv)
+		(void)duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Server object");
+
+	return sv;
+}
+
+static struct irc_server *
+require(duk_context *ctx, duk_idx_t index)
+{
+	struct irc_server *sv;
+
+	if (!duk_is_object(ctx, index) || !duk_has_prop_string(ctx, index, SIGNATURE))
+		(void)duk_error(ctx, DUK_ERR_TYPE_ERROR, "not a Server object");
+
+	duk_get_prop_string(ctx, index, SIGNATURE);
+	sv = duk_to_pointer(ctx, -1);
+	duk_pop(ctx);
+
+	return sv;
+}
+
+static inline unsigned short
+get_port(duk_context *ctx)
+{
+	unsigned short port;
+
+	duk_get_prop_string(ctx, 0, "port");
+
+	if (!duk_is_number(ctx, -1))
+		(void)duk_error(ctx, DUK_ERR_ERROR, "invalid 'port' property");
+
+	port = duk_to_int(ctx, -1);
+	duk_pop(ctx);
+
+	return port;
+}
+
+static inline const char *
+get_string(duk_context *ctx, const char *n)
+{
+	const char *ret;
+
+	duk_get_prop_string(ctx, 0, n);
+
+	if (!duk_is_string(ctx, -1))
+		(void)duk_error(ctx, DUK_ERR_ERROR, "invalid or missing '%s' property", n);
+
+	ret = duk_to_string(ctx, -1);
+	duk_pop(ctx);
+
+	return ret;
+}
+
+static inline void
+get_ip(duk_context *ctx, struct irc_server *s)
+{
+	enum irc_server_flags flags = IRC_SERVER_FLAGS_IPV4 |
+				      IRC_SERVER_FLAGS_IPV6;
+
+	duk_get_prop_string(ctx, 0, "ipv4");
+	duk_get_prop_string(ctx, 0, "ipv6");
+
+	if (duk_is_boolean(ctx, -1) && !duk_to_boolean(ctx, -1))
+		flags &= ~(IRC_SERVER_FLAGS_IPV4);
+	if (duk_is_boolean(ctx, -2) && !duk_to_boolean(ctx, -2))
+		flags &= ~(IRC_SERVER_FLAGS_IPV6);
+
+	s->flags |= flags;
+	duk_pop_n(ctx, 2);
+}
+
+static inline void
+get_ssl(duk_context *ctx, struct irc_server *s)
+{
+	duk_get_prop_string(ctx, 0, "ssl");
+
+	if (duk_is_boolean(ctx, -1) && duk_to_boolean(ctx, -1))
+		s->flags |= IRC_SERVER_FLAGS_SSL;
+
+	duk_pop(ctx);
+}
+
+static inline void
+get_channels(duk_context *ctx, struct irc_server *s)
+{
+	duk_get_prop_string(ctx, 0, "channels");
+
+	for (duk_enum(ctx, -1, 0); duk_next(ctx, -1, true); ) {
+		duk_get_prop_string(ctx, -1, "name");
+		duk_get_prop_string(ctx, -2, "password");
+
+		if (!duk_is_string(ctx, -2))
+			(void)duk_error(ctx, DUK_ERR_ERROR, "invalid channel 'name' property");
+
+		irc_server_join(s, duk_to_string(ctx, -2), duk_opt_string(ctx, -1, NULL));
+		duk_pop_n(ctx, 4);
+	}
+
+	duk_pop_n(ctx, 2);
+}
+
+static duk_ret_t
+Server_prototype_info(duk_context *ctx)
+{
+	const struct irc_server *s = self(ctx);
+	const struct irc_channel *c;
+	const struct irc_channel_user *u;
+	size_t ci = 0, ui = 0;
+
+	duk_push_object(ctx);
+	duk_push_string(ctx, s->name);
+	duk_put_prop_string(ctx, -2, "name");
+	duk_push_string(ctx, s->conn.hostname);
+	duk_put_prop_string(ctx, -2, "hostname");
+	duk_push_uint(ctx, s->conn.port);
+	duk_put_prop_string(ctx, -2, "port");
+	duk_push_boolean(ctx, s->flags & IRC_SERVER_FLAGS_SSL);
+	duk_put_prop_string(ctx, -2, "ssl");
+	duk_push_string(ctx, s->commandchar);
+	duk_put_prop_string(ctx, -2, "commandChar");
+	duk_push_string(ctx, s->ident.realname);
+	duk_put_prop_string(ctx, -2, "realname");
+	duk_push_string(ctx, s->ident.nickname);
+	duk_put_prop_string(ctx, -2, "nickname");
+	duk_push_string(ctx, s->ident.username);
+	duk_put_prop_string(ctx, -2, "username");
+
+	duk_push_array(ctx);
+
+	LIST_FOREACH(c, &s->channels, link) {
+		duk_push_object(ctx);
+		duk_push_string(ctx, c->name);
+		duk_put_prop_string(ctx, -2, "name");
+		duk_push_boolean(ctx, c->joined);
+		duk_put_prop_string(ctx, -2, "joined");
+		duk_push_array(ctx);
+
+		LIST_FOREACH(u, &c->users, link) {
+			duk_push_object(ctx);
+			duk_push_string(ctx, u->nickname);
+			duk_put_prop_string(ctx, -2, "nickname");
+			if (u->mode)
+				duk_push_sprintf(ctx, "%c", u->mode);
+			else
+				duk_push_null(ctx);
+			duk_put_prop_string(ctx, -2, "mode");
+			duk_put_prop_index(ctx, -2, ui++);
+		}
+
+		duk_put_prop_string(ctx, -2, "users");
+		duk_put_prop_index(ctx, -2, ci++);
+	}
+
+	duk_put_prop_string(ctx, -2, "channels");
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_invite(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *target = duk_require_string(ctx, 0);
+	const char *channel = duk_require_string(ctx, 1);
+
+#if 0
+	if (!*target || !*channel)
+		throw server_error(server_error::invalid_nickname);
+	if (channel.empty())
+		throw server_error(server_error::invalid_channel);
+#endif
+
+	duk_push_boolean(ctx, irc_server_invite(s, target, channel));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_isSelf(duk_context *ctx)
+{
+	(void)ctx;
+#if 0
+	return wrap(ctx, [] (auto ctx) {
+		return duk::push(ctx, self(ctx)->is_self(duk::require<std::string>(ctx, 0)));
+	});
+#endif
+
+	return 0;
+}
+
+static duk_ret_t
+Server_prototype_join(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *channel = duk_require_string(ctx, 0);
+	const char *password = duk_opt_string(ctx, 1, NULL);
+
+#if 0
+	if (channel.empty())
+		throw server_error(server_error::invalid_channel);
+#endif
+
+	duk_push_boolean(ctx, irc_server_join(s, channel, password));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_kick(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *target = duk_require_string(ctx, 0);
+	const char *channel = duk_require_string(ctx, 1);
+	const char *reason = duk_opt_string(ctx, 2, NULL);
+
+#if 0
+	if (target.empty())
+		throw server_error(server_error::invalid_nickname);
+	if (channel.empty())
+		throw server_error(server_error::invalid_channel);
+#endif
+
+	duk_push_boolean(ctx, irc_server_kick(s, target, channel, reason));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_me(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *target = duk_require_string(ctx, 0);
+	const char *message = duk_require_string(ctx, 1);
+
+#if 0
+	if (target.empty())
+		throw server_error(server_error::invalid_nickname);
+#endif
+
+	duk_push_boolean(ctx, irc_server_me(s, target, message));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_message(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *target = duk_require_string(ctx, 0);
+	const char *message = duk_require_string(ctx, 1);
+
+#if 0
+	if (target.empty())
+		throw server_error(server_error::invalid_nickname);
+#endif
+
+	duk_push_boolean(ctx, irc_server_message(s, target, message));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_mode(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *channel = duk_require_string(ctx, 0);
+	const char *mode = duk_require_string(ctx, 1);
+	const char *limit = duk_opt_string(ctx, 2, NULL);
+	const char *user = duk_opt_string(ctx, 3, NULL);
+	const char *mask = duk_opt_string(ctx, 4, NULL);
+
+#if 0
+	if (channel.empty())
+		throw server_error(server_error::invalid_channel);
+	if (mode.empty())
+		throw server_error(server_error::invalid_mode);
+#endif
+
+	duk_push_boolean(ctx, irc_server_mode(s, channel, mode, limit, user, mask));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_names(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *channel = duk_require_string(ctx, 0);
+
+#if 0
+	if (channel.empty())
+		throw server_error(server_error::invalid_channel);
+#endif
+
+	duk_push_boolean(ctx, irc_server_names(s, channel));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_nick(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *nickname = duk_require_string(ctx, 0);
+
+#if 0
+	if (nickname.empty())
+		throw server_error(server_error::invalid_nickname);
+#endif
+
+	duk_push_boolean(ctx, irc_server_nick(s, nickname));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_notice(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *target = duk_require_string(ctx, 0);
+	const char *message = duk_opt_string(ctx, 1, NULL);
+
+#if 0
+	if (target.empty())
+		throw server_error(server_error::invalid_nickname);
+#endif
+
+	duk_push_boolean(ctx, irc_server_notice(s, target, message));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_part(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *channel = duk_require_string(ctx, 0);
+	const char *reason = duk_opt_string(ctx, 1, NULL);
+
+#if 0
+	if (channel.empty())
+		throw server_error(server_error::invalid_channel);
+#endif
+
+	duk_push_boolean(ctx, irc_server_part(s, channel, reason));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_send(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *raw = duk_require_string(ctx, 0);
+
+#if 0
+	if (raw.empty())
+		throw server_error(server_error::invalid_message);
+#endif
+
+	duk_push_boolean(ctx, irc_server_send(s, raw));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_topic(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *channel = duk_require_string(ctx, 0);
+	const char *topic = duk_require_string(ctx, 1);
+
+#if 0
+	if (channel.empty())
+		throw server_error(server_error::invalid_channel);
+#endif
+
+	duk_push_boolean(ctx, irc_server_topic(s, channel, topic));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_whois(duk_context *ctx)
+{
+	struct irc_server *s = self(ctx);
+	const char *target = duk_require_string(ctx, 0);
+
+#if 0
+	if (target.empty())
+		throw server_error(server_error::invalid_nickname);
+#endif
+
+	duk_push_boolean(ctx, irc_server_whois(s, target));
+
+	return 1;
+}
+
+static duk_ret_t
+Server_prototype_toString(duk_context *ctx)
+{
+	duk_push_string(ctx, self(ctx)->name);
+
+	return 1;
+}
+
+static duk_ret_t
+Server_constructor(duk_context *ctx)
+{
+	struct irc_server *s;
+
+	duk_require_object(ctx, 0);
+
+	s = irc_server_new(
+	    get_string(ctx, "name"),
+	    get_string(ctx, "nickname"),
+	    get_string(ctx, "username"),
+	    get_string(ctx, "realname"),
+	    get_string(ctx, "hostname"),
+	    get_port(ctx)
+	);
+
+	get_ip(ctx, s);
+	get_ssl(ctx, s);
+	get_channels(ctx, s);
+
+	irc_server_incref(s);
+
+	duk_push_this(ctx);
+	duk_push_pointer(ctx, s);
+	duk_put_prop_string(ctx, -2, SIGNATURE);
+	duk_pop(ctx);
+
+	return 0;
+}
+
+static duk_ret_t
+Server_destructor(duk_context *ctx)
+{
+	struct irc_server *sv;
+
+	duk_get_prop_string(ctx, 0, SIGNATURE);
+
+	if ((sv = duk_to_pointer(ctx, -1)))
+		irc_server_decref(sv);
+
+	duk_pop(ctx);
+	duk_del_prop_string(ctx, 0, SIGNATURE);
+
+	return 0;
+}
+
+static duk_ret_t
+Server_add(duk_context *ctx)
+{
+	irc_bot_server_add(require(ctx, 0));
+
+	return 0;
+}
+
+static duk_ret_t
+Server_find(duk_context *ctx)
+{
+	const char *name = duk_require_string(ctx, 0);
+	struct irc_server *s = irc_bot_server_find(name);
+
+	if (!s)
+		return 0;
+
+	jsapi_server_push(ctx, s);
+
+	return 1;
+}
+
+static duk_ret_t
+Server_list(duk_context *ctx)
+{
+	struct irc_server *s;
+
+	duk_push_object(ctx);
+
+	LIST_FOREACH(s, &irc.servers, link) {
+		jsapi_server_push(ctx, s);
+		duk_put_prop_string(ctx, -2, s->name);
+	}
+
+	return 1;
+}
+
+static duk_ret_t
+Server_remove(duk_context *ctx)
+{
+	irc_bot_server_remove(duk_require_string(ctx, 0));
+
+	return 0;
+}
+
+static const duk_function_list_entry methods[] = {
+	{ "info",       Server_prototype_info,          0               },
+	{ "invite",     Server_prototype_invite,        2               },
+	{ "isSelf",     Server_prototype_isSelf,        1               },
+	{ "join",       Server_prototype_join,          DUK_VARARGS     },
+	{ "kick",       Server_prototype_kick,          DUK_VARARGS     },
+	{ "me",         Server_prototype_me,            2               },
+	{ "message",    Server_prototype_message,       2               },
+	{ "mode",       Server_prototype_mode,          1               },
+	{ "names",      Server_prototype_names,         1               },
+	{ "nick",       Server_prototype_nick,          1               },
+	{ "notice",     Server_prototype_notice,        2               },
+	{ "part",       Server_prototype_part,          DUK_VARARGS     },
+	{ "send",       Server_prototype_send,          1               },
+	{ "topic",      Server_prototype_topic,         2               },
+	{ "toString",   Server_prototype_toString,      0               },
+	{ "whois",      Server_prototype_whois,         1               },
+	{ NULL,         NULL,                           0               }
+};
+
+static const duk_function_list_entry functions[] = {
+	{ "add",        Server_add,                     1               },
+	{ "find",       Server_find,                    1               },
+	{ "list",       Server_list,                    0               },
+	{ "remove",     Server_remove,                  1               },
+	{ NULL,         NULL,                           0               }
+};
+
+void
+jsapi_server_load(duk_context *ctx)
+{
+	assert(ctx);
+
+	duk_get_global_string(ctx, "Irccd");
+
+	duk_push_c_function(ctx, Server_constructor, 1);
+	duk_put_function_list(ctx, -1, functions);
+	duk_push_object(ctx);
+	duk_put_function_list(ctx, -1, methods);
+	duk_push_c_function(ctx, Server_destructor, 1);
+	duk_set_finalizer(ctx, -2);
+	duk_dup_top(ctx);
+	duk_put_global_string(ctx, PROTOTYPE);
+	duk_put_prop_string(ctx, -2, "prototype");
+	duk_put_prop_string(ctx, -2, "Server");
+	duk_pop(ctx);
+}
+
+void
+jsapi_server_push(duk_context *ctx, struct irc_server *s)
+{
+	assert(ctx);
+	assert(s);
+
+	irc_server_incref(s);
+
+	duk_push_object(ctx);
+	duk_push_pointer(ctx, s);
+	duk_put_prop_string(ctx, -2, SIGNATURE);
+	duk_get_global_string(ctx, PROTOTYPE);
+	duk_set_prototype(ctx, -2);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-server.h	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,32 @@
+/*
+ * jsapi-server.c -- Irccd.Server API
+ *
+ * Copyright (c) 2013-2021 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_JSAPI_SERVER_H
+#define IRCCD_JSAPI_SERVER_H
+
+#include <duktape.h>
+
+struct irc_server;
+
+void
+jsapi_server_push(duk_context *, struct irc_server *);
+
+void
+jsapi_server_load(duk_context *);
+
+#endif /* IRCCD_JSAPI_SERVER_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/irccd/jsapi-system.c	Fri Jan 29 15:03:23 2021 +0100
@@ -0,0 +1,250 @@
+/*
+ * jsapi-system.c -- Irccd.System API
+ *
+ * Copyright (c) 2013-2021 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 <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#if defined(_WIN32)
+#       include <windows.h>
+#elif defined(__linux__)
+#       include <sys/sysinfo.h>
+#elif defined(__APPLE__)
+#       include <sys/types.h>
+#       include <sys/sysctl.h>
+#endif
+
+#if !defined(_WIN32)
+#       include <sys/utsname.h>
+#endif
+
+#include <duktape.h>
+
+#include "jsapi-file.h"
+#include "jsapi-system.h"
+
+static duk_ret_t
+nsleep(unsigned long ns)
+{
+	struct timespec ts = {
+		.tv_sec = ns / 1000000000L,
+		.tv_nsec = (ns % 1000000000L),
+	};
+
+	while (nanosleep(&ts, &ts) && errno == EINTR);
+
+	return 0;
+}
+
+static duk_ret_t
+System_env(duk_context *ctx)
+{
+	const char *name = duk_require_string(ctx, 0);
+	const char *value = getenv(name);
+
+	if (!value)
+		duk_push_null(ctx);
+	else
+		duk_push_string(ctx, value);
+
+	return 1;
+}
+
+static duk_ret_t
+System_exec(duk_context *ctx)
+{
+	duk_push_uint(ctx, system(duk_require_string(ctx, 0)));
+
+	return 1;
+}
+
+static duk_ret_t
+System_home(duk_context *ctx)
+{
+#if defined(_WIN32)
+	char path[MAX_PATH] = {0};
+
+	SHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, path);
+
+	duk_push_string(ctx, path);
+#else
+	const char *home;
+
+	if ((home = getenv("HOME")))
+		duk_push_string(ctx, home);
+	else
+		duk_push_undefined(ctx);
+#endif
+
+	return 1;
+}
+
+static duk_ret_t
+System_name(duk_context *ctx)
+{
+#if defined(__linux__)
+	duk_push_string(ctx, "Linux");
+#elif defined(_WIN32)
+	duk_push_string(ctx, "Windows");
+#elif defined(__FreeBSD__)
+	duk_push_string(ctx, "FreeBSD");
+#elif defined(__DragonFly__)
+	duk_push_string(ctx, "DragonFlyBSD");
+#elif defined(__OpenBSD__)
+	duk_push_string(ctx, "OpenBSD");
+#elif defined(__NetBSD__)
+	duk_push_string(ctx, "NetBSD");
+#elif defined(__APPLE__)
+	duk_push_string(ctx, "macOS");
+#elif defined(__ANDROID__)
+	duk_push_string(ctx, "Android");
+#elif defined(_AIX)
+	duk_push_string(ctx, "Aix");
+#elif defined(__HAIKU__)
+	duk_push_string(ctx, "Haiku");
+#elif defined(sun)
+	duk_push_string(ctx, "Solaris");
+#else
+	duk_push_string(ctx, "Unknown");
+#endif
+
+	return 1;
+}
+
+static duk_ret_t
+System_popen(duk_context *ctx)
+{
+	const char *cmd = duk_require_string(ctx, 0);
+	const char *mode = duk_require_string(ctx, 1);
+	FILE *fp;
+
+	if (!(fp = popen(cmd, mode)))
+		jsapi_system_raise(ctx);
+
+	jsapi_file_push(ctx, NULL, fp, pclose);
+
+	return 1;
+}
+
+static duk_ret_t
+System_sleep(duk_context *ctx)
+{
+	return nsleep(duk_require_uint(ctx, 0) * 1000000000L);
+}
+
+static duk_ret_t
+System_usleep(duk_context *ctx)
+{
+	return nsleep(duk_require_uint(ctx, 0) * 1000);
+}
+
+static duk_ret_t
+System_uptime(duk_context *ctx)
+{
+#if defined(_WIN32)
+	duk_push_uint(ctx, GetTickCount64() / 1000);
+#elif defined(__linux__)
+	struct sysinfo info;
+
+	if (sysinfo(&info) < 0)
+		irc_jsapi_system_raise(ctx);
+
+	duk_push_uint(ctx, info.uptime);
+#elif defined(__APPLE__)
+	struct timeval boottime;
+	size_t length = sizeof (boottime);
+	int mib[2] = { CTL_KERN, KERN_BOOTTIME };
+	time_t bsec, csec;
+
+	if (sysctl(mib, 2, &boottime, &length, NULL, 0) < 0)
+		jsapi_system_raise(ctx);
+
+	bsec = boottime.tv_sec;
+	csec = time(NULL);
+
+	duk_push_uint(ctx, difftime(csec, bsec));
+#else
+	struct timespec ts;
+
+	/* Mostly POSIX compliant (CLOCK_UPTIME isn't POSIX though). */
+	if (clock_gettime(CLOCK_UPTIME, &ts) < 0)
+		irc_jsapi_system_raise(ctx);
+
+	duk_push_uint(ctx, ts.tv_sec);
+#endif
+
+	return 1;
+}
+
+static duk_ret_t
+System_version(duk_context *ctx)
+{
+#if defined(_WIN32)
+	DWORD version = GetVersion();
+	DWORD major = (DWORD)(LOBYTE(LOWORD(version)));
+	DWORD minor = (DWORD)(HIBYTE(LOWORD(version)));
+
+	duk_push_sprintf(ctx, "%d.%d", (int)major, (int)minor);
+#else
+	struct utsname uts;
+
+	if (uname(&uts) < 0)
+		jsapi_system_raise(ctx);
+
+	duk_push_string(ctx, uts.release);
+#endif
+	return 1;
+}
+
+static const duk_function_list_entry functions[] = {
+	{ "env",        System_env,     1 },
+	{ "exec",       System_exec,    1 },
+	{ "home",       System_home,    0 },
+	{ "name",       System_name,    0 },
+	{ "popen",      System_popen,   2 },
+	{ "sleep",      System_sleep,   1 },
+	{ "uptime",     System_uptime,  0 },
+	{ "usleep",     System_usleep,  1 },
+	{ "version",    System_version, 0 },
+	{ NULL,         NULL,           0 }
+};
+
+void
+jsapi_system_raise(duk_context *ctx)
+{
+	duk_get_global_string(ctx, "Irccd");
+	duk_get_prop_string(ctx, -1, "SystemError");
+	duk_remove(ctx, -2);
+	duk_push_int(ctx, errno);
+	duk_push_string(ctx, strerror(errno));
+	duk_new(ctx, 2);
+
+	(void)duk_throw(ctx);
+}
+
+void
+jsapi_system_load(duk_context *ctx)
+{
+	duk_get_global_string(ctx, "Irccd");
+	duk_push_object(ctx);
+	duk_put_function_list(ctx, -1, functions);
+	duk_put_prop_string(ctx, -2, "System");
+	duk_pop(ctx);
+}