tildefriends/src/api.js.c

#include "api.js.h"

#include "log.h"
#include "mem.h"
#include "ssb.db.h"
#include "ssb.h"
#include "task.h"
#include "util.js.h"

#include <quickjs.h>

#include <stdlib.h>

#if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(_WIN32)
#include <alloca.h>
#endif

typedef struct _app_path_pair_t
{
	const char* app;
	const char* path;
} app_path_pair_t;

typedef struct _get_apps_t
{
	app_path_pair_t* apps;
	int count;
	JSContext* context;
	JSValue promise[2];
	char user[];
} get_apps_t;

static void _tf_api_core_apps_work(tf_ssb_t* ssb, void* user_data)
{
	get_apps_t* work = user_data;

	JSMallocFunctions funcs = { 0 };
	tf_get_js_malloc_functions(&funcs);
	JSRuntime* runtime = JS_NewRuntime2(&funcs, NULL);
	JSContext* context = JS_NewContext(runtime);

	const char* apps = tf_ssb_db_get_property(ssb, work->user, "apps");
	if (apps)
	{
		JSValue apps_array = JS_ParseJSON(context, apps, strlen(apps), NULL);
		if (JS_IsArray(context, apps_array))
		{
			int length = tf_util_get_length(context, apps_array);
			for (int i = 0; i < length; i++)
			{
				JSValue name = JS_GetPropertyUint32(context, apps_array, i);
				const char* name_string = JS_ToCString(context, name);
				if (name_string)
				{
					work->apps = tf_resize_vec(work->apps, sizeof(app_path_pair_t) * (work->count + 1));
					work->apps[work->count].app = tf_strdup(name_string);
					size_t size = strlen("path:") + strlen(name_string) + 1;
					char* path_key = tf_malloc(size);
					snprintf(path_key, size, "path:%s", name_string);
					work->apps[work->count].path = tf_ssb_db_get_property(ssb, work->user, path_key);
					tf_free(path_key);
					work->count++;
				}
				JS_FreeCString(context, name_string);
				JS_FreeValue(context, name);
			}
		}
		JS_FreeValue(context, apps_array);
	}
	tf_free((void*)apps);

	JS_FreeContext(context);
	JS_FreeRuntime(runtime);
}

static void _tf_api_core_apps_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	get_apps_t* work = user_data;
	JSContext* context = work->context;
	JSValue result = JS_NewObject(context);
	for (int i = 0; i < work->count; i++)
	{
		JS_SetPropertyStr(context, result, work->apps[i].app, JS_NewString(context, work->apps[i].path ? work->apps[i].path : ""));
	}
	JSValue error = JS_Call(context, work->promise[0], JS_UNDEFINED, 1, &result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, result);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	for (int i = 0; i < work->count; i++)
	{
		tf_free((void*)work->apps[i].app);
		tf_free((void*)work->apps[i].path);
	}
	tf_free(work->apps);
	tf_free(work);
}

static const char* _tf_ssb_get_process_credentials_session_name(JSContext* context, JSValue process)
{
	JSValue credentials = JS_IsObject(process) ? JS_GetPropertyStr(context, process, "credentials") : JS_UNDEFINED;
	JSValue session = JS_IsObject(credentials) ? JS_GetPropertyStr(context, credentials, "session") : JS_UNDEFINED;
	JSValue name_value = JS_IsObject(session) ? JS_GetPropertyStr(context, session, "name") : JS_UNDEFINED;
	const char* result = JS_IsString(name_value) ? JS_ToCString(context, name_value) : NULL;
	JS_FreeValue(context, name_value);
	JS_FreeValue(context, session);
	JS_FreeValue(context, credentials);
	return result;
}

static JSValue _tf_api_core_apps(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	JSValue result = JS_UNDEFINED;
	JSValue user = argv[0];
	JSValue process = data[0];
	const char* user_string = JS_IsString(user) ? JS_ToCString(context, user) : NULL;
	const char* session_name_string = _tf_ssb_get_process_credentials_session_name(context, process);

	if (user_string && session_name_string && strcmp(user_string, session_name_string) && strcmp(user_string, "core"))
	{
		JS_FreeCString(context, user_string);
		user_string = NULL;
	}
	else if (!user_string)
	{
		user_string = session_name_string;
		session_name_string = NULL;
	}
	JS_FreeCString(context, session_name_string);

	if (user_string)
	{
		get_apps_t* work = tf_malloc(sizeof(get_apps_t) + strlen(user_string) + 1);
		*work = (get_apps_t) {
			.context = context,
		};
		memcpy(work->user, user_string, strlen(user_string) + 1);
		result = JS_NewPromiseCapability(context, work->promise);

		tf_task_t* task = tf_task_get(context);
		tf_ssb_t* ssb = tf_task_get_ssb(task);
		tf_ssb_run_work(ssb, _tf_api_core_apps_work, _tf_api_core_apps_after_work, work);
	}
	else
	{
		result = JS_NewObject(context);
	}
	JS_FreeCString(context, user_string);
	return result;
}

typedef struct _users_t
{
	const char* users;
	JSContext* context;
	JSValue promise[2];
} users_t;

static void _tf_api_core_users_work(tf_ssb_t* ssb, void* user_data)
{
	users_t* work = user_data;
	work->users = tf_ssb_db_get_property(ssb, "auth", "users");
}

static void _tf_api_core_users_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	users_t* work = user_data;
	JSContext* context = work->context;
	JSValue result = JS_UNDEFINED;
	if (work->users)
	{
		result = JS_ParseJSON(context, work->users, strlen(work->users), NULL);
		tf_free((void*)work->users);
	}
	if (JS_IsUndefined(result))
	{
		result = JS_NewArray(context);
	}
	JSValue error = JS_Call(context, JS_IsArray(context, result) ? work->promise[0] : work->promise[1], JS_UNDEFINED, 1, &result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, result);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	tf_free(work);
}

static JSValue _tf_api_core_users(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	users_t* work = tf_malloc(sizeof(users_t));
	*work = (users_t) {
		.context = context,
	};
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	tf_ssb_run_work(ssb, _tf_api_core_users_work, _tf_api_core_users_after_work, work);
	return result;
}

static JSValue _tf_api_core_register(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	JSValue event_name = argv[0];
	JSValue handler = argv[1];
	JSValue process = data[0];
	JSValue event_handlers = JS_GetPropertyStr(context, process, "eventHandlers");
	JSAtom atom = JS_ValueToAtom(context, event_name);
	JSValue array = JS_GetProperty(context, event_handlers, atom);
	if (!JS_IsArray(context, array))
	{
		JS_FreeValue(context, array);
		array = JS_NewArray(context);
		JS_SetProperty(context, event_handlers, atom, JS_DupValue(context, array));
	}
	JS_SetPropertyUint32(context, array, tf_util_get_length(context, array), JS_DupValue(context, handler));
	JS_FreeValue(context, array);
	JS_FreeAtom(context, atom);
	JS_FreeValue(context, event_handlers);
	return JS_UNDEFINED;
}

static JSValue _tf_api_core_unregister(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	JSValue event_name = argv[0];
	JSValue handler = argv[1];
	JSValue process = data[0];
	JSValue event_handlers = JS_GetPropertyStr(context, process, "eventHandlers");
	JSAtom atom = JS_ValueToAtom(context, event_name);
	JSValue array = JS_GetProperty(context, event_handlers, atom);

	if (JS_IsArray(context, array))
	{
		JSValue index_of = JS_GetPropertyStr(context, array, "indexOf");

		JSValue index = JS_Call(context, index_of, array, 1, &handler);
		int int_index = -1;
		JS_ToInt32(context, &int_index, index);
		if (int_index != -1)
		{
			JSValue splice = JS_GetPropertyStr(context, array, "splice");
			JSValue splice_args[] = {
				index,
				JS_NewInt32(context, 1),
			};
			JSValue result = JS_Call(context, splice, array, 2, splice_args);
			JS_FreeValue(context, result);
			JS_FreeValue(context, splice);
		}
		JS_FreeValue(context, index);
		JS_FreeValue(context, index_of);

		if (tf_util_get_length(context, array) == 0)
		{
			JS_DeleteProperty(context, event_handlers, atom, 0);
		}
	}

	JS_FreeValue(context, array);
	JS_FreeAtom(context, atom);
	JS_FreeValue(context, event_handlers);
	return JS_UNDEFINED;
}

typedef struct _permissions_for_user_t
{
	const char* user;
	const char* settings;
	JSContext* context;
	JSValue promise[2];
} permissions_for_user_t;

static void _tf_api_core_permissions_for_user_work(tf_ssb_t* ssb, void* user_data)
{
	permissions_for_user_t* work = user_data;
	work->settings = tf_ssb_db_get_property(ssb, "core", "settings");
}

static void _tf_api_core_permissions_for_user_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	permissions_for_user_t* work = user_data;
	JSContext* context = work->context;
	JSValue result = JS_UNDEFINED;
	if (work->settings)
	{
		JSValue json = JS_ParseJSON(context, work->settings, strlen(work->settings), NULL);
		if (JS_IsObject(json))
		{
			JSValue permissions = JS_GetPropertyStr(context, json, "permissions");
			if (JS_IsObject(permissions))
			{
				result = JS_GetPropertyStr(context, permissions, work->user);
			}
			JS_FreeValue(context, permissions);
		}
		JS_FreeValue(context, json);
		tf_free((void*)work->settings);
	}
	if (JS_IsUndefined(result))
	{
		result = JS_NewArray(context);
	}
	JSValue error = JS_Call(context, JS_IsArray(context, result) ? work->promise[0] : work->promise[1], JS_UNDEFINED, 1, &result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, result);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	JS_FreeCString(context, work->user);
	tf_free(work);
}

static JSValue _tf_api_core_permissionsForUser(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	permissions_for_user_t* work = tf_malloc(sizeof(permissions_for_user_t));
	*work = (permissions_for_user_t) {
		.context = context,
		.user = JS_ToCString(context, argv[0]),
	};
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	tf_ssb_run_work(ssb, _tf_api_core_permissions_for_user_work, _tf_api_core_permissions_for_user_after_work, work);
	return result;
}

typedef struct _permissions_granted_t
{
	JSContext* context;
	const char* user;
	const char* package_owner;
	const char* package_name;
	const char* settings;
	JSValue promise[2];
} permissions_granted_t;

static void _tf_api_core_permissions_granted_work(tf_ssb_t* ssb, void* user_data)
{
	permissions_granted_t* work = user_data;
	work->settings = tf_ssb_db_get_property(ssb, "core", "settings");
}

static void _tf_api_core_permissions_granted_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	permissions_granted_t* work = user_data;
	JSContext* context = work->context;
	JSValue result = JS_UNDEFINED;
	if (work->settings)
	{
		JSValue json = JS_ParseJSON(context, work->settings, strlen(work->settings), NULL);
		if (JS_IsObject(json) && work->user && work->package_owner && work->package_name)
		{
			JSValue user_permissions = JS_GetPropertyStr(context, json, "userPermissions");
			if (JS_IsObject(user_permissions))
			{
				JSValue user = JS_GetPropertyStr(context, user_permissions, work->user);
				if (JS_IsObject(user))
				{
					JSValue package_owner = JS_GetPropertyStr(context, user, work->package_owner);
					if (JS_IsObject(package_owner))
					{
						result = JS_GetPropertyStr(context, package_owner, work->package_name);
					}
					JS_FreeValue(context, package_owner);
				}
				JS_FreeValue(context, user);
			}
			JS_FreeValue(context, user_permissions);
		}
		JS_FreeValue(context, json);
		tf_free((void*)work->settings);
	}

	JSValue error = JS_Call(context, work->promise[0], JS_UNDEFINED, 1, &result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, result);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	JS_FreeCString(context, work->user);
	tf_free((void*)work->package_owner);
	tf_free((void*)work->package_name);
	tf_free(work);
}

static JSValue _tf_api_core_permissionsGranted(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	JSValue process = data[0];
	JSValue package_owner_value = JS_GetPropertyStr(context, process, "packageOwner");
	JSValue package_name_value = JS_GetPropertyStr(context, process, "packageName");
	const char* package_owner = JS_ToCString(context, package_owner_value);
	const char* package_name = JS_ToCString(context, package_name_value);
	permissions_granted_t* work = tf_malloc(sizeof(permissions_granted_t));
	*work = (permissions_granted_t) {
		.context = context,
		.user = _tf_ssb_get_process_credentials_session_name(context, process),
		.package_owner = tf_strdup(package_owner),
		.package_name = tf_strdup(package_name),
	};
	JS_FreeCString(context, package_owner);
	JS_FreeCString(context, package_name);
	JS_FreeValue(context, package_owner_value);
	JS_FreeValue(context, package_name_value);
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	tf_ssb_run_work(ssb, _tf_api_core_permissions_granted_work, _tf_api_core_permissions_granted_after_work, work);
	return result;
}

typedef struct _active_identity_work_t
{
	JSContext* context;
	const char* name;
	const char* package_owner;
	const char* package_name;
	char identity[k_id_base64_len];
	int result;
	JSValue promise[2];
} active_identity_work_t;

static void _tf_ssb_getActiveIdentity_visit(const char* identity, void* user_data)
{
	active_identity_work_t* request = user_data;
	if (!*request->identity)
	{
		snprintf(request->identity, sizeof(request->identity), "@%s", identity);
	}
}

static void _tf_ssb_getActiveIdentity_work(tf_ssb_t* ssb, void* user_data)
{
	active_identity_work_t* request = user_data;
	sqlite3* db = tf_ssb_acquire_db_reader(ssb);
	tf_ssb_db_identity_get_active(db, request->name, request->package_owner, request->package_name, request->identity, sizeof(request->identity));
	tf_ssb_release_db_reader(ssb, db);

	if (!*request->identity && tf_ssb_db_user_has_permission(ssb, NULL, request->name, "administration"))
	{
		tf_ssb_whoami(ssb, request->identity, sizeof(request->identity));
	}

	if (!*request->identity)
	{
		tf_ssb_db_identity_visit(ssb, request->name, _tf_ssb_getActiveIdentity_visit, request);
	}
}

static void _tf_ssb_getActiveIdentity_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	active_identity_work_t* request = user_data;
	JSContext* context = request->context;
	if (request->result == 0)
	{
		JSValue identity = JS_NewString(context, request->identity);
		JSValue error = JS_Call(context, request->promise[0], JS_UNDEFINED, 1, &identity);
		JS_FreeValue(context, identity);
		tf_util_report_error(context, error);
		JS_FreeValue(context, error);
	}
	else
	{
		JSValue error = JS_Call(context, request->promise[1], JS_UNDEFINED, 0, NULL);
		tf_util_report_error(context, error);
		JS_FreeValue(context, error);
	}
	JS_FreeValue(context, request->promise[0]);
	JS_FreeValue(context, request->promise[1]);
	tf_free((void*)request->name);
	tf_free((void*)request->package_owner);
	tf_free((void*)request->package_name);
	tf_free(request);
}

static JSValue _tf_ssb_getActiveIdentity(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	JSValue process = data[0];
	JSValue package_owner_value = JS_GetPropertyStr(context, process, "packageOwner");
	JSValue package_name_value = JS_GetPropertyStr(context, process, "packageName");

	const char* name = _tf_ssb_get_process_credentials_session_name(context, process);
	const char* package_owner = JS_ToCString(context, package_owner_value);
	const char* package_name = JS_ToCString(context, package_name_value);
	active_identity_work_t* work = tf_malloc(sizeof(active_identity_work_t));
	*work = (active_identity_work_t) {
		.context = context,
		.name = tf_strdup(name),
		.package_owner = tf_strdup(package_owner),
		.package_name = tf_strdup(package_name),
	};
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	JS_FreeCString(context, name);
	JS_FreeCString(context, package_owner);
	JS_FreeCString(context, package_name);

	JS_FreeValue(context, package_owner_value);
	JS_FreeValue(context, package_name_value);
	tf_ssb_run_work(ssb, _tf_ssb_getActiveIdentity_work, _tf_ssb_getActiveIdentity_after_work, work);
	return result;
}

typedef struct _identities_visit_t
{
	JSContext* context;
	JSValue promise[2];
	const char** identities;
	int count;
	char user[];
} identities_visit_t;

static void _tf_ssb_getIdentities_visit(const char* identity, void* user_data)
{
	identities_visit_t* work = user_data;
	work->identities = tf_resize_vec(work->identities, (work->count + 1) * sizeof(const char*));
	char id[k_id_base64_len];
	snprintf(id, sizeof(id), "@%s", identity);
	work->identities[work->count++] = tf_strdup(id);
}

static void _tf_ssb_get_all_identities_work(tf_ssb_t* ssb, void* user_data)
{
	tf_ssb_db_identity_visit_all(ssb, _tf_ssb_getIdentities_visit, user_data);
}

static void _tf_ssb_get_identities_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	identities_visit_t* work = user_data;
	JSContext* context = tf_ssb_get_context(ssb);
	JSValue result = JS_NewArray(context);
	for (int i = 0; i < work->count; i++)
	{
		JS_SetPropertyUint32(context, result, i, JS_NewString(context, work->identities[i]));
		tf_free((void*)work->identities[i]);
	}
	tf_free(work->identities);

	JSValue error = JS_Call(context, work->promise[0], JS_UNDEFINED, 1, &result);
	JS_FreeValue(context, result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	tf_free(work);
}

static JSValue _tf_ssb_getAllIdentities(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	JSValue result = JS_UNDEFINED;
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	if (ssb)
	{
		identities_visit_t* work = tf_malloc(sizeof(identities_visit_t));
		*work = (identities_visit_t) {
			.context = context,
		};

		result = JS_NewPromiseCapability(context, work->promise);
		tf_ssb_run_work(ssb, _tf_ssb_get_all_identities_work, _tf_ssb_get_identities_after_work, work);
	}
	return result;
}

static void _tf_ssb_get_identities_work(tf_ssb_t* ssb, void* user_data)
{
	identities_visit_t* work = user_data;
	if (tf_ssb_db_user_has_permission(ssb, NULL, work->user, "administration"))
	{
		char id[k_id_base64_len] = "";
		if (tf_ssb_whoami(ssb, id, sizeof(id)))
		{
			_tf_ssb_getIdentities_visit(*id == '@' ? id + 1 : id, work);
		}
	}
	tf_ssb_db_identity_visit(ssb, work->user, _tf_ssb_getIdentities_visit, user_data);
}

static JSValue _tf_ssb_getIdentities(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	JSValue result = JS_UNDEFINED;
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	JSValue process = data[0];
	if (ssb)
	{
		const char* user = _tf_ssb_get_process_credentials_session_name(context, process);
		if (user)
		{
			size_t user_length = user ? strlen(user) : 0;
			identities_visit_t* work = tf_malloc(sizeof(identities_visit_t) + user_length + 1);
			*work = (identities_visit_t) {
				.context = context,
			};
			memcpy(work->user, user, user_length + 1);
			JS_FreeCString(context, user);

			result = JS_NewPromiseCapability(context, work->promise);
			tf_ssb_run_work(ssb, _tf_ssb_get_identities_work, _tf_ssb_get_identities_after_work, work);
		}
	}
	return result;
}

static JSValue _tf_ssb_getOwnerIdentities(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	JSValue result = JS_UNDEFINED;
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	JSValue process = data[0];
	if (ssb)
	{
		JSValue value = JS_GetPropertyStr(context, process, "packageOwner");
		const char* user = JS_ToCString(context, value);
		size_t user_length = user ? strlen(user) : 0;
		identities_visit_t* work = tf_malloc(sizeof(identities_visit_t) + user_length + 1);
		*work = (identities_visit_t) {
			.context = context,
		};
		memcpy(work->user, user, user_length + 1);
		JS_FreeCString(context, user);
		JS_FreeValue(context, value);

		result = JS_NewPromiseCapability(context, work->promise);
		tf_ssb_run_work(ssb, _tf_ssb_get_identities_work, _tf_ssb_get_identities_after_work, work);
	}
	return result;
}

typedef struct _settings_descriptions_get_t
{
	const char* settings;
	JSContext* context;
	JSValue promise[2];
} settings_descriptions_get_t;

static void _tf_ssb_get_settings_descriptions_work(tf_ssb_t* ssb, void* user_data)
{
	settings_descriptions_get_t* work = user_data;
	work->settings = tf_ssb_db_get_property(ssb, "core", "settings");
}

static void _tf_ssb_get_settings_descriptions_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	settings_descriptions_get_t* work = user_data;
	JSContext* context = work->context;
	JSValue result = JS_NewObject(context);
	JSValue settings = JS_ParseJSON(context, work->settings ? work->settings : "", work->settings ? strlen(work->settings) : 0, NULL);
	const char* name;
	const char* type;
	tf_setting_kind_t kind;
	const char* description;
	for (int i = 0; tf_util_get_global_setting_by_index(i, &name, &type, &kind, &description); i++)
	{
		JSValue entry = JS_NewObject(context);
		JS_SetPropertyStr(context, entry, "type", JS_NewString(context, type));
		JS_SetPropertyStr(context, entry, "description", JS_NewString(context, description));
		switch (kind)
		{
		case k_kind_unknown:
			break;
		case k_kind_bool:
			JS_SetPropertyStr(context, entry, "default_value", JS_NewBool(context, tf_util_get_default_global_setting_bool(name)));
			break;
		case k_kind_int:
			JS_SetPropertyStr(context, entry, "default_value", JS_NewInt32(context, tf_util_get_default_global_setting_int(name)));
			break;
		case k_kind_string:
			JS_SetPropertyStr(context, entry, "default_value", JS_NewString(context, tf_util_get_default_global_setting_string(name)));
			break;
		}
		if (JS_IsObject(settings))
		{
			JS_SetPropertyStr(context, entry, "value", JS_GetPropertyStr(context, settings, name));
		}
		JS_SetPropertyStr(context, result, name, entry);
	}
	JS_FreeValue(context, settings);
	JSValue error = JS_Call(context, work->promise[0], JS_UNDEFINED, 1, &result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, result);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	tf_free((void*)work->settings);
	tf_free(work);
}

static JSValue _tf_ssb_globalSettingsDescriptions(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	settings_descriptions_get_t* work = tf_malloc(sizeof(settings_descriptions_get_t));
	*work = (settings_descriptions_get_t) { .context = context };
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	tf_ssb_run_work(ssb, _tf_ssb_get_settings_descriptions_work, _tf_ssb_get_settings_descriptions_after_work, work);
	return result;
}

typedef struct _settings_get_t
{
	const char* key;
	tf_setting_kind_t kind;
	void* value;
	JSContext* context;
	JSValue promise[2];
} settings_get_t;

static void _tf_ssb_settings_get_work(tf_ssb_t* ssb, void* user_data)
{
	settings_get_t* work = user_data;
	work->kind = tf_util_get_global_setting_kind(work->key);
	switch (work->kind)
	{
	case k_kind_unknown:
		break;
	case k_kind_bool:
		{
			sqlite3* db = tf_ssb_acquire_db_reader(ssb);
			bool value = false;
			tf_ssb_db_get_global_setting_bool(db, work->key, &value);
			work->value = (void*)(intptr_t)value;
			tf_ssb_release_db_reader(ssb, db);
		}
		break;
	case k_kind_int:
		{
			sqlite3* db = tf_ssb_acquire_db_reader(ssb);
			int64_t value = 0;
			tf_ssb_db_get_global_setting_int64(db, work->key, &value);
			work->value = (void*)(intptr_t)value;
			tf_ssb_release_db_reader(ssb, db);
		}
		break;
	case k_kind_string:
		{
			sqlite3* db = tf_ssb_acquire_db_reader(ssb);
			work->value = (void*)tf_ssb_db_get_global_setting_string_alloc(db, work->key);
			tf_ssb_release_db_reader(ssb, db);
		}
		break;
	}
}

static void _tf_ssb_settings_get_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	settings_get_t* work = user_data;
	JSContext* context = tf_ssb_get_context(ssb);
	JSValue result = JS_UNDEFINED;
	switch (work->kind)
	{
	case k_kind_unknown:
		break;
	case k_kind_bool:
		result = work->value ? JS_TRUE : JS_FALSE;
		break;
	case k_kind_int:
		result = JS_NewInt64(context, (int64_t)(intptr_t)work->value);
		break;
	case k_kind_string:
		result = JS_NewString(context, (const char*)work->value);
		tf_free(work->value);
		break;
	}

	JSValue error = JS_Call(context, work->promise[0], JS_UNDEFINED, 1, &result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, result);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	JS_FreeCString(context, work->key);
	tf_free(work);
}

static JSValue _tf_ssb_globalSettingsGet(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	settings_get_t* work = tf_malloc(sizeof(settings_get_t));
	*work = (settings_get_t) { .context = context, .key = JS_ToCString(context, argv[0]) };
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	tf_ssb_run_work(ssb, _tf_ssb_settings_get_work, _tf_ssb_settings_get_after_work, work);
	return result;
}

typedef struct _modify_block_t
{
	const char* user;
	char id[k_id_base64_len];
	bool add;
	bool completed;
	JSValue result;
	JSValue promise[2];
} modify_block_t;

static void _tf_ssb_modify_block_work(tf_ssb_t* ssb, void* user_data)
{
	modify_block_t* work = user_data;
	sqlite3* db = tf_ssb_acquire_db_writer(ssb);
	if (work->add)
	{
		tf_ssb_db_add_block(db, work->id);
	}
	else
	{
		tf_ssb_db_remove_block(db, work->id);
	}
	tf_ssb_release_db_writer(ssb, db);
	work->completed = true;
}

static void _tf_ssb_modify_block_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	modify_block_t* request = user_data;
	JSContext* context = tf_ssb_get_context(ssb);
	JSValue error = JS_Call(context, request->completed ? request->promise[0] : request->promise[1], JS_UNDEFINED, 1, &request->result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, request->promise[0]);
	JS_FreeValue(context, request->promise[1]);
	JS_FreeValue(context, request->result);
	JS_FreeCString(context, request->user);
	tf_free(request);
}

typedef void(permission_test_callback_t)(JSContext* context, bool granted, JSValue value, void* user_data);

typedef struct _permission_test_t
{
	permission_test_callback_t* callback;
	void* user_data;
} permission_test_t;

static JSValue _tf_ssb_permission_test_resolve(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	JSClassID class_id = 0;
	permission_test_t* work = JS_GetAnyOpaque(data[0], &class_id);
	JS_FreeValue(context, data[0]);
	work->callback(context, true, argv[0], work->user_data);
	tf_free(work);
	return JS_UNDEFINED;
}

static JSValue _tf_ssb_permission_test_reject(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	JSClassID class_id = 0;
	permission_test_t* work = JS_GetAnyOpaque(data[0], &class_id);
	JS_FreeValue(context, data[0]);
	work->callback(context, false, argv[0], work->user_data);
	tf_free(work);
	return JS_UNDEFINED;
}

static void _tf_ssb_permission_test(JSContext* context, JSValue process, const char* permission, const char* description, permission_test_callback_t* callback, void* user_data)
{
	permission_test_t* payload = tf_malloc(sizeof(permission_test_t));
	*payload = (permission_test_t) {
		.callback = callback,
		.user_data = user_data,
	};
	JSValue opaque = JS_NewObject(context);
	JS_SetOpaque(opaque, payload);
	JSValue imports = JS_GetPropertyStr(context, process, "imports");
	JSValue core = JS_GetPropertyStr(context, imports, "core");
	JSValue permission_test = JS_GetPropertyStr(context, core, "permissionTest");
	JSValue args[] = {
		JS_NewString(context, permission),
		JS_NewString(context, description),
	};
	JSValue promise = JS_Call(context, permission_test, imports, tf_countof(args), args);
	JSValue then = JS_GetPropertyStr(context, promise, "then");
	JSValue catch = JS_GetPropertyStr(context, promise, "catch");
	JSValue resolve = JS_NewCFunctionData(context, _tf_ssb_permission_test_resolve, 1, 0, 1, &opaque);
	JSValue reject = JS_NewCFunctionData(context, _tf_ssb_permission_test_reject, 1, 0, 1, &opaque);
	JSValue result = JS_Call(context, then, promise, 1, &resolve);
	tf_util_report_error(context, result);
	JS_FreeValue(context, result);
	result = JS_Call(context, catch, promise, 1, &reject);
	tf_util_report_error(context, result);
	JS_FreeValue(context, promise);
	JS_FreeValue(context, resolve);
	JS_FreeValue(context, reject);
	JS_FreeValue(context, result);
	JS_FreeValue(context, then);
	JS_FreeValue(context, catch);
	for (int i = 0; i < tf_countof(args); i++)
	{
		JS_FreeValue(context, args[i]);
	}
	JS_FreeValue(context, permission_test);
	JS_FreeValue(context, core);
	JS_FreeValue(context, imports);
}

static void _tf_ssb_modify_block_start_work(JSContext* context, bool granted, JSValue value, void* user_data)
{
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	modify_block_t* work = user_data;
	work->result = JS_DupValue(context, value);
	if (granted)
	{
		tf_ssb_run_work(ssb, _tf_ssb_modify_block_work, _tf_ssb_modify_block_after_work, work);
	}
	else
	{
		_tf_ssb_modify_block_after_work(ssb, 0, work);
	}
}

static JSValue _tf_ssb_add_block(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	const char* id = JS_ToCString(context, argv[0]);
	modify_block_t* work = tf_malloc(sizeof(modify_block_t));
	*work = (modify_block_t) {
		.user = _tf_ssb_get_process_credentials_session_name(context, data[0]),
		.add = true,
	};
	tf_string_set(work->id, sizeof(work->id), id);
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	JS_FreeCString(context, id);

	char description[256] = "";
	snprintf(description, sizeof(description), "Block %s.", work->id);
	_tf_ssb_permission_test(context, data[0], "modify_blocks", description, _tf_ssb_modify_block_start_work, work);
	return result;
}

static JSValue _tf_ssb_remove_block(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	const char* id = JS_ToCString(context, argv[0]);
	modify_block_t* work = tf_malloc(sizeof(modify_block_t));
	*work = (modify_block_t) {
		.user = _tf_ssb_get_process_credentials_session_name(context, data[0]),
		.add = false,
	};
	tf_string_set(work->id, sizeof(work->id), id);
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	JS_FreeCString(context, id);

	char description[256] = "";
	snprintf(description, sizeof(description), "Unblock %s.", work->id);
	_tf_ssb_permission_test(context, data[0], "modify_blocks", description, _tf_ssb_modify_block_start_work, work);
	return result;
}

typedef struct _block_t
{
	char id[k_id_base64_len];
	double timestamp;
} block_t;

typedef struct _get_blocks_t
{
	block_t* blocks;
	int count;
	JSValue promise[2];
} get_blocks_t;

static void _get_blocks_callback(const char* id, double timestamp, void* user_data)
{
	get_blocks_t* work = user_data;
	work->blocks = tf_resize_vec(work->blocks, sizeof(block_t) * (work->count + 1));
	work->blocks[work->count] = (block_t) { .timestamp = timestamp };
	tf_string_set(work->blocks[work->count].id, sizeof(work->blocks[work->count].id), id);
	work->count++;
}

static void _tf_ssb_get_blocks_work(tf_ssb_t* ssb, void* user_data)
{
	sqlite3* db = tf_ssb_acquire_db_reader(ssb);
	tf_ssb_db_get_blocks(db, _get_blocks_callback, user_data);
	tf_ssb_release_db_reader(ssb, db);
}

static void _tf_ssb_get_blocks_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	get_blocks_t* work = user_data;
	JSContext* context = tf_ssb_get_context(ssb);

	JSValue result = JS_NewArray(context);
	for (int i = 0; i < work->count; i++)
	{
		JSValue entry = JS_NewObject(context);
		JS_SetPropertyStr(context, entry, "id", JS_NewString(context, work->blocks[i].id));
		JS_SetPropertyStr(context, entry, "timestamp", JS_NewFloat64(context, work->blocks[i].timestamp));
		JS_SetPropertyUint32(context, result, i, entry);
	}

	JSValue error = JS_Call(context, work->promise[0], JS_UNDEFINED, 1, &result);
	JS_FreeValue(context, result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	tf_free(work->blocks);
	tf_free(work);
}

static JSValue _tf_ssb_get_blocks(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	get_blocks_t* work = tf_malloc(sizeof(get_blocks_t));
	*work = (get_blocks_t) { 0 };
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	tf_ssb_run_work(ssb, _tf_ssb_get_blocks_work, _tf_ssb_get_blocks_after_work, work);
	return result;
}

typedef struct _global_setting_set_t
{
	const char* key;
	const char* value;
	JSValue promise[2];
	bool done;
	JSValue result;
} global_setting_set_t;

static void _tf_ssb_globalSettingsSet_work(tf_ssb_t* ssb, void* user_data)
{
	global_setting_set_t* work = user_data;
	sqlite3* db = tf_ssb_acquire_db_writer(ssb);
	work->done = tf_ssb_db_set_global_setting_from_string(db, work->key, work->value);
	tf_ssb_release_db_writer(ssb, db);
}

static void _tf_ssb_globalSettingsSet_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	global_setting_set_t* work = user_data;
	JSContext* context = tf_ssb_get_context(ssb);
	JSValue error = JS_Call(context, work->done ? work->promise[0] : work->promise[1], JS_UNDEFINED, 1, &work->result);
	JS_FreeValue(context, work->result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	JS_FreeCString(context, work->key);
	JS_FreeCString(context, work->value);
	tf_free(work);
}

static void _tf_ssb_globalSettingsSet_permission_callback(JSContext* context, bool granted, JSValue value, void* user_data)
{
	global_setting_set_t* work = user_data;
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	work->result = value;
	if (granted)
	{
		tf_ssb_run_work(ssb, _tf_ssb_globalSettingsSet_work, _tf_ssb_globalSettingsSet_after_work, work);
	}
	else
	{
		_tf_ssb_globalSettingsSet_after_work(ssb, -1, work);
	}
}

static JSValue _tf_ssb_globalSettingsSet(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	const char* key = JS_ToCString(context, argv[0]);
	const char* value = JS_ToCString(context, argv[1]);

	global_setting_set_t* work = tf_malloc(sizeof(global_setting_set_t));
	*work = (global_setting_set_t) {
		.key = key,
		.value = value,
	};
	JSValue result = JS_NewPromiseCapability(context, work->promise);

	char description[256] = "";
	snprintf(description, sizeof(description), "Set %s to %s.", key, value);
	_tf_ssb_permission_test(context, data[0], "set_global_setting", description, _tf_ssb_globalSettingsSet_permission_callback, work);
	return result;
}

typedef struct _delete_user_t
{
	const char* user;
	bool completed;
	JSValue result;
	JSValue promise[2];
} delete_user_t;

static void _tf_ssb_delete_user_work(tf_ssb_t* ssb, void* user_data)
{
	delete_user_t* work = user_data;
	size_t length = strlen("user:") + strlen(work->user) + 1;
	char* buffer = alloca(length);
	snprintf(buffer, length, "user:%s", work->user);
	work->completed = tf_ssb_db_remove_property(ssb, "auth", buffer) || work->completed;
	work->completed = tf_ssb_db_remove_value_from_array_property(ssb, "auth", "users", work->user) || work->completed;
}

static void _tf_ssb_delete_user_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	delete_user_t* work = user_data;
	JSContext* context = tf_ssb_get_context(ssb);
	if (!work->completed && JS_IsUndefined(work->result))
	{
		work->result = JS_NewString(context, "User not found.");
	}
	JSValue error = JS_Call(context, work->completed ? work->promise[0] : work->promise[1], JS_UNDEFINED, 1, &work->result);
	JS_FreeValue(context, work->result);
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	JS_FreeCString(context, work->user);
	tf_free(work);
}

static void _tf_ssb_delete_user_permission_callback(JSContext* context, bool granted, JSValue value, void* user_data)
{
	delete_user_t* work = user_data;
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	if (granted)
	{
		tf_ssb_run_work(ssb, _tf_ssb_delete_user_work, _tf_ssb_delete_user_after_work, work);
	}
	else
	{
		_tf_ssb_delete_user_after_work(ssb, -1, work);
	}
}

static JSValue _tf_ssb_delete_user(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	delete_user_t* work = tf_malloc(sizeof(delete_user_t));
	*work = (delete_user_t) {
		.user = JS_ToCString(context, argv[0]),
	};
	JSValue result = JS_NewPromiseCapability(context, work->promise);

	char description[256] = "";
	snprintf(description, sizeof(description), "Delete user '%s'.", work->user);
	_tf_ssb_permission_test(context, data[0], "delete_user", description, _tf_ssb_delete_user_permission_callback, work);
	return result;
}

typedef struct _swap_with_server_identity_t
{
	char server_id[k_id_base64_len];
	char user_id[k_id_base64_len];
	JSValue promise[2];
	char* error;
	char user[];
} swap_with_server_identity_t;

static void _tf_ssb_swap_with_server_identity_work(tf_ssb_t* ssb, void* user_data)
{
	swap_with_server_identity_t* work = user_data;
	sqlite3* db = tf_ssb_acquire_db_writer(ssb);
	work->error = tf_ssb_db_swap_with_server_identity(db, work->user, work->user_id, work->server_id);
	tf_ssb_release_db_writer(ssb, db);
}

static void _tf_ssb_swap_with_server_identity_after_work(tf_ssb_t* ssb, int status, void* user_data)
{
	swap_with_server_identity_t* work = user_data;
	JSContext* context = tf_ssb_get_context(ssb);
	JSValue error = JS_UNDEFINED;
	if (work->error)
	{
		JSValue arg = JS_ThrowInternalError(context, "%s", work->error);
		JSValue exception = JS_GetException(context);
		error = JS_Call(context, work->promise[1], JS_UNDEFINED, 1, &exception);
		tf_free(work->error);
		JS_FreeValue(context, exception);
		JS_FreeValue(context, arg);
	}
	else
	{
		error = JS_Call(context, work->promise[0], JS_UNDEFINED, 0, NULL);
	}
	tf_util_report_error(context, error);
	JS_FreeValue(context, error);
	JS_FreeValue(context, work->promise[0]);
	JS_FreeValue(context, work->promise[1]);
	tf_free(work);
}

static void _tf_ssb_swap_with_server_identity_permission_callback(JSContext* context, bool granted, JSValue value, void* user_data)
{
	swap_with_server_identity_t* work = user_data;
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	tf_ssb_run_work(ssb, _tf_ssb_swap_with_server_identity_work, _tf_ssb_swap_with_server_identity_after_work, work);
}

static JSValue _tf_ssb_swap_with_server_identity(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data)
{
	tf_task_t* task = tf_task_get(context);
	tf_ssb_t* ssb = tf_task_get_ssb(task);
	const char* user = _tf_ssb_get_process_credentials_session_name(context, data[0]);
	size_t user_length = user ? strlen(user) : 0;
	const char* id = JS_ToCString(context, argv[0]);
	swap_with_server_identity_t* work = tf_malloc(sizeof(swap_with_server_identity_t) + user_length + 1);
	*work = (swap_with_server_identity_t) { 0 };
	tf_ssb_whoami(ssb, work->server_id, sizeof(work->server_id));
	tf_string_set(work->user_id, sizeof(work->user_id), id);
	if (user)
	{
		memcpy(work->user, user, user_length + 1);
	}
	else
	{
		*work->user = '\0';
	}
	JSValue result = JS_NewPromiseCapability(context, work->promise);
	char description[1024];
	snprintf(description, sizeof(description), "Swap identity %s with %s.", work->user_id, work->server_id);
	_tf_ssb_permission_test(context, data[0], "delete_user", description, _tf_ssb_swap_with_server_identity_permission_callback, work);
	JS_FreeCString(context, id);
	JS_FreeCString(context, user);
	return result;
}

static JSValue _tf_api_register_imports(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	JSValue imports = argv[0];
	JSValue process = argv[1];
	JSValue core = JS_GetPropertyStr(context, imports, "core");
	JS_SetPropertyStr(context, core, "apps", JS_NewCFunctionData(context, _tf_api_core_apps, 1, 0, 1, &process));
	JS_SetPropertyStr(context, core, "register", JS_NewCFunctionData(context, _tf_api_core_register, 2, 0, 1, &process));
	JS_SetPropertyStr(context, core, "unregister", JS_NewCFunctionData(context, _tf_api_core_unregister, 2, 0, 1, &process));

	JS_SetPropertyStr(context, core, "users", JS_NewCFunctionData(context, _tf_api_core_users, 0, 0, 1, &process));

	JS_SetPropertyStr(context, core, "permissionsForUser", JS_NewCFunctionData(context, _tf_api_core_permissionsForUser, 1, 0, 1, &process));
	JS_SetPropertyStr(context, core, "permissionsGranted", JS_NewCFunctionData(context, _tf_api_core_permissionsGranted, 0, 0, 1, &process));

	JSValue app = JS_NewObject(context);
	JS_SetPropertyStr(context, app, "owner", JS_GetPropertyStr(context, process, "packageOwner"));
	JS_SetPropertyStr(context, app, "name", JS_GetPropertyStr(context, process, "packageName"));
	JS_SetPropertyStr(context, core, "app", app);

	JS_SetPropertyStr(context, core, "url", JS_GetPropertyStr(context, process, "url"));

	JSValue ssb = JS_GetPropertyStr(context, imports, "ssb");
	JS_SetPropertyStr(context, ssb, "getAllIdentities", JS_NewCFunction(context, _tf_ssb_getAllIdentities, "getAllIdentities", 0));
	JS_SetPropertyStr(context, ssb, "getActiveIdentity", JS_NewCFunctionData(context, _tf_ssb_getActiveIdentity, 0, 0, 1, &process));
	JS_SetPropertyStr(context, ssb, "getIdentities", JS_NewCFunctionData(context, _tf_ssb_getIdentities, 0, 0, 1, &process));
	JS_SetPropertyStr(context, ssb, "getOwnerIdentities", JS_NewCFunctionData(context, _tf_ssb_getOwnerIdentities, 0, 0, 1, &process));
	JS_FreeValue(context, ssb);

	JSValue credentials = JS_GetPropertyStr(context, process, "credentials");
	JSValue permissions = JS_IsObject(credentials) ? JS_GetPropertyStr(context, credentials, "permissions") : JS_UNDEFINED;
	JSValue administration = JS_IsObject(permissions) ? JS_GetPropertyStr(context, permissions, "administration") : JS_UNDEFINED;
	if (JS_ToBool(context, administration) > 0)
	{
		JS_SetPropertyStr(context, core, "globalSettingsDescriptions", JS_NewCFunction(context, _tf_ssb_globalSettingsDescriptions, "globalSettingsDescriptions", 0));
		JS_SetPropertyStr(context, core, "globalSettingsGet", JS_NewCFunction(context, _tf_ssb_globalSettingsGet, "globalSettingsGet", 1));
		JS_SetPropertyStr(context, core, "globalSettingsSet", JS_NewCFunctionData(context, _tf_ssb_globalSettingsSet, 2, 0, 1, &process));

		JS_SetPropertyStr(context, core, "deleteUser", JS_NewCFunctionData(context, _tf_ssb_delete_user, 0, 0, 1, &process));

		JS_SetPropertyStr(context, ssb, "addBlock", JS_NewCFunctionData(context, _tf_ssb_add_block, 1, 0, 1, &process));
		JS_SetPropertyStr(context, ssb, "removeBlock", JS_NewCFunctionData(context, _tf_ssb_remove_block, 1, 0, 1, &process));
		JS_SetPropertyStr(context, ssb, "getBlocks", JS_NewCFunctionData(context, _tf_ssb_get_blocks, 0, 0, 1, &process));

		JS_SetPropertyStr(context, ssb, "swapWithServerIdentity", JS_NewCFunctionData(context, _tf_ssb_swap_with_server_identity, 1, 0, 1, &process));
	}
	JS_FreeValue(context, administration);
	JS_FreeValue(context, permissions);
	JS_FreeValue(context, credentials);

	JS_FreeValue(context, core);
	return JS_UNDEFINED;
}

void tf_api_register(JSContext* context)
{
	JSValue global = JS_GetGlobalObject(context);
	JSValue ssb = JS_GetPropertyStr(context, global, "ssb");
	JS_SetPropertyStr(context, ssb, "registerImports", JS_NewCFunction(context, _tf_api_register_imports, "registerImports", 2));
	JS_FreeValue(context, ssb);
	JS_FreeValue(context, global);
}