@alfe.ai/gateway 0.9.18 → 0.9.19

package/dist/runtime-upgrade.js

@@ -1,38 +1,31 @@
-import { n as logger } from "./logger.js";
+import { d as supportsOpenClawNode, l as OPENCLAW_NODE_REQUIREMENT, n as OPENCLAW_EXTERNAL_SUPERVISOR_ENV } from "./runtime-process.js";
+import { m as logger } from "./sentry.js";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 //#region src/runtime-upgrade.ts
 /**
-* Runtime upgrade — install/update the runtime binary then cycle the RuntimeProcess.
+* Runtime upgrade — safely replace a runtime binary and cycle its child.
 *
-* Unlike CLI upgrade (which exits the daemon for systemd restart),
-* runtime upgrade keeps the daemon running and just restarts the child process.
+* OpenClaw upgrades are a state migration, not just an npm install:
+*   1. prove the host Node.js version can run the target;
+*   2. drain/suspend the runtime and serialize against every OpenClaw CLI writer;
+*   3. create and verify an OpenClaw backup (workspace excluded; sync owns it);
+*   4. install and verify the exact package version;
+*   5. run the non-interactive doctor migration and post-upgrade audit;
+*   6. resume the runtime under Alfe's external supervisor.
 *
-* Flow (generic across runtimes):
-*   1. Stop the RuntimeProcess child (SIGTERM + grace period)
-*   2. Run the per-runtime upgrade command (see `resolveUpgradeCommand`)
-*   3. Restart the RuntimeProcess child
-*
-* On install failure, the runtime is restarted on the old version.
+* If package replacement fails before doctor starts, the previous exact version
+* is reinstalled. Once doctor has begun, automatic package rollback is unsafe:
+* OpenClaw 2 may already have migrated session/state storage. The verified
+* archive is retained for operator recovery and the new runtime is resumed so
+* its idempotent doctor can be retried.
 */
 const execFileAsync = promisify(execFile);
-/**
-* Resolve the per-runtime upgrade command.
-*
-* - `openclaw`:    `npm install -g openclaw@<version>` — version-pinned.
-* - `claude-code`: `npm install -g @alfe.ai/claude-code-host@<version>` — the
-*                  runtime child is the host binary; mirrors openclaw. The
-*                  caller defaults a missing version to the pin.
-* - `hermes`:      `hermes update --yes` — Hermes self-updates from its own
-*                  channel. A pinned version does not map to a Hermes CLI flag,
-*                  so the `version` arg is intentionally ignored on this branch.
-*
-* Returns `undefined` for an unknown runtime (or openclaw/claude-code with no
-* version), which the caller treats as a failed upgrade (restart on the old
-* version). `upgradeRuntime` restarts the RuntimeProcess child regardless of
-* runtime, so a new branch here is all that's needed to cycle onto the new
-* version.
-*/
+const OPENCLAW_UPGRADE_TIMEOUT_MS = 3e5;
+const OPENCLAW_DOCTOR_TIMEOUT_MS = 3e5;
 function resolveUpgradeCommand(runtime, version) {
 	switch (runtime) {
 		case "openclaw":
@@ -62,7 +55,25 @@ function resolveUpgradeCommand(runtime, version) {
 		default: return;
 	}
 }
-async function upgradeRuntime(runtime, version, runtimeProcess) {
+/** Extract the semver-like version token printed by `openclaw --version`. */
+function parseOpenClawVersion(output) {
+	return /(?:^|\s)(\d{4}\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)(?:\s|$)/u.exec(output.trim())?.[1];
+}
+async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
+	const runCommand = options.runCommand ?? (async (command, args, commandOptions) => {
+		const result = await execFileAsync(command, args, commandOptions);
+		return {
+			stdout: result.stdout,
+			stderr: result.stderr
+		};
+	});
+	const commandOptions = (timeout) => runtime === "openclaw" ? {
+		timeout,
+		env: {
+			...process.env,
+			...OPENCLAW_EXTERNAL_SUPERVISOR_ENV
+		}
+	} : { timeout };
 	const cmd = resolveUpgradeCommand(runtime, version);
 	if (!cmd) {
 		const message = `No upgrade command for runtime '${runtime}'`;
@@ -77,52 +88,143 @@ async function upgradeRuntime(runtime, version, runtimeProcess) {
 			error: message
 		};
 	}
+	let previousOpenClawVersion;
+	if (runtime === "openclaw") try {
+		const [{ stdout: nodeOutput }, { stdout: openClawOutput }] = await Promise.all([runCommand("node", ["--version"], commandOptions(1e4)), runCommand("openclaw", ["--version"], commandOptions(1e4))]);
+		const nodeVersion = nodeOutput.trim();
+		if (!supportsOpenClawNode(nodeVersion)) {
+			const message = `OpenClaw ${version ?? "2.x"} requires Node.js ${OPENCLAW_NODE_REQUIREMENT}; this host resolves ${nodeVersion}. Upgrade Node.js or rebuild the agent before retrying.`;
+			logger.error({
+				runtime,
+				version,
+				nodeVersion
+			}, message);
+			return {
+				success: false,
+				runtime,
+				version,
+				error: message
+			};
+		}
+		previousOpenClawVersion = parseOpenClawVersion(openClawOutput);
+	} catch (err) {
+		const message = `OpenClaw upgrade preflight failed: ${err instanceof Error ? err.message : String(err)}`;
+		logger.error({
+			runtime,
+			version
+		}, message);
+		return {
+			success: false,
+			runtime,
+			version,
+			error: message
+		};
+	}
 	logger.info({
 		runtime,
 		version
 	}, "Upgrading runtime...");
-	if (runtimeProcess) {
-		logger.info("Stopping runtime for upgrade...");
-		await runtimeProcess.stopWhenIdle();
-	}
+	let gateSuspended = false;
+	let packageInstallAttempted = false;
+	let doctorStarted = false;
+	let runtimeChanged = false;
+	const performUpgrade = async () => {
+		try {
+			if (runtime === "openclaw") {
+				const backupDirectory = options.backupDirectory ?? join(homedir(), ".alfe", "backups", "openclaw");
+				await mkdir(backupDirectory, {
+					recursive: true,
+					mode: 448
+				});
+				const backup = await runCommand("openclaw", [
+					"backup",
+					"create",
+					"--output",
+					backupDirectory,
+					"--verify",
+					"--no-include-workspace",
+					"--json"
+				], commandOptions(OPENCLAW_UPGRADE_TIMEOUT_MS));
+				if (backup.stdout) logger.info({ backup: backup.stdout.trim() }, "Verified pre-upgrade OpenClaw backup created");
+			}
+			packageInstallAttempted = true;
+			const { stdout, stderr } = await runCommand(cmd.command, cmd.args, commandOptions(OPENCLAW_UPGRADE_TIMEOUT_MS));
+			if (stdout) logger.debug({ stdout: stdout.trim() }, "runtime upgrade stdout");
+			if (stderr) logger.debug({ stderr: stderr.trim() }, "runtime upgrade stderr");
+			if (runtime === "openclaw" && version) {
+				const installedVersion = parseOpenClawVersion((await runCommand("openclaw", ["--version"], commandOptions(1e4))).stdout);
+				if (installedVersion !== version) throw new Error(`OpenClaw package verification failed: requested ${version}, resolved ${installedVersion ?? "unknown"}`);
+				runtimeChanged = installedVersion !== previousOpenClawVersion;
+				doctorStarted = true;
+				await runCommand("openclaw", [
+					"doctor",
+					"--fix",
+					"--non-interactive",
+					"--yes",
+					"--json"
+				], commandOptions(OPENCLAW_DOCTOR_TIMEOUT_MS));
+				const audit = await runCommand("openclaw", [
+					"doctor",
+					"--post-upgrade",
+					"--json"
+				], commandOptions(OPENCLAW_DOCTOR_TIMEOUT_MS));
+				if (audit.stdout) logger.info({ audit: audit.stdout.trim() }, "OpenClaw post-upgrade audit completed");
+			}
+		} catch (err) {
+			if (runtime === "openclaw" && packageInstallAttempted && !doctorStarted && previousOpenClawVersion) try {
+				logger.warn({ previousOpenClawVersion }, "OpenClaw package replacement failed before state migration — restoring previous package");
+				await runCommand("npm", [
+					"install",
+					"-g",
+					`openclaw@${previousOpenClawVersion}`
+				], commandOptions(OPENCLAW_UPGRADE_TIMEOUT_MS));
+				if (parseOpenClawVersion((await runCommand("openclaw", ["--version"], commandOptions(1e4))).stdout) !== previousOpenClawVersion) throw new Error("restored OpenClaw version did not verify");
+				runtimeChanged = false;
+			} catch (rollbackError) {
+				logger.error({ err: rollbackError instanceof Error ? rollbackError.message : String(rollbackError) }, "Failed to restore the previous OpenClaw package after upgrade failure");
+			}
+			throw err;
+		}
+	};
 	try {
-		const { stdout, stderr } = await execFileAsync(cmd.command, cmd.args, { timeout: 12e4 });
-		if (stdout) logger.debug({ stdout: stdout.trim() }, "runtime upgrade stdout");
-		if (stderr) logger.debug({ stderr: stderr.trim() }, "runtime upgrade stderr");
+		if (options.gate) {
+			gateSuspended = true;
+			await options.gate.suspend();
+		} else if (runtimeProcess) await runtimeProcess.stopWhenIdle();
+		if (runtime === "openclaw" && options.cliLock) await options.cliLock.run(performUpgrade);
+		else await performUpgrade();
 		logger.info({
 			runtime,
 			version
 		}, "Runtime upgraded successfully");
+		return {
+			success: true,
+			runtime,
+			version,
+			runtimeChanged
+		};
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
 		logger.error({
 			err: message,
 			runtime,
 			version
-		}, "Runtime upgrade install command failed");
-		if (runtimeProcess) try {
-			logger.info("Restarting runtime on previous version after failed upgrade...");
-			await runtimeProcess.restart();
-		} catch (restartErr) {
-			const restartMsg = restartErr instanceof Error ? restartErr.message : String(restartErr);
-			logger.error({ err: restartMsg }, "Failed to restart runtime after failed upgrade");
-		}
+		}, "Runtime upgrade failed");
 		return {
 			success: false,
 			runtime,
 			version,
+			runtimeChanged,
 			error: message
 		};
+	} finally {
+		try {
+			if (gateSuspended && options.gate) await options.gate.resume();
+			else if (!options.gate && runtimeProcess) await runtimeProcess.restart();
+		} catch (restartErr) {
+			logger.error({ err: restartErr instanceof Error ? restartErr.message : String(restartErr) }, "Failed to resume runtime after upgrade attempt");
+		}
 	}
-	if (runtimeProcess) {
-		logger.info("Restarting runtime after upgrade...");
-		await runtimeProcess.restart();
-	}
-	return {
-		success: true,
-		runtime,
-		version
-	};
 }
 //#endregion
 export { upgradeRuntime };

package/dist/sentry.js

@@ -1,4 +1,49 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import pino from "pino";
+import { mkdirSync } from "node:fs";
 import { readConfig, resolveConfig } from "@alfe.ai/config";
+//#region src/logger.ts
+/**
+* Daemon logger — pino with rolling file output.
+*
+* Writes to ~/.alfe/logs/gateway.log with 10MB rotation, keep 5 files.
+* In managed mode (ECS Fargate): always stdout for CloudWatch capture.
+* In development: stdout.
+*/
+const LOG_DIR = join(homedir(), ".alfe", "logs");
+const LOG_FILE = join(LOG_DIR, "gateway.log");
+const isDev = process.env.NODE_ENV !== "production";
+const isManaged = process.env.ALFE_MANAGED === "true";
+if (!isManaged) try {
+	mkdirSync(LOG_DIR, { recursive: true });
+} catch {}
+/**
+* Create the daemon logger.
+* Managed mode (ECS): JSON to stdout (CloudWatch captures via awslogs driver).
+* Development: JSON to stdout.
+* Production (local): JSON to rolling file.
+*/
+function createLogger() {
+	if (isDev || isManaged) return pino({
+		level: process.env.LOG_LEVEL ?? (isDev ? "debug" : "info"),
+		transport: {
+			target: "pino/file",
+			options: { destination: 1 }
+		}
+	});
+	const transport = pino.transport({
+		target: "pino-roll",
+		options: {
+			file: LOG_FILE,
+			size: "10m",
+			limit: { count: 5 }
+		}
+	});
+	return pino({ level: process.env.LOG_LEVEL ?? "info" }, transport);
+}
+const logger = createLogger();
+//#endregion
 //#region src/sentry.ts
 /**
 * Agent-side error reporting (Sentry) for the Alfe CLI + gateway daemon.
@@ -383,4 +428,4 @@ function captureFatal(cause) {
 	} catch {}
 }
 //#endregion
-export { captureFatal as a, captureRuntimeCrash as c, initAgentSentry as d, setAgentContext as f, captureCliFailure as i, captureRuntimeErrorOutput as l, AGENT_MCP_SENTRY_DSN as n, captureIntegrationFailure as o, AGENT_RUNTIME_SENTRY_DSN as r, captureMcpFailure as s, AGENT_DAEMON_SENTRY_DSN as t, flushSentry as u };
+export { captureFatal as a, captureRuntimeCrash as c, initAgentSentry as d, setAgentContext as f, captureCliFailure as i, captureRuntimeErrorOutput as l, logger as m, AGENT_MCP_SENTRY_DSN as n, captureIntegrationFailure as o, LOG_FILE as p, AGENT_RUNTIME_SENTRY_DSN as r, captureMcpFailure as s, AGENT_DAEMON_SENTRY_DSN as t, flushSentry as u };

package/dist/src/index.d.ts

@@ -44,8 +44,8 @@ declare function startDaemon(): Promise<void>;
  * truth for every install path:
  *   - `@alfe.ai/cli` `installRuntime` (fresh `alfe setup`)
  *   - the daemon `runtime.update` default (this package)
- *   - the managed Docker image (`services/compute/Dockerfile` — build args can't import
- *     TypeScript, so it hardcodes this same value; keep them in sync)
+ *   - managed provisioning (`services/compute/src/lib/provisioner.ts` installs a
+ *     compatible Node.js 22 before the CLI consumes this pin)
  *
  * Pinning (rather than floating `npm install -g openclaw` → `latest`) is deliberate:
  * OpenClaw runs on every managed agent, so a `latest` that changes runtime semantics —
@@ -53,7 +53,14 @@ declare function startDaemon(): Promise<void>;
  * silent fleet outage with no Alfe deploy. Bump deliberately after validating a new
  * OpenClaw, then cut a CLI release so the pin travels with the CLI version.
  */
-declare const PINNED_OPENCLAW_VERSION = "2026.6.11";
+declare const PINNED_OPENCLAW_VERSION = "2026.8.1";
+/** OpenClaw 2026.8.1's published Node.js engine floor. */
+declare const OPENCLAW_NODE_REQUIREMENT = ">=22.22.3 <23 || >=24.15.0 <25 || >=25.9.0";
+/**
+ * Whether a concrete Node.js version satisfies OpenClaw 2.x's engine range.
+ * Accepts `process.versions.node` (`22.22.3`) or CLI output (`v22.22.3`).
+ */
+declare function supportsOpenClawNode(nodeVersion: string): boolean;
 //#endregion
 //#region src/claude-code-host-version.d.ts
 /**
@@ -407,4 +414,4 @@ declare function checkExistingDaemon(): Promise<number | null>;
  */
 declare function stopExistingDaemon(): Promise<boolean>;
 //#endregion
-export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, type AgentIdentity, type AgentWorkspaceConfig, type DaemonConfig, type DaemonHealth, type IPCEvent, type IPCRequest, type IPCResponse, type InitAgentSentryOptions, PID_PATH, PINNED_CLAUDE_CODE_HOST_VERSION, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, type RuntimeOutputLine, SOCKET_PATH, type SentrySurface, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, isServiceInstalled, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, restartService, setAgentContext, startDaemon, startService, stopExistingDaemon, stopService, uninstallService };
+export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, type AgentIdentity, type AgentWorkspaceConfig, type DaemonConfig, type DaemonHealth, type IPCEvent, type IPCRequest, type IPCResponse, type InitAgentSentryOptions, OPENCLAW_NODE_REQUIREMENT, PID_PATH, PINNED_CLAUDE_CODE_HOST_VERSION, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, type RuntimeOutputLine, SOCKET_PATH, type SentrySurface, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, isServiceInstalled, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, restartService, setAgentContext, startDaemon, startService, stopExistingDaemon, stopService, supportsOpenClawNode, uninstallService };

package/dist/src/index.js

@@ -1,4 +1,4 @@
-import { _ as loadDaemonConfig, a as installService, b as PINNED_OPENCLAW_VERSION, c as startService, d as uninstallService, f as PROTOCOL_VERSION, g as fetchAgentConfig, h as SOCKET_PATH, i as checkExistingDaemon, l as stopExistingDaemon, m as PID_PATH, n as queryDaemonHealth, o as isServiceInstalled, p as ALFE_DIR, r as startDaemon, s as restartService, t as formatHealthReport, u as stopService, v as resolveAgentIdentity, y as PINNED_CLAUDE_CODE_HOST_VERSION } from "../health.js";
-import { n as logger } from "../logger.js";
-import { a as captureFatal, c as captureRuntimeCrash, d as initAgentSentry, f as setAgentContext, i as captureCliFailure, l as captureRuntimeErrorOutput, n as AGENT_MCP_SENTRY_DSN, o as captureIntegrationFailure, r as AGENT_RUNTIME_SENTRY_DSN, s as captureMcpFailure, t as AGENT_DAEMON_SENTRY_DSN, u as flushSentry } from "../sentry.js";
-export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, PID_PATH, PINNED_CLAUDE_CODE_HOST_VERSION, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, SOCKET_PATH, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, isServiceInstalled, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, restartService, setAgentContext, startDaemon, startService, stopExistingDaemon, stopService, uninstallService };
+import { d as supportsOpenClawNode, l as OPENCLAW_NODE_REQUIREMENT, u as PINNED_OPENCLAW_VERSION } from "../runtime-process.js";
+import { _ as loadDaemonConfig, a as installService, c as startService, d as uninstallService, f as PROTOCOL_VERSION, g as fetchAgentConfig, h as SOCKET_PATH, i as checkExistingDaemon, l as stopExistingDaemon, m as PID_PATH, n as queryDaemonHealth, o as isServiceInstalled, p as ALFE_DIR, r as startDaemon, s as restartService, t as formatHealthReport, u as stopService, v as resolveAgentIdentity, y as PINNED_CLAUDE_CODE_HOST_VERSION } from "../health.js";
+import { a as captureFatal, c as captureRuntimeCrash, d as initAgentSentry, f as setAgentContext, i as captureCliFailure, l as captureRuntimeErrorOutput, m as logger, n as AGENT_MCP_SENTRY_DSN, o as captureIntegrationFailure, r as AGENT_RUNTIME_SENTRY_DSN, s as captureMcpFailure, t as AGENT_DAEMON_SENTRY_DSN, u as flushSentry } from "../sentry.js";
+export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, OPENCLAW_NODE_REQUIREMENT, PID_PATH, PINNED_CLAUDE_CODE_HOST_VERSION, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, SOCKET_PATH, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, isServiceInstalled, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, restartService, setAgentContext, startDaemon, startService, stopExistingDaemon, stopService, supportsOpenClawNode, uninstallService };

package/dist/upgrade.js

@@ -1,5 +1,4 @@
-import { n as logger } from "./logger.js";
-import { i as captureCliFailure } from "./sentry.js";
+import { i as captureCliFailure, m as logger } from "./sentry.js";
 import { existsSync } from "node:fs";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/gateway",
-  "version": "0.9.18",
+  "version": "0.9.19",
   "description": "Alfe local gateway daemon — persistent control plane for agent integrations",
   "type": "module",
   "bin": {
@@ -23,11 +23,11 @@
     "pino-roll": "^1.2.0",
     "smol-toml": ">=1.6.1",
     "ws": "^8.18.0",
-    "@alfe.ai/agent-api-client": "^0.19.0",
+    "@alfe.ai/agent-api-client": "^0.19.1",
     "@alfe.ai/ai-proxy-local": "^0.0.17",
     "@alfe.ai/config": "^0.4.1",
-    "@alfe.ai/integration-manifest": "^0.4.1",
-    "@alfe.ai/integrations": "^0.6.5",
+    "@alfe.ai/integration-manifest": "^0.4.2",
+    "@alfe.ai/integrations": "^0.6.6",
     "@alfe.ai/mcp-bundler": "^0.4.2"
   },
   "license": "UNLICENSED",

package/dist/logger.js

@@ -1,46 +0,0 @@
-import { join } from "node:path";
-import { homedir } from "node:os";
-import pino from "pino";
-import { mkdirSync } from "node:fs";
-//#region src/logger.ts
-/**
-* Daemon logger — pino with rolling file output.
-*
-* Writes to ~/.alfe/logs/gateway.log with 10MB rotation, keep 5 files.
-* In managed mode (ECS Fargate): always stdout for CloudWatch capture.
-* In development: stdout.
-*/
-const LOG_DIR = join(homedir(), ".alfe", "logs");
-const LOG_FILE = join(LOG_DIR, "gateway.log");
-const isDev = process.env.NODE_ENV !== "production";
-const isManaged = process.env.ALFE_MANAGED === "true";
-if (!isManaged) try {
-	mkdirSync(LOG_DIR, { recursive: true });
-} catch {}
-/**
-* Create the daemon logger.
-* Managed mode (ECS): JSON to stdout (CloudWatch captures via awslogs driver).
-* Development: JSON to stdout.
-* Production (local): JSON to rolling file.
-*/
-function createLogger() {
-	if (isDev || isManaged) return pino({
-		level: process.env.LOG_LEVEL ?? (isDev ? "debug" : "info"),
-		transport: {
-			target: "pino/file",
-			options: { destination: 1 }
-		}
-	});
-	const transport = pino.transport({
-		target: "pino-roll",
-		options: {
-			file: LOG_FILE,
-			size: "10m",
-			limit: { count: 5 }
-		}
-	});
-	return pino({ level: process.env.LOG_LEVEL ?? "info" }, transport);
-}
-const logger = createLogger();
-//#endregion
-export { logger as n, LOG_FILE as t };