@studiometa/forge-core 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,3 +1,27 @@
+import { createWriteStream, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 /**
 * All supported resources.
 * Single source of truth — MCP schema and handlers derive from this.
@@ -42,6 +66,569 @@ const ACTIONS = [
 	"help",
 	"schema"
 ];
+var require_quick_format_unescaped = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function tryStringify(o) {
+		try {
+			return JSON.stringify(o);
+		} catch (e) {
+			return "\"[Circular]\"";
+		}
+	}
+	module.exports = format;
+	function format(f, args, opts) {
+		var ss = opts && opts.stringify || tryStringify;
+		var offset = 1;
+		if (typeof f === "object" && f !== null) {
+			var len = args.length + offset;
+			if (len === 1) return f;
+			var objects = new Array(len);
+			objects[0] = ss(f);
+			for (var index = 1; index < len; index++) objects[index] = ss(args[index]);
+			return objects.join(" ");
+		}
+		if (typeof f !== "string") return f;
+		var argLen = args.length;
+		if (argLen === 0) return f;
+		var str = "";
+		var a = 1 - offset;
+		var lastPos = -1;
+		var flen = f && f.length || 0;
+		for (var i = 0; i < flen;) {
+			if (f.charCodeAt(i) === 37 && i + 1 < flen) {
+				lastPos = lastPos > -1 ? lastPos : 0;
+				switch (f.charCodeAt(i + 1)) {
+					case 100:
+					case 102:
+						if (a >= argLen) break;
+						if (args[a] == null) break;
+						if (lastPos < i) str += f.slice(lastPos, i);
+						str += Number(args[a]);
+						lastPos = i + 2;
+						i++;
+						break;
+					case 105:
+						if (a >= argLen) break;
+						if (args[a] == null) break;
+						if (lastPos < i) str += f.slice(lastPos, i);
+						str += Math.floor(Number(args[a]));
+						lastPos = i + 2;
+						i++;
+						break;
+					case 79:
+					case 111:
+					case 106:
+						if (a >= argLen) break;
+						if (args[a] === void 0) break;
+						if (lastPos < i) str += f.slice(lastPos, i);
+						var type = typeof args[a];
+						if (type === "string") {
+							str += "'" + args[a] + "'";
+							lastPos = i + 2;
+							i++;
+							break;
+						}
+						if (type === "function") {
+							str += args[a].name || "<anonymous>";
+							lastPos = i + 2;
+							i++;
+							break;
+						}
+						str += ss(args[a]);
+						lastPos = i + 2;
+						i++;
+						break;
+					case 115:
+						if (a >= argLen) break;
+						if (lastPos < i) str += f.slice(lastPos, i);
+						str += String(args[a]);
+						lastPos = i + 2;
+						i++;
+						break;
+					case 37:
+						if (lastPos < i) str += f.slice(lastPos, i);
+						str += "%";
+						lastPos = i + 2;
+						i++;
+						a--;
+						break;
+				}
+				++a;
+			}
+			++i;
+		}
+		if (lastPos === -1) return f;
+		else if (lastPos < flen) str += f.slice(lastPos);
+		return str;
+	}
+}));
+var import_browser = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var format = require_quick_format_unescaped();
+	module.exports = pino;
+	var _console = pfGlobalThisOrFallback().console || {};
+	var stdSerializers = {
+		mapHttpRequest: mock,
+		mapHttpResponse: mock,
+		wrapRequestSerializer: passthrough,
+		wrapResponseSerializer: passthrough,
+		wrapErrorSerializer: passthrough,
+		req: mock,
+		res: mock,
+		err: asErrValue,
+		errWithCause: asErrValue
+	};
+	function levelToValue(level, logger) {
+		return level === "silent" ? Infinity : logger.levels.values[level];
+	}
+	var baseLogFunctionSymbol = Symbol("pino.logFuncs");
+	var hierarchySymbol = Symbol("pino.hierarchy");
+	var logFallbackMap = {
+		error: "log",
+		fatal: "error",
+		warn: "error",
+		info: "log",
+		debug: "log",
+		trace: "log"
+	};
+	function appendChildLogger(parentLogger, childLogger) {
+		childLogger[hierarchySymbol] = {
+			logger: childLogger,
+			parent: parentLogger[hierarchySymbol]
+		};
+	}
+	function setupBaseLogFunctions(logger, levels, proto) {
+		const logFunctions = {};
+		levels.forEach((level) => {
+			logFunctions[level] = proto[level] ? proto[level] : _console[level] || _console[logFallbackMap[level] || "log"] || noop;
+		});
+		logger[baseLogFunctionSymbol] = logFunctions;
+	}
+	function shouldSerialize(serialize, serializers) {
+		if (Array.isArray(serialize)) return serialize.filter(function(k) {
+			return k !== "!stdSerializers.err";
+		});
+		else if (serialize === true) return Object.keys(serializers);
+		return false;
+	}
+	function pino(opts) {
+		opts = opts || {};
+		opts.browser = opts.browser || {};
+		const transmit = opts.browser.transmit;
+		if (transmit && typeof transmit.send !== "function") throw Error("pino: transmit option must have a send function");
+		const proto = opts.browser.write || _console;
+		if (opts.browser.write) opts.browser.asObject = true;
+		const serializers = opts.serializers || {};
+		const serialize = shouldSerialize(opts.browser.serialize, serializers);
+		let stdErrSerialize = opts.browser.serialize;
+		if (Array.isArray(opts.browser.serialize) && opts.browser.serialize.indexOf("!stdSerializers.err") > -1) stdErrSerialize = false;
+		const customLevels = Object.keys(opts.customLevels || {});
+		const levels = [
+			"error",
+			"fatal",
+			"warn",
+			"info",
+			"debug",
+			"trace"
+		].concat(customLevels);
+		if (typeof proto === "function") levels.forEach(function(level) {
+			proto[level] = proto;
+		});
+		if (opts.enabled === false || opts.browser.disabled) opts.level = "silent";
+		const level = opts.level || "info";
+		const logger = Object.create(proto);
+		if (!logger.log) logger.log = noop;
+		setupBaseLogFunctions(logger, levels, proto);
+		appendChildLogger({}, logger);
+		Object.defineProperty(logger, "levelVal", { get: getLevelVal });
+		Object.defineProperty(logger, "level", {
+			get: getLevel,
+			set: setLevel
+		});
+		const setOpts = {
+			transmit,
+			serialize,
+			asObject: opts.browser.asObject,
+			asObjectBindingsOnly: opts.browser.asObjectBindingsOnly,
+			formatters: opts.browser.formatters,
+			reportCaller: opts.browser.reportCaller,
+			levels,
+			timestamp: getTimeFunction(opts),
+			messageKey: opts.messageKey || "msg",
+			onChild: opts.onChild || noop
+		};
+		logger.levels = getLevels(opts);
+		logger.level = level;
+		logger.isLevelEnabled = function(level) {
+			if (!this.levels.values[level]) return false;
+			return this.levels.values[level] >= this.levels.values[this.level];
+		};
+		logger.setMaxListeners = logger.getMaxListeners = logger.emit = logger.addListener = logger.on = logger.prependListener = logger.once = logger.prependOnceListener = logger.removeListener = logger.removeAllListeners = logger.listeners = logger.listenerCount = logger.eventNames = logger.write = logger.flush = noop;
+		logger.serializers = serializers;
+		logger._serialize = serialize;
+		logger._stdErrSerialize = stdErrSerialize;
+		logger.child = function(...args) {
+			return child.call(this, setOpts, ...args);
+		};
+		if (transmit) logger._logEvent = createLogEventShape();
+		function getLevelVal() {
+			return levelToValue(this.level, this);
+		}
+		function getLevel() {
+			return this._level;
+		}
+		function setLevel(level) {
+			if (level !== "silent" && !this.levels.values[level]) throw Error("unknown level " + level);
+			this._level = level;
+			set(this, setOpts, logger, "error");
+			set(this, setOpts, logger, "fatal");
+			set(this, setOpts, logger, "warn");
+			set(this, setOpts, logger, "info");
+			set(this, setOpts, logger, "debug");
+			set(this, setOpts, logger, "trace");
+			customLevels.forEach((level) => {
+				set(this, setOpts, logger, level);
+			});
+		}
+		function child(setOpts, bindings, childOptions) {
+			if (!bindings) throw new Error("missing bindings for child Pino");
+			childOptions = childOptions || {};
+			if (serialize && bindings.serializers) childOptions.serializers = bindings.serializers;
+			const childOptionsSerializers = childOptions.serializers;
+			if (serialize && childOptionsSerializers) {
+				var childSerializers = Object.assign({}, serializers, childOptionsSerializers);
+				var childSerialize = opts.browser.serialize === true ? Object.keys(childSerializers) : serialize;
+				delete bindings.serializers;
+				applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize);
+			}
+			function Child(parent) {
+				this._childLevel = (parent._childLevel | 0) + 1;
+				this.bindings = bindings;
+				if (childSerializers) {
+					this.serializers = childSerializers;
+					this._serialize = childSerialize;
+				}
+				if (transmit) this._logEvent = createLogEventShape([].concat(parent._logEvent.bindings, bindings));
+			}
+			Child.prototype = this;
+			const newLogger = new Child(this);
+			appendChildLogger(this, newLogger);
+			newLogger.child = function(...args) {
+				return child.call(this, setOpts, ...args);
+			};
+			newLogger.level = childOptions.level || this.level;
+			setOpts.onChild(newLogger);
+			return newLogger;
+		}
+		return logger;
+	}
+	function getLevels(opts) {
+		const customLevels = opts.customLevels || {};
+		return {
+			values: Object.assign({}, pino.levels.values, customLevels),
+			labels: Object.assign({}, pino.levels.labels, invertObject(customLevels))
+		};
+	}
+	function invertObject(obj) {
+		const inverted = {};
+		Object.keys(obj).forEach(function(key) {
+			inverted[obj[key]] = key;
+		});
+		return inverted;
+	}
+	pino.levels = {
+		values: {
+			fatal: 60,
+			error: 50,
+			warn: 40,
+			info: 30,
+			debug: 20,
+			trace: 10
+		},
+		labels: {
+			10: "trace",
+			20: "debug",
+			30: "info",
+			40: "warn",
+			50: "error",
+			60: "fatal"
+		}
+	};
+	pino.stdSerializers = stdSerializers;
+	pino.stdTimeFunctions = Object.assign({}, {
+		nullTime,
+		epochTime,
+		unixTime,
+		isoTime
+	});
+	function getBindingChain(logger) {
+		const bindings = [];
+		if (logger.bindings) bindings.push(logger.bindings);
+		let hierarchy = logger[hierarchySymbol];
+		while (hierarchy.parent) {
+			hierarchy = hierarchy.parent;
+			if (hierarchy.logger.bindings) bindings.push(hierarchy.logger.bindings);
+		}
+		return bindings.reverse();
+	}
+	function set(self, opts, rootLogger, level) {
+		Object.defineProperty(self, level, {
+			value: levelToValue(self.level, rootLogger) > levelToValue(level, rootLogger) ? noop : rootLogger[baseLogFunctionSymbol][level],
+			writable: true,
+			enumerable: true,
+			configurable: true
+		});
+		if (self[level] === noop) {
+			if (!opts.transmit) return;
+			const transmitValue = levelToValue(opts.transmit.level || self.level, rootLogger);
+			if (levelToValue(level, rootLogger) < transmitValue) return;
+		}
+		self[level] = createWrap(self, opts, rootLogger, level);
+		const bindings = getBindingChain(self);
+		if (bindings.length === 0) return;
+		self[level] = prependBindingsInArguments(bindings, self[level]);
+	}
+	function prependBindingsInArguments(bindings, logFunc) {
+		return function() {
+			return logFunc.apply(this, [...bindings, ...arguments]);
+		};
+	}
+	function createWrap(self, opts, rootLogger, level) {
+		return (function(write) {
+			return function LOG() {
+				const ts = opts.timestamp();
+				const args = new Array(arguments.length);
+				const proto = Object.getPrototypeOf && Object.getPrototypeOf(this) === _console ? _console : this;
+				for (var i = 0; i < args.length; i++) args[i] = arguments[i];
+				var argsIsSerialized = false;
+				if (opts.serialize) {
+					applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize);
+					argsIsSerialized = true;
+				}
+				if (opts.asObject || opts.formatters) {
+					const out = asObject(this, level, args, ts, opts);
+					if (opts.reportCaller && out && out.length > 0 && out[0] && typeof out[0] === "object") try {
+						const caller = getCallerLocation();
+						if (caller) out[0].caller = caller;
+					} catch (e) {}
+					write.call(proto, ...out);
+				} else {
+					if (opts.reportCaller) try {
+						const caller = getCallerLocation();
+						if (caller) args.push(caller);
+					} catch (e) {}
+					write.apply(proto, args);
+				}
+				if (opts.transmit) {
+					const transmitLevel = opts.transmit.level || self._level;
+					const transmitValue = levelToValue(transmitLevel, rootLogger);
+					const methodValue = levelToValue(level, rootLogger);
+					if (methodValue < transmitValue) return;
+					transmit(this, {
+						ts,
+						methodLevel: level,
+						methodValue,
+						transmitLevel,
+						transmitValue: rootLogger.levels.values[opts.transmit.level || self._level],
+						send: opts.transmit.send,
+						val: levelToValue(self._level, rootLogger)
+					}, args, argsIsSerialized);
+				}
+			};
+		})(self[baseLogFunctionSymbol][level]);
+	}
+	function asObject(logger, level, args, ts, opts) {
+		const { level: levelFormatter, log: logObjectFormatter = (obj) => obj } = opts.formatters || {};
+		const argsCloned = args.slice();
+		let msg = argsCloned[0];
+		const logObject = {};
+		let lvl = (logger._childLevel | 0) + 1;
+		if (lvl < 1) lvl = 1;
+		if (ts) logObject.time = ts;
+		if (levelFormatter) {
+			const formattedLevel = levelFormatter(level, logger.levels.values[level]);
+			Object.assign(logObject, formattedLevel);
+		} else logObject.level = logger.levels.values[level];
+		if (opts.asObjectBindingsOnly) {
+			if (msg !== null && typeof msg === "object") while (lvl-- && typeof argsCloned[0] === "object") Object.assign(logObject, argsCloned.shift());
+			return [logObjectFormatter(logObject), ...argsCloned];
+		} else {
+			if (msg !== null && typeof msg === "object") {
+				while (lvl-- && typeof argsCloned[0] === "object") Object.assign(logObject, argsCloned.shift());
+				msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : void 0;
+			} else if (typeof msg === "string") msg = format(argsCloned.shift(), argsCloned);
+			if (msg !== void 0) logObject[opts.messageKey] = msg;
+			return [logObjectFormatter(logObject)];
+		}
+	}
+	function applySerializers(args, serialize, serializers, stdErrSerialize) {
+		for (const i in args) if (stdErrSerialize && args[i] instanceof Error) args[i] = pino.stdSerializers.err(args[i]);
+		else if (typeof args[i] === "object" && !Array.isArray(args[i]) && serialize) {
+			for (const k in args[i]) if (serialize.indexOf(k) > -1 && k in serializers) args[i][k] = serializers[k](args[i][k]);
+		}
+	}
+	function transmit(logger, opts, args, argsIsSerialized = false) {
+		const send = opts.send;
+		const ts = opts.ts;
+		const methodLevel = opts.methodLevel;
+		const methodValue = opts.methodValue;
+		const val = opts.val;
+		const bindings = logger._logEvent.bindings;
+		if (!argsIsSerialized) applySerializers(args, logger._serialize || Object.keys(logger.serializers), logger.serializers, logger._stdErrSerialize === void 0 ? true : logger._stdErrSerialize);
+		logger._logEvent.ts = ts;
+		logger._logEvent.messages = args.filter(function(arg) {
+			return bindings.indexOf(arg) === -1;
+		});
+		logger._logEvent.level.label = methodLevel;
+		logger._logEvent.level.value = methodValue;
+		send(methodLevel, logger._logEvent, val);
+		logger._logEvent = createLogEventShape(bindings);
+	}
+	function createLogEventShape(bindings) {
+		return {
+			ts: 0,
+			messages: [],
+			bindings: bindings || [],
+			level: {
+				label: "",
+				value: 0
+			}
+		};
+	}
+	function asErrValue(err) {
+		const obj = {
+			type: err.constructor.name,
+			msg: err.message,
+			stack: err.stack
+		};
+		for (const key in err) if (obj[key] === void 0) obj[key] = err[key];
+		return obj;
+	}
+	function getTimeFunction(opts) {
+		if (typeof opts.timestamp === "function") return opts.timestamp;
+		if (opts.timestamp === false) return nullTime;
+		return epochTime;
+	}
+	function mock() {
+		return {};
+	}
+	function passthrough(a) {
+		return a;
+	}
+	function noop() {}
+	function nullTime() {
+		return false;
+	}
+	function epochTime() {
+		return Date.now();
+	}
+	function unixTime() {
+		return Math.round(Date.now() / 1e3);
+	}
+	function isoTime() {
+		return new Date(Date.now()).toISOString();
+	}
+	/* istanbul ignore next */
+	function pfGlobalThisOrFallback() {
+		function defd(o) {
+			return typeof o !== "undefined" && o;
+		}
+		try {
+			if (typeof globalThis !== "undefined") return globalThis;
+			Object.defineProperty(Object.prototype, "globalThis", {
+				get: function() {
+					delete Object.prototype.globalThis;
+					return this.globalThis = this;
+				},
+				configurable: true
+			});
+			return globalThis;
+		} catch (e) {
+			return defd(self) || defd(window) || defd(this) || {};
+		}
+	}
+	module.exports.default = pino;
+	module.exports.pino = pino;
+	/* istanbul ignore next */
+	function getCallerLocation() {
+		const stack = (/* @__PURE__ */ new Error()).stack;
+		if (!stack) return null;
+		const lines = stack.split("\n");
+		for (let i = 1; i < lines.length; i++) {
+			const l = lines[i].trim();
+			if (/(^at\s+)?(createWrap|LOG|set\s*\(|asObject|Object\.apply|Function\.apply)/.test(l)) continue;
+			if (l.indexOf("browser.js") !== -1) continue;
+			if (l.indexOf("node:internal") !== -1) continue;
+			if (l.indexOf("node_modules") !== -1) continue;
+			let m = l.match(/\((.*?):(\d+):(\d+)\)/);
+			if (!m) m = l.match(/at\s+(.*?):(\d+):(\d+)/);
+			if (m) {
+				const file = m[1];
+				const line = m[2];
+				const col = m[3];
+				return file + ":" + line + ":" + col;
+			}
+		}
+		return null;
+	}
+})))(), 1);
+/**
+* Sensitive fields to strip from logged args.
+* These are replaced with '[REDACTED]' to prevent token leakage.
+*/
+var SENSITIVE_KEYS = [
+	"apiToken",
+	"token",
+	"password",
+	"secret",
+	"key",
+	"credentials"
+];
+/**
+* Return a shallow copy of `args` with sensitive keys replaced by '[REDACTED]'.
+*/
+function sanitizeArgs(args) {
+	const sanitized = { ...args };
+	for (const k of SENSITIVE_KEYS) if (k in sanitized) sanitized[k] = "[REDACTED]";
+	return sanitized;
+}
+/**
+* Resolve the audit log file path.
+*
+* Priority:
+* 1. `FORGE_AUDIT_LOG` environment variable
+* 2. `~/.config/forge-tools/audit.log` (default)
+*/
+function getAuditLogPath() {
+	if (process.env.FORGE_AUDIT_LOG) return process.env.FORGE_AUDIT_LOG;
+	return join(homedir(), ".config", "forge-tools", "audit.log");
+}
+/**
+* Create an audit logger that appends structured JSON lines to the audit log.
+*
+* Failures are always silent — logging must never interrupt the actual operation.
+*
+* @param source - Identifies who is logging ('mcp' or 'cli').
+*/
+function createAuditLogger(source) {
+	let logger = null;
+	try {
+		const logPath = getAuditLogPath();
+		mkdirSync(dirname(logPath), { recursive: true });
+		logger = (0, import_browser.default)({ level: "info" }, createWriteStream(logPath, { flags: "a" }));
+	} catch {}
+	return { log(entry) {
+		try {
+			if (!logger) return;
+			logger.info({
+				source,
+				resource: entry.resource,
+				action: entry.action,
+				args: sanitizeArgs(entry.args),
+				status: entry.status,
+				...entry.error !== void 0 ? { error: entry.error } : {}
+			});
+		} catch {}
+	} };
+}
 /**
 * Create a test executor context with a mock HTTP client.
 *
@@ -123,6 +710,64 @@ async function deploySite(options, ctx) {
 	return { data: void 0 };
 }
 /**
+* Trigger a deployment and wait for it to complete.
+*
+* 1. POSTs to the deploy endpoint.
+* 2. Polls GET /servers/{id}/sites/{site_id} every `poll_interval_ms` ms.
+* 3. When `deployment_status` becomes null the deploy is done.
+* 4. Fetches the deployment log.
+* 5. Checks the most recent deployment status to determine success/failure.
+*/
+async function deploySiteAndWait(options, ctx) {
+	const { server_id, site_id, poll_interval_ms = 3e3, timeout_ms = 6e5, onProgress } = options;
+	const baseUrl = `/servers/${server_id}/sites/${site_id}`;
+	await ctx.client.post(`${baseUrl}/deployment/deploy`);
+	const startTime = Date.now();
+	await new Promise((resolve) => {
+		const tick = async () => {
+			const elapsed_ms = Date.now() - startTime;
+			if (elapsed_ms >= timeout_ms) {
+				resolve();
+				return;
+			}
+			const currentStatus = (await ctx.client.get(`/servers/${server_id}/sites/${site_id}`)).site.deployment_status;
+			if (onProgress) onProgress({
+				status: currentStatus ?? "done",
+				elapsed_ms
+			});
+			if (currentStatus === null) {
+				resolve();
+				return;
+			}
+			await new Promise((r) => setTimeout(r, poll_interval_ms));
+			await tick();
+		};
+		tick().catch(() => resolve());
+	});
+	const elapsed_ms = Date.now() - startTime;
+	let log = "";
+	try {
+		log = await ctx.client.get(`${baseUrl}/deployment/log`);
+	} catch {}
+	let deployStatus = "failed";
+	try {
+		const deployments = (await ctx.client.get(`${baseUrl}/deployments`)).deployments;
+		if (deployments.length > 0) deployStatus = deployments[0].status === "finished" ? "success" : "failed";
+	} catch {}
+	if (elapsed_ms >= timeout_ms) deployStatus = "failed";
+	return { data: {
+		status: deployStatus,
+		log,
+		elapsed_ms
+	} };
+}
+/**
+* Get the deployment log for a site.
+*/
+async function getDeploymentLog(options, ctx) {
+	return { data: await ctx.client.get(`/servers/${options.server_id}/sites/${options.site_id}/deployment/log`) };
+}
+/**
 * Get the output of a deployment.
 */
 async function getDeploymentOutput(options, ctx) {
@@ -475,6 +1120,6 @@ async function listScheduledJobs(options, ctx) {
 async function getUser(_options, ctx) {
 	return { data: (await ctx.client.get("/user")).user };
 }
-export { ACTIONS, RESOURCES, activateCertificate, createBackupConfig, createCertificate, createCommand, createDaemon, createDatabase, createDatabaseUser, createFirewallRule, createMonitor, createNginxTemplate, createRecipe, createRedirectRule, createScheduledJob, createSecurityRule, createServer, createSite, createSshKey, createTestExecutorContext, deleteBackupConfig, deleteCertificate, deleteDaemon, deleteDatabase, deleteDatabaseUser, deleteFirewallRule, deleteMonitor, deleteNginxTemplate, deleteRecipe, deleteRedirectRule, deleteScheduledJob, deleteSecurityRule, deleteServer, deleteSite, deleteSshKey, deploySite, getBackupConfig, getCertificate, getCommand, getDaemon, getDatabase, getDatabaseUser, getDeploymentOutput, getDeploymentScript, getEnv, getFirewallRule, getMonitor, getNginxConfig, getNginxTemplate, getRecipe, getRedirectRule, getScheduledJob, getSecurityRule, getServer, getSite, getSshKey, getUser, listBackupConfigs, listCertificates, listCommands, listDaemons, listDatabaseUsers, listDatabases, listDeployments, listFirewallRules, listMonitors, listNginxTemplates, listRecipes, listRedirectRules, listScheduledJobs, listSecurityRules, listServers, listSites, listSshKeys, rebootServer, restartDaemon, runRecipe, updateDeploymentScript, updateEnv, updateNginxConfig, updateNginxTemplate };
+export { ACTIONS, RESOURCES, activateCertificate, createAuditLogger, createBackupConfig, createCertificate, createCommand, createDaemon, createDatabase, createDatabaseUser, createFirewallRule, createMonitor, createNginxTemplate, createRecipe, createRedirectRule, createScheduledJob, createSecurityRule, createServer, createSite, createSshKey, createTestExecutorContext, deleteBackupConfig, deleteCertificate, deleteDaemon, deleteDatabase, deleteDatabaseUser, deleteFirewallRule, deleteMonitor, deleteNginxTemplate, deleteRecipe, deleteRedirectRule, deleteScheduledJob, deleteSecurityRule, deleteServer, deleteSite, deleteSshKey, deploySite, deploySiteAndWait, getAuditLogPath, getBackupConfig, getCertificate, getCommand, getDaemon, getDatabase, getDatabaseUser, getDeploymentLog, getDeploymentOutput, getDeploymentScript, getEnv, getFirewallRule, getMonitor, getNginxConfig, getNginxTemplate, getRecipe, getRedirectRule, getScheduledJob, getSecurityRule, getServer, getSite, getSshKey, getUser, listBackupConfigs, listCertificates, listCommands, listDaemons, listDatabaseUsers, listDatabases, listDeployments, listFirewallRules, listMonitors, listNginxTemplates, listRecipes, listRedirectRules, listScheduledJobs, listSecurityRules, listServers, listSites, listSshKeys, rebootServer, restartDaemon, runRecipe, sanitizeArgs, updateDeploymentScript, updateEnv, updateNginxConfig, updateNginxTemplate };
 
 //# sourceMappingURL=index.js.map