miladyai 2.0.0-alpha.27

package/dist/auth/credentials.js

@@ -0,0 +1,156 @@
+import { SUBSCRIPTION_PROVIDER_MAP } from "./types.js";
+import { refreshAnthropicToken } from "./anthropic.js";
+import { refreshCodexToken } from "./openai-codex.js";
+import os from "node:os";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import fs from "node:fs";
+
+//#region src/auth/credentials.ts
+/**
+* Credential storage and token refresh for subscription providers.
+*
+* Stores OAuth credentials in ~/.milady/auth/ as JSON files.
+*/
+const AUTH_DIR = path.join(process.env.MILADY_HOME || path.join(os.homedir(), ".milady"), "auth");
+/** Buffer before expiry to trigger refresh (5 minutes) */
+const REFRESH_BUFFER_MS = 300 * 1e3;
+function ensureAuthDir() {
+	if (!fs.existsSync(AUTH_DIR)) fs.mkdirSync(AUTH_DIR, {
+		recursive: true,
+		mode: 448
+	});
+}
+function credentialPath(provider) {
+	return path.join(AUTH_DIR, `${provider}.json`);
+}
+/**
+* Save credentials for a provider.
+*/
+function saveCredentials(provider, credentials) {
+	ensureAuthDir();
+	const stored = {
+		provider,
+		credentials,
+		createdAt: Date.now(),
+		updatedAt: Date.now()
+	};
+	fs.writeFileSync(credentialPath(provider), JSON.stringify(stored, null, 2), {
+		encoding: "utf-8",
+		mode: 384
+	});
+	logger.info(`[auth] Saved ${provider} credentials`);
+}
+/**
+* Load stored credentials for a provider.
+*/
+function loadCredentials(provider) {
+	const filePath = credentialPath(provider);
+	try {
+		const data = fs.readFileSync(filePath, "utf-8");
+		return JSON.parse(data);
+	} catch (err) {
+		if (err.code === "ENOENT") return null;
+		throw err;
+	}
+}
+/**
+* Delete stored credentials for a provider.
+*/
+function deleteCredentials(provider) {
+	const filePath = credentialPath(provider);
+	try {
+		fs.unlinkSync(filePath);
+		logger.info(`[auth] Deleted ${provider} credentials`);
+	} catch (err) {
+		if (err.code !== "ENOENT") throw err;
+	}
+}
+/**
+* Get a valid access token, refreshing if needed.
+* Returns null if no credentials stored or refresh fails.
+*/
+async function getAccessToken(provider) {
+	const stored = loadCredentials(provider);
+	if (!stored) return null;
+	const { credentials } = stored;
+	if (credentials.expires > Date.now() + REFRESH_BUFFER_MS) return credentials.access;
+	logger.info(`[auth] Refreshing ${provider} token...`);
+	try {
+		let refreshed;
+		if (provider === "anthropic-subscription") refreshed = await refreshAnthropicToken(credentials.refresh);
+		else if (provider === "openai-codex") refreshed = await refreshCodexToken(credentials.refresh);
+		else {
+			logger.error(`[auth] Unknown provider: ${provider}`);
+			return null;
+		}
+		saveCredentials(provider, refreshed);
+		return refreshed.access;
+	} catch (err) {
+		logger.error(`[auth] Failed to refresh ${provider} token: ${err}`);
+		return null;
+	}
+}
+/**
+* Get all configured subscription providers and their status.
+*/
+function getSubscriptionStatus() {
+	return ["anthropic-subscription", "openai-codex"].map((provider) => {
+		const stored = loadCredentials(provider);
+		return {
+			provider,
+			configured: stored !== null,
+			valid: stored ? stored.credentials.expires > Date.now() : false,
+			expiresAt: stored?.credentials.expires ?? null
+		};
+	});
+}
+/**
+* Apply subscription credentials to the environment.
+* Called at startup to make credentials available to ElizaOS plugins.
+*
+* When a `config` is provided and the active subscription provider has
+* credentials, `model.primary` is auto-set so the user doesn't need to
+* configure it manually.
+*/
+async function applySubscriptionCredentials(config) {
+	const anthropicToken = await getAccessToken("anthropic-subscription");
+	if (anthropicToken) {
+		process.env.ANTHROPIC_API_KEY = anthropicToken;
+		logger.info("[auth] Applied Anthropic subscription credentials to environment");
+		try {
+			const { applyClaudeCodeStealth } = await import("./apply-stealth.js");
+			applyClaudeCodeStealth();
+		} catch (err) {
+			logger.warn(`[auth] Failed to apply Claude stealth: ${err instanceof Error ? err.message : err}`);
+		}
+	}
+	const codexToken = await getAccessToken("openai-codex");
+	if (codexToken) {
+		process.env.OPENAI_API_KEY = codexToken;
+		logger.info("[auth] Applied OpenAI Codex subscription credentials to environment");
+		try {
+			const { applyOpenAICodexStealth } = await import("./apply-stealth.js");
+			await applyOpenAICodexStealth();
+		} catch (err) {
+			logger.warn(`[auth] Failed to apply OpenAI Codex stealth: ${err instanceof Error ? err.message : err}`);
+		}
+	}
+	if (config?.agents?.defaults) {
+		const defaults = config.agents.defaults;
+		const provider = defaults.subscriptionProvider;
+		const modelId = provider ? SUBSCRIPTION_PROVIDER_MAP[provider] : void 0;
+		if (modelId) {
+			if (!defaults.model) {
+				defaults.model = { primary: modelId };
+				logger.info(`[auth] Auto-set model.primary to "${modelId}" from subscription provider`);
+			} else if (!defaults.model.primary) {
+				defaults.model.primary = modelId;
+				logger.info(`[auth] Auto-set model.primary to "${modelId}" from subscription provider`);
+			}
+		}
+	}
+}
+
+//#endregion
+export { applySubscriptionCredentials, deleteCredentials, getAccessToken, getSubscriptionStatus, loadCredentials, saveCredentials };

package/dist/auth/index.js

@@ -0,0 +1,5 @@
+import { refreshAnthropicToken, startAnthropicLogin } from "./anthropic.js";
+import { refreshCodexToken, startCodexLogin } from "./openai-codex.js";
+import { applySubscriptionCredentials, deleteCredentials, getAccessToken, getSubscriptionStatus, loadCredentials, saveCredentials } from "./credentials.js";
+
+export { applySubscriptionCredentials, deleteCredentials, getSubscriptionStatus, saveCredentials, startAnthropicLogin, startCodexLogin };

package/dist/auth/openai-codex.js

@@ -0,0 +1,66 @@
+import { loginOpenAICodex, refreshOpenAICodexToken } from "@mariozechner/pi-ai";
+
+//#region src/auth/openai-codex.ts
+/**
+* OpenAI Codex (ChatGPT Plus/Pro subscription) OAuth flow
+*
+* Wraps @mariozechner/pi-ai's loginOpenAICodex for server-side use.
+* Handles local callback server + manual code paste fallback.
+*/
+/**
+* Start the OpenAI Codex OAuth flow.
+* Starts a local callback server on port 1455 and returns the auth URL.
+*/
+function startCodexLogin() {
+	return new Promise((resolveFlow, rejectFlow) => {
+		let authUrl = "";
+		let flowState = "";
+		let resolveManual = null;
+		let closeServer = null;
+		let credentials;
+		const manualPromise = new Promise((resolve) => {
+			resolveManual = resolve;
+		});
+		try {
+			credentials = loginOpenAICodex({
+				onAuth: ({ url }) => {
+					authUrl = url;
+					try {
+						flowState = new URL(url).searchParams.get("state") || "";
+					} catch {}
+					resolveFlow({
+						get authUrl() {
+							return authUrl;
+						},
+						state: flowState,
+						submitCode: (code) => resolveManual?.(code),
+						credentials,
+						close: () => closeServer?.()
+					});
+				},
+				onPrompt: async () => {
+					return manualPromise;
+				},
+				onManualCodeInput: () => manualPromise,
+				onProgress: () => {},
+				originator: "milady"
+			});
+			credentials.catch(() => {});
+		} catch (err) {
+			rejectFlow(err);
+			return;
+		}
+		closeServer = () => {
+			resolveManual?.("");
+		};
+	});
+}
+/**
+* Refresh an expired OpenAI Codex token.
+*/
+async function refreshCodexToken(refreshToken) {
+	return refreshOpenAICodexToken(refreshToken);
+}
+
+//#endregion
+export { refreshCodexToken, startCodexLogin };

package/dist/auth/types.js

@@ -0,0 +1,9 @@
+//#region src/auth/types.ts
+/** Maps subscription provider IDs to their model provider short names. */
+const SUBSCRIPTION_PROVIDER_MAP = {
+	"anthropic-subscription": "anthropic",
+	"openai-codex": "openai"
+};
+
+//#endregion
+export { SUBSCRIPTION_PROVIDER_MAP };

package/dist/auth-routes.js

@@ -0,0 +1,56 @@
+import crypto from "node:crypto";
+
+//#region src/api/auth-routes.ts
+async function handleAuthRoutes(ctx) {
+	const { req, res, method, pathname, readJsonBody, json, error, pairingEnabled, ensurePairingCode, normalizePairingCode, rateLimitPairing, getPairingExpiresAt, clearPairing } = ctx;
+	if (!pathname.startsWith("/api/auth/")) return false;
+	if (method === "GET" && pathname === "/api/auth/status") {
+		const required = Boolean(process.env.MILADY_API_TOKEN?.trim());
+		const enabled = pairingEnabled();
+		if (enabled) ensurePairingCode();
+		json(res, {
+			required,
+			pairingEnabled: enabled,
+			expiresAt: enabled ? getPairingExpiresAt() : null
+		});
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/auth/pair") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const token = process.env.MILADY_API_TOKEN?.trim();
+		if (!token) {
+			error(res, "Pairing not enabled", 400);
+			return true;
+		}
+		if (!pairingEnabled()) {
+			error(res, "Pairing disabled", 403);
+			return true;
+		}
+		if (!rateLimitPairing(req.socket.remoteAddress ?? null)) {
+			error(res, "Too many attempts. Try again later.", 429);
+			return true;
+		}
+		const provided = normalizePairingCode(body.code ?? "");
+		const current = ensurePairingCode();
+		if (!current || Date.now() > getPairingExpiresAt()) {
+			ensurePairingCode();
+			error(res, "Pairing code expired. Check server logs for a new code.", 410);
+			return true;
+		}
+		const expected = normalizePairingCode(current);
+		const a = Buffer.from(expected, "utf8");
+		const b = Buffer.from(provided, "utf8");
+		if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
+			error(res, "Invalid pairing code", 403);
+			return true;
+		}
+		clearPairing();
+		json(res, { token });
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleAuthRoutes };

package/dist/autonomy-routes.js

@@ -0,0 +1,44 @@
+//#region src/api/autonomy-routes.ts
+/** Helper to retrieve the AutonomyService from a runtime (may be null). */
+function getAutonomySvc(runtime) {
+	if (!runtime) return null;
+	return runtime.getService("AUTONOMY");
+}
+function getAutonomyState(runtime) {
+	const svc = getAutonomySvc(runtime);
+	const statusEnabled = svc?.getStatus?.().enabled;
+	const runtimeEnabled = runtime?.enableAutonomy === true;
+	return {
+		enabled: typeof statusEnabled === "boolean" ? statusEnabled : runtimeEnabled || Boolean(svc),
+		thinking: svc?.isLoopRunning() ?? false
+	};
+}
+async function handleAutonomyRoutes(ctx) {
+	const { req, res, method, pathname, runtime, readJsonBody, json } = ctx;
+	if (method === "POST" && pathname === "/api/agent/autonomy") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const svc = getAutonomySvc(runtime);
+		if (typeof body.enabled === "boolean" && svc) if (body.enabled) await svc.enableAutonomy();
+		else await svc.disableAutonomy();
+		const autonomy = getAutonomyState(runtime);
+		json(res, {
+			ok: true,
+			autonomy: autonomy.enabled,
+			thinking: autonomy.thinking
+		});
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/agent/autonomy") {
+		const autonomy = getAutonomyState(runtime);
+		json(res, {
+			enabled: autonomy.enabled,
+			thinking: autonomy.thinking
+		});
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { getAutonomyState, getAutonomySvc, handleAutonomyRoutes };

package/dist/bug-report-routes.js

@@ -0,0 +1,111 @@
+import { sweepExpiredEntries } from "./memory-bounds.js";
+import os from "node:os";
+
+//#region src/api/bug-report-routes.ts
+const BUG_REPORT_REPO = "milady-ai/milady";
+const GITHUB_ISSUES_URL = `https://api.github.com/repos/${BUG_REPORT_REPO}/issues`;
+const GITHUB_NEW_ISSUE_URL = `https://github.com/${BUG_REPORT_REPO}/issues/new?template=bug_report.yml`;
+const BUG_REPORT_WINDOW_MS = 600 * 1e3;
+const BUG_REPORT_MAX_SUBMISSIONS = 5;
+const bugReportAttempts = /* @__PURE__ */ new Map();
+function rateLimitBugReport(ip) {
+	const key = ip ?? "unknown";
+	const now = Date.now();
+	sweepExpiredEntries(bugReportAttempts, now, 100);
+	const current = bugReportAttempts.get(key);
+	if (!current || now > current.resetAt) {
+		bugReportAttempts.set(key, {
+			count: 1,
+			resetAt: now + BUG_REPORT_WINDOW_MS
+		});
+		return true;
+	}
+	if (current.count >= BUG_REPORT_MAX_SUBMISSIONS) return false;
+	current.count += 1;
+	return true;
+}
+/**
+* Strip HTML tags and limit length to prevent markdown injection.
+* GitHub's renderer already sanitizes HTML, but we defensively strip
+* tags and cap field length to reduce abuse surface.
+*/
+function sanitize(input, maxLen = 1e4) {
+	return input.replace(/<[^>]*>/g, "").slice(0, maxLen);
+}
+function formatIssueBody(body) {
+	const sections = [];
+	sections.push(`### Description\n\n${sanitize(body.description)}`);
+	sections.push(`### Steps to Reproduce\n\n${sanitize(body.stepsToReproduce)}`);
+	if (body.expectedBehavior) sections.push(`### Expected Behavior\n\n${sanitize(body.expectedBehavior)}`);
+	if (body.actualBehavior) sections.push(`### Actual Behavior\n\n${sanitize(body.actualBehavior)}`);
+	if (body.environment) sections.push(`### Environment\n\n${sanitize(body.environment, 200)}`);
+	if (body.nodeVersion) sections.push(`### Node Version\n\n${sanitize(body.nodeVersion, 200)}`);
+	if (body.modelProvider) sections.push(`### Model Provider\n\n${sanitize(body.modelProvider, 200)}`);
+	if (body.logs) sections.push(`### Logs\n\n\`\`\`\n${sanitize(body.logs, 5e4)}\n\`\`\``);
+	return sections.join("\n\n");
+}
+async function handleBugReportRoutes(ctx) {
+	const { req, res, method, pathname, json, error, readJsonBody } = ctx;
+	if (method === "GET" && pathname === "/api/bug-report/info") {
+		json(res, {
+			nodeVersion: process.version,
+			platform: os.platform()
+		});
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/bug-report") {
+		if (!rateLimitBugReport(req.socket.remoteAddress ?? null)) {
+			error(res, "Too many bug reports. Try again later.", 429);
+			return true;
+		}
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (!body.description?.trim() || !body.stepsToReproduce?.trim()) {
+			error(res, "description and stepsToReproduce are required", 400);
+			return true;
+		}
+		const githubToken = process.env.GITHUB_TOKEN;
+		if (!githubToken) {
+			json(res, { fallback: GITHUB_NEW_ISSUE_URL });
+			return true;
+		}
+		try {
+			const sanitizedTitle = sanitize(body.description, 80).replace(/[\r\n]+/g, " ");
+			const issueBody = formatIssueBody(body);
+			const issueRes = await fetch(GITHUB_ISSUES_URL, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${githubToken}`,
+					Accept: "application/vnd.github.v3+json",
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({
+					title: `[Bug] ${sanitizedTitle}`,
+					body: issueBody,
+					labels: [
+						"bug",
+						"triage",
+						"user-reported"
+					]
+				})
+			});
+			if (!issueRes.ok) {
+				error(res, `GitHub API error (${issueRes.status})`, 502);
+				return true;
+			}
+			const url = (await issueRes.json()).html_url;
+			if (typeof url !== "string" || !url.startsWith(`https://github.com/${BUG_REPORT_REPO}/issues/`)) {
+				error(res, "Unexpected response from GitHub API", 502);
+				return true;
+			}
+			json(res, { url });
+		} catch (_err) {
+			error(res, "Failed to create GitHub issue", 500);
+		}
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleBugReportRoutes };

package/dist/build-info.json

@@ -0,0 +1,6 @@
+{
+  "version": "2.0.0-alpha.27",
+  "channel": "alpha",
+  "commit": "55ff7b657bc3db661ea23b4e64932f68cf183835",
+  "builtAt": "2026-02-23T03:34:19.379Z"
+}

package/dist/character-routes.js

@@ -0,0 +1,195 @@
+import { CharacterSchema } from "./config/zod-schema.js";
+import { ModelType, logger } from "@elizaos/core";
+
+//#region src/api/character-routes.ts
+function buildCharacterSummary(ctx) {
+	return [
+		ctx.name ? `Name: ${ctx.name}` : "",
+		ctx.system ? `System prompt: ${ctx.system}` : "",
+		ctx.bio ? `Bio: ${ctx.bio}` : "",
+		ctx.style?.all?.length ? `Style rules: ${ctx.style.all.join("; ")}` : ""
+	].filter(Boolean).join("\n");
+}
+function buildGeneratePrompt(field, context, mode) {
+	const charSummary = buildCharacterSummary(context);
+	if (field === "bio") return `Given this character:\n${charSummary}\n\nWrite a concise, compelling bio for this character (3-4 short paragraphs, one per line). Just output the bio lines, nothing else. Match the character's voice and personality.`;
+	if (field === "style") return `Given this character:\n${charSummary}${mode === "append" && context.style?.all?.length ? `\nExisting style rules (add to these, don't repeat):\n${context.style.all.join("\n")}` : ""}\n\nGenerate 4-6 communication style rules for this character. Output a JSON object with keys "all", "chat", "post", each containing an array of short rule strings. Just output the JSON, nothing else.`;
+	if (field === "chatExamples") return `Given this character:\n${charSummary}\n\nGenerate 3 example chat conversations showing how this character responds. Output a JSON array where each element is an array of message objects like [{"user":"{{user1}}","content":{"text":"..."}},{"user":"{{agentName}}","content":{"text":"..."}}]. Just output the JSON array, nothing else.`;
+	return `Given this character:\n${charSummary}${mode === "append" && context.postExamples?.length ? `\nExisting posts (add new ones, don't repeat):\n${context.postExamples.join("\n")}` : ""}\n\nGenerate 3-5 example social media posts this character would write. Output a JSON array of strings. Just output the JSON array, nothing else.`;
+}
+const CHARACTER_SCHEMA_FIELDS = [
+	{
+		key: "name",
+		type: "string",
+		label: "Name",
+		description: "Agent display name",
+		maxLength: 100
+	},
+	{
+		key: "username",
+		type: "string",
+		label: "Username",
+		description: "Agent username for platforms",
+		maxLength: 50
+	},
+	{
+		key: "bio",
+		type: "string | string[]",
+		label: "Bio",
+		description: "Biography — single string or array of points"
+	},
+	{
+		key: "system",
+		type: "string",
+		label: "System Prompt",
+		description: "System prompt defining core behavior",
+		maxLength: 1e4
+	},
+	{
+		key: "adjectives",
+		type: "string[]",
+		label: "Adjectives",
+		description: "Personality adjectives (e.g. curious, witty)"
+	},
+	{
+		key: "topics",
+		type: "string[]",
+		label: "Topics",
+		description: "Topics the agent is knowledgeable about"
+	},
+	{
+		key: "style",
+		type: "object",
+		label: "Style",
+		description: "Communication style guides",
+		children: [
+			{
+				key: "all",
+				type: "string[]",
+				label: "All",
+				description: "Style guidelines for all responses"
+			},
+			{
+				key: "chat",
+				type: "string[]",
+				label: "Chat",
+				description: "Style guidelines for chat responses"
+			},
+			{
+				key: "post",
+				type: "string[]",
+				label: "Post",
+				description: "Style guidelines for social media posts"
+			}
+		]
+	},
+	{
+		key: "messageExamples",
+		type: "array",
+		label: "Message Examples",
+		description: "Example conversations demonstrating the agent's voice"
+	},
+	{
+		key: "postExamples",
+		type: "string[]",
+		label: "Post Examples",
+		description: "Example social media posts"
+	}
+];
+async function handleCharacterRoutes(ctx) {
+	const { req, res, method, pathname, state, readJsonBody, json, error, pickRandomNames } = ctx;
+	if (method === "GET" && pathname === "/api/character") {
+		const runtime = state.runtime;
+		const merged = {};
+		if (runtime) {
+			const character = runtime.character;
+			if (character.name) merged.name = character.name;
+			if (character.bio) merged.bio = character.bio;
+			if (character.system) merged.system = character.system;
+			if (character.adjectives) merged.adjectives = character.adjectives;
+			if (character.topics) merged.topics = character.topics;
+			if (character.style) merged.style = character.style;
+			if (character.postExamples) merged.postExamples = character.postExamples;
+		}
+		json(res, {
+			character: merged,
+			agentName: state.agentName
+		});
+		return true;
+	}
+	if (method === "PUT" && pathname === "/api/character") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const result = CharacterSchema.safeParse(body);
+		if (!result.success) {
+			json(res, {
+				ok: false,
+				validationErrors: result.error.issues.map((issue) => ({
+					path: issue.path.join("."),
+					message: issue.message
+				}))
+			}, 422);
+			return true;
+		}
+		if (state.runtime) {
+			const character = state.runtime.character;
+			if (body.name != null) character.name = String(body.name);
+			if (body.bio != null) character.bio = Array.isArray(body.bio) ? body.bio : [String(body.bio)];
+			if (body.system != null) character.system = String(body.system);
+			if (body.adjectives != null) character.adjectives = body.adjectives;
+			if (body.topics != null) character.topics = body.topics;
+			if (body.style != null) character.style = body.style;
+			if (body.postExamples != null) character.postExamples = body.postExamples;
+		}
+		if (body.name) state.agentName = String(body.name);
+		json(res, {
+			ok: true,
+			character: body,
+			agentName: state.agentName
+		});
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/character/random-name") {
+		json(res, { name: pickRandomNames(1)[0] ?? "Reimu" });
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/character/generate") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (!body.field || !body.context) {
+			error(res, "field and context are required", 400);
+			return true;
+		}
+		const runtime = state.runtime;
+		if (!runtime) {
+			error(res, "Agent runtime not available. Start the agent first.", 503);
+			return true;
+		}
+		if (body.field !== "bio" && body.field !== "style" && body.field !== "chatExamples" && body.field !== "postExamples") {
+			error(res, `Unknown field: ${body.field}`, 400);
+			return true;
+		}
+		const prompt = buildGeneratePrompt(body.field, body.context, body.mode);
+		try {
+			const result = await runtime.useModel(ModelType.TEXT_SMALL, {
+				prompt,
+				temperature: .8,
+				maxTokens: 1500
+			});
+			json(res, { generated: String(result) });
+		} catch (err) {
+			const message = err instanceof Error ? err.message : "generation failed";
+			logger.error(`[character-generate] ${message}`);
+			error(res, message, 500);
+		}
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/character/schema") {
+		json(res, { fields: CHARACTER_SCHEMA_FIELDS });
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleCharacterRoutes };