miladyai 2.0.0-alpha.27

package/dist/api/subscription-routes.js

@@ -0,0 +1,172 @@
+import { logger } from "@elizaos/core";
+
+//#region src/api/subscription-routes.ts
+async function handleSubscriptionRoutes(ctx) {
+	const { req, res, method, pathname, state, readJsonBody, json, error } = ctx;
+	if (!pathname.startsWith("/api/subscription/")) return false;
+	if (method === "GET" && pathname === "/api/subscription/status") {
+		try {
+			const { getSubscriptionStatus } = await import("../auth/index.js");
+			json(res, { providers: getSubscriptionStatus() });
+		} catch (err) {
+			logger.error(`[api] Failed to get subscription status: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to get subscription status", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/anthropic/start") {
+		try {
+			const { startAnthropicLogin } = await import("../auth/index.js");
+			const flow = await startAnthropicLogin();
+			state._anthropicFlow = flow;
+			json(res, { authUrl: flow.authUrl });
+		} catch (err) {
+			logger.error(`[api] Failed to start Anthropic login: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to start Anthropic login", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/anthropic/exchange") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (!body.code) {
+			error(res, "Missing code", 400);
+			return true;
+		}
+		try {
+			const { saveCredentials, applySubscriptionCredentials } = await import("../auth/index.js");
+			const flow = state._anthropicFlow;
+			if (!flow) {
+				error(res, "No active flow — call /start first", 400);
+				return true;
+			}
+			flow.submitCode(body.code);
+			const credentials = await flow.credentials;
+			saveCredentials("anthropic-subscription", credentials);
+			await applySubscriptionCredentials(state.config);
+			delete state._anthropicFlow;
+			json(res, {
+				success: true,
+				expiresAt: credentials.expires
+			});
+		} catch (err) {
+			logger.error(`[api] Anthropic exchange failed: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Anthropic exchange failed", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/anthropic/setup-token") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (!body.token || !body.token.startsWith("sk-ant-")) {
+			error(res, "Invalid token format — expected sk-ant-oat01-...", 400);
+			return true;
+		}
+		try {
+			process.env.ANTHROPIC_API_KEY = body.token.trim();
+			if (!state.config.env) state.config.env = {};
+			state.config.env.ANTHROPIC_API_KEY = body.token.trim();
+			ctx.saveConfig(state.config);
+			json(res, { success: true });
+		} catch (err) {
+			logger.error(`[api] Failed to save setup token: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to save setup token", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/openai/start") {
+		try {
+			const { startCodexLogin } = await import("../auth/index.js");
+			if (state._codexFlow) try {
+				state._codexFlow.close();
+			} catch (err) {
+				logger.debug(`[api] OAuth flow cleanup failed: ${err instanceof Error ? err.message : err}`);
+			}
+			clearTimeout(state._codexFlowTimer);
+			const flow = await startCodexLogin();
+			state._codexFlow = flow;
+			state._codexFlowTimer = setTimeout(() => {
+				try {
+					flow.close();
+				} catch (err) {
+					logger.debug(`[api] OAuth flow cleanup failed: ${err instanceof Error ? err.message : err}`);
+				}
+				delete state._codexFlow;
+				delete state._codexFlowTimer;
+			}, 600 * 1e3);
+			json(res, {
+				authUrl: flow.authUrl,
+				state: flow.state,
+				instructions: "Open the URL in your browser. After login, if auto-redirect doesn't work, paste the full redirect URL."
+			});
+		} catch (err) {
+			logger.error(`[api] Failed to start OpenAI login: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to start OpenAI login", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/openai/exchange") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		try {
+			const { saveCredentials, applySubscriptionCredentials } = await import("../auth/index.js");
+			const flow = state._codexFlow;
+			if (!flow) {
+				error(res, "No active flow — call /start first", 400);
+				return true;
+			}
+			if (body.code) flow.submitCode(body.code);
+			else if (!body.waitForCallback) {
+				error(res, "Provide either code or set waitForCallback: true", 400);
+				return true;
+			}
+			let credentials;
+			try {
+				credentials = await flow.credentials;
+			} catch (err) {
+				try {
+					flow.close();
+				} catch (closeErr) {
+					logger.debug(`[api] OAuth flow cleanup failed: ${closeErr instanceof Error ? closeErr.message : closeErr}`);
+				}
+				delete state._codexFlow;
+				clearTimeout(state._codexFlowTimer);
+				delete state._codexFlowTimer;
+				logger.error(`[api] OpenAI exchange failed: ${err instanceof Error ? err.stack : err}`);
+				error(res, "OpenAI exchange failed", 500);
+				return true;
+			}
+			saveCredentials("openai-codex", credentials);
+			await applySubscriptionCredentials(state.config);
+			flow.close();
+			delete state._codexFlow;
+			clearTimeout(state._codexFlowTimer);
+			delete state._codexFlowTimer;
+			json(res, {
+				success: true,
+				expiresAt: credentials.expires
+			});
+		} catch (err) {
+			logger.error(`[api] OpenAI exchange failed: ${err instanceof Error ? err.stack : err}`);
+			error(res, "OpenAI exchange failed", 500);
+		}
+		return true;
+	}
+	if (method === "DELETE" && pathname.startsWith("/api/subscription/")) {
+		const provider = pathname.split("/").pop();
+		if (provider === "anthropic-subscription" || provider === "openai-codex") try {
+			const { deleteCredentials } = await import("../auth/index.js");
+			deleteCredentials(provider);
+			json(res, { success: true });
+		} catch (err) {
+			logger.error(`[api] Failed to delete credentials: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to delete credentials", 500);
+		}
+		else error(res, `Unknown provider: ${provider}`, 400);
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleSubscriptionRoutes };

package/dist/api/terminal-run-limits.js

@@ -0,0 +1,24 @@
+import { parseClampedInteger } from "../utils/number-parsing.js";
+
+//#region src/api/terminal-run-limits.ts
+const TERMINAL_RUN_MAX_CONCURRENT_DEFAULT = 2;
+const TERMINAL_RUN_MAX_CONCURRENT_CAP = 16;
+const TERMINAL_RUN_MAX_DURATION_MS_DEFAULT = 300 * 1e3;
+const TERMINAL_RUN_MAX_DURATION_MS_CAP = 3600 * 1e3;
+function resolveTerminalRunLimits() {
+	return {
+		maxConcurrent: parseClampedInteger(process.env.MILADY_TERMINAL_MAX_CONCURRENT ?? process.env.MILAIDY_TERMINAL_MAX_CONCURRENT, {
+			fallback: TERMINAL_RUN_MAX_CONCURRENT_DEFAULT,
+			min: 1,
+			max: TERMINAL_RUN_MAX_CONCURRENT_CAP
+		}),
+		maxDurationMs: parseClampedInteger(process.env.MILADY_TERMINAL_MAX_DURATION_MS ?? process.env.MILAIDY_TERMINAL_MAX_DURATION_MS, {
+			fallback: TERMINAL_RUN_MAX_DURATION_MS_DEFAULT,
+			min: 1e3,
+			max: TERMINAL_RUN_MAX_DURATION_MS_CAP
+		})
+	};
+}
+
+//#endregion
+export { resolveTerminalRunLimits };

package/dist/api/training-routes.js

@@ -0,0 +1,158 @@
+import { isLoopbackHost } from "../security/network-policy.js";
+import { parsePositiveInteger } from "../utils/number-parsing.js";
+
+//#region src/api/training-routes.ts
+function resolveOllamaUrlRejection(rawUrl) {
+	const trimmed = rawUrl.trim();
+	if (!trimmed) return null;
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return "ollamaUrl must be a valid URL";
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return "ollamaUrl must use http:// or https://";
+	if (!isLoopbackHost(parsed.hostname)) return "ollamaUrl must target a loopback host (localhost, 127.0.0.1, or ::1)";
+	return null;
+}
+async function handleTrainingRoutes(ctx) {
+	const { req, res, method, pathname, runtime, trainingService, json, error, readJsonBody } = ctx;
+	if (!pathname.startsWith("/api/training")) return false;
+	if (method === "GET" && pathname === "/api/training/status") {
+		json(res, {
+			...trainingService.getStatus(),
+			runtimeAvailable: runtime !== null
+		});
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/training/trajectories") {
+		const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+		const limit = parsePositiveInteger(url.searchParams.get("limit"), 100);
+		const offset = Math.max(0, Number(url.searchParams.get("offset") ?? "0"));
+		json(res, await trainingService.listTrajectories({
+			limit,
+			offset
+		}));
+		return true;
+	}
+	const trajectoryMatch = /^\/api\/training\/trajectories\/([^/]+)$/.exec(pathname);
+	if (method === "GET" && trajectoryMatch) {
+		const trajectoryId = decodeURIComponent(trajectoryMatch[1]);
+		const detail = await trainingService.getTrajectoryById(trajectoryId);
+		if (!detail) {
+			error(res, "Trajectory not found", 404);
+			return true;
+		}
+		json(res, { trajectory: detail });
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/training/datasets") {
+		json(res, { datasets: trainingService.listDatasets() });
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/training/datasets/build") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		json(res, { dataset: await trainingService.buildDataset({
+			limit: body.limit,
+			minLlmCallsPerTrajectory: body.minLlmCallsPerTrajectory
+		}) }, 201);
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/training/jobs") {
+		json(res, { jobs: trainingService.listJobs() });
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/training/jobs") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		try {
+			json(res, { job: await trainingService.startTrainingJob({
+				datasetId: body.datasetId,
+				maxTrajectories: body.maxTrajectories,
+				backend: body.backend,
+				model: body.model,
+				iterations: body.iterations,
+				batchSize: body.batchSize,
+				learningRate: body.learningRate
+			}) }, 201);
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 400);
+		}
+		return true;
+	}
+	const jobMatch = /^\/api\/training\/jobs\/([^/]+)$/.exec(pathname);
+	if (method === "GET" && jobMatch) {
+		const jobId = decodeURIComponent(jobMatch[1]);
+		const job = trainingService.getJob(jobId);
+		if (!job) {
+			error(res, "Training job not found", 404);
+			return true;
+		}
+		json(res, { job });
+		return true;
+	}
+	const cancelMatch = /^\/api\/training\/jobs\/([^/]+)\/cancel$/.exec(pathname);
+	if (method === "POST" && cancelMatch) {
+		const jobId = decodeURIComponent(cancelMatch[1]);
+		try {
+			json(res, { job: await trainingService.cancelJob(jobId) });
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 404);
+		}
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/training/models") {
+		json(res, { models: trainingService.listModels() });
+		return true;
+	}
+	const importMatch = /^\/api\/training\/models\/([^/]+)\/import-ollama$/.exec(pathname);
+	if (method === "POST" && importMatch) {
+		const modelId = decodeURIComponent(importMatch[1]);
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (body.ollamaUrl !== void 0 && typeof body.ollamaUrl !== "string") {
+			error(res, "ollamaUrl must be a string", 400);
+			return true;
+		}
+		if (typeof body.ollamaUrl === "string") {
+			const ollamaUrlRejection = resolveOllamaUrlRejection(body.ollamaUrl);
+			if (ollamaUrlRejection) {
+				error(res, ollamaUrlRejection, 400);
+				return true;
+			}
+		}
+		try {
+			json(res, { model: await trainingService.importModelToOllama(modelId, body) });
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 400);
+		}
+		return true;
+	}
+	const activateMatch = /^\/api\/training\/models\/([^/]+)\/activate$/.exec(pathname);
+	if (method === "POST" && activateMatch) {
+		const modelId = decodeURIComponent(activateMatch[1]);
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		try {
+			json(res, await trainingService.activateModel(modelId, body.providerModel));
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 400);
+		}
+		return true;
+	}
+	const benchmarkMatch = /^\/api\/training\/models\/([^/]+)\/benchmark$/.exec(pathname);
+	if (method === "POST" && benchmarkMatch) {
+		const modelId = decodeURIComponent(benchmarkMatch[1]);
+		try {
+			json(res, await trainingService.benchmarkModel(modelId));
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 400);
+		}
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleTrainingRoutes };

package/dist/api/trajectory-routes.js

@@ -0,0 +1,300 @@
+import { readJsonBody, sendJson, sendJsonError } from "./http-helpers.js";
+import { createZipArchive } from "./zip-utils.js";
+
+//#region src/api/trajectory-routes.ts
+function isRouteCompatibleTrajectoryLogger(candidate) {
+	if (!candidate || typeof candidate !== "object") return false;
+	const logger = candidate;
+	return typeof logger.isEnabled === "function" && typeof logger.setEnabled === "function" && typeof logger.listTrajectories === "function" && typeof logger.getTrajectoryDetail === "function" && typeof logger.getStats === "function" && typeof logger.deleteTrajectories === "function" && typeof logger.clearAllTrajectories === "function" && typeof logger.exportTrajectories === "function";
+}
+function getTrajectoryLogger(runtime) {
+	const runtimeLike = runtime;
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	const addCandidate = (candidate) => {
+		if (!candidate || seen.has(candidate)) return;
+		seen.add(candidate);
+		candidates.push(candidate);
+	};
+	if (typeof runtimeLike.getServicesByType === "function") {
+		const byType = runtimeLike.getServicesByType("trajectory_logger");
+		if (Array.isArray(byType)) for (const candidate of byType) addCandidate(candidate);
+		else addCandidate(byType);
+	}
+	if (typeof runtimeLike.getService === "function") addCandidate(runtimeLike.getService("trajectory_logger"));
+	for (const candidate of candidates) if (isRouteCompatibleTrajectoryLogger(candidate)) return candidate;
+	return null;
+}
+function toNullableString(value) {
+	return typeof value === "string" ? value : null;
+}
+function listItemToUIRecord(item) {
+	const status = item.status === "timeout" || item.status === "error" ? "error" : item.status;
+	return {
+		id: item.id,
+		agentId: item.agentId,
+		roomId: null,
+		entityId: null,
+		conversationId: null,
+		source: item.source,
+		status,
+		startTime: item.startTime,
+		endTime: item.endTime,
+		durationMs: item.durationMs,
+		llmCallCount: item.llmCallCount,
+		providerAccessCount: 0,
+		totalPromptTokens: item.totalPromptTokens,
+		totalCompletionTokens: item.totalCompletionTokens,
+		metadata: {},
+		createdAt: item.createdAt,
+		updatedAt: item.createdAt
+	};
+}
+function trajectoryToUIDetail(traj) {
+	const finalStatus = traj.metrics?.finalStatus ?? "completed";
+	const normalizedEndTime = typeof traj.endTime === "number" && traj.endTime > 0 ? traj.endTime : null;
+	const status = finalStatus === "timeout" || finalStatus === "terminated" || finalStatus === "error" ? "error" : finalStatus === "completed" ? "completed" : normalizedEndTime ? "completed" : "active";
+	const llmCalls = [];
+	const providerAccesses = [];
+	let totalPromptTokens = 0;
+	let totalCompletionTokens = 0;
+	const steps = traj.steps || [];
+	const trajectoryId = String(traj.trajectoryId);
+	for (let i = 0; i < steps.length; i++) {
+		const step = steps[i];
+		const stepId = typeof step.stepId === "string" ? step.stepId : `step-${i}`;
+		const calls = step.llmCalls || [];
+		for (let j = 0; j < calls.length; j++) {
+			const call = calls[j];
+			llmCalls.push({
+				id: call.callId || `${stepId}-call-${j}`,
+				trajectoryId,
+				stepId,
+				model: call.model || "unknown",
+				systemPrompt: call.systemPrompt || "",
+				userPrompt: call.userPrompt || "",
+				response: call.response || "",
+				temperature: typeof call.temperature === "number" ? call.temperature : 0,
+				maxTokens: typeof call.maxTokens === "number" ? call.maxTokens : 0,
+				purpose: call.purpose || "",
+				actionType: call.actionType || "",
+				latencyMs: call.latencyMs || 0,
+				promptTokens: call.promptTokens,
+				completionTokens: call.completionTokens,
+				timestamp: call.timestamp || step.timestamp,
+				createdAt: new Date(call.timestamp || step.timestamp).toISOString()
+			});
+			totalPromptTokens += call.promptTokens || 0;
+			totalCompletionTokens += call.completionTokens || 0;
+		}
+		const accesses = step.providerAccesses || [];
+		for (let k = 0; k < accesses.length; k++) {
+			const access = accesses[k];
+			providerAccesses.push({
+				id: access.providerId || `${stepId}-provider-${k}`,
+				trajectoryId,
+				stepId,
+				providerName: access.providerName || "unknown",
+				purpose: access.purpose || "",
+				data: access.data || {},
+				query: access.query,
+				timestamp: access.timestamp || step.timestamp,
+				createdAt: new Date(access.timestamp || step.timestamp).toISOString()
+			});
+		}
+	}
+	const metadata = traj.metadata ?? {};
+	const normalizedDurationMs = status === "active" ? null : typeof traj.durationMs === "number" ? traj.durationMs : null;
+	const updatedAtMs = normalizedEndTime ?? (traj.startTime || Date.now());
+	return {
+		trajectory: {
+			id: trajectoryId,
+			agentId: String(traj.agentId),
+			roomId: toNullableString(metadata.roomId),
+			entityId: toNullableString(metadata.entityId),
+			conversationId: toNullableString(metadata.conversationId),
+			source: toNullableString(metadata.source) ?? "chat",
+			status,
+			startTime: traj.startTime,
+			endTime: normalizedEndTime,
+			durationMs: normalizedDurationMs,
+			llmCallCount: llmCalls.length,
+			providerAccessCount: providerAccesses.length,
+			totalPromptTokens,
+			totalCompletionTokens,
+			metadata,
+			createdAt: new Date(traj.startTime).toISOString(),
+			updatedAt: new Date(updatedAtMs).toISOString()
+		},
+		llmCalls,
+		providerAccesses
+	};
+}
+async function handleGetTrajectories(req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+	const options = {
+		limit: Math.min(500, Math.max(1, Number(url.searchParams.get("limit")) || 50)),
+		offset: Math.max(0, Number(url.searchParams.get("offset")) || 0),
+		source: url.searchParams.get("source") || void 0,
+		status: url.searchParams.get("status") || void 0,
+		startDate: url.searchParams.get("startDate") || void 0,
+		endDate: url.searchParams.get("endDate") || void 0,
+		search: url.searchParams.get("search") || void 0,
+		scenarioId: url.searchParams.get("scenarioId") || void 0,
+		batchId: url.searchParams.get("batchId") || void 0,
+		isTrainingData: url.searchParams.has("isTrainingData") ? url.searchParams.get("isTrainingData") === "true" : void 0
+	};
+	const result = await logger.listTrajectories(options);
+	sendJson(res, {
+		trajectories: result.trajectories.map(listItemToUIRecord),
+		total: result.total,
+		offset: result.offset,
+		limit: result.limit
+	});
+}
+async function handleGetTrajectoryDetail(_req, res, runtime, trajectoryId) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const trajectory = await logger.getTrajectoryDetail(trajectoryId);
+	if (!trajectory) {
+		sendJsonError(res, `Trajectory "${trajectoryId}" not found`, 404);
+		return;
+	}
+	sendJson(res, trajectoryToUIDetail(trajectory));
+}
+async function handleGetStats(_req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	sendJson(res, await logger.getStats());
+}
+async function handleGetConfig(_req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	sendJson(res, { enabled: logger.isEnabled() });
+}
+async function handlePutConfig(req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const body = await readJsonBody(req, res);
+	if (!body) return;
+	if (typeof body.enabled === "boolean") logger.setEnabled(body.enabled);
+	sendJson(res, { enabled: logger.isEnabled() });
+}
+async function handleExportTrajectories(req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const body = await readJsonBody(req, res);
+	if (!body) return;
+	if (body.format === "zip") {
+		if (typeof logger.exportTrajectoriesZip !== "function") {
+			sendJsonError(res, "Trajectory ZIP export is unavailable in the active logger", 503);
+			return;
+		}
+		const zipOptions = {
+			includePrompts: body.includePrompts,
+			trajectoryIds: body.trajectoryIds,
+			startDate: body.startDate,
+			endDate: body.endDate,
+			scenarioId: body.scenarioId,
+			batchId: body.batchId
+		};
+		const zipResult = await logger.exportTrajectoriesZip(zipOptions);
+		const archive = createZipArchive(zipResult.entries);
+		res.statusCode = 200;
+		res.setHeader("Content-Type", "application/zip");
+		res.setHeader("Content-Disposition", `attachment; filename="${zipResult.filename}"`);
+		res.end(archive);
+		return;
+	}
+	if (body.format !== "json" && body.format !== "csv" && body.format !== "art") {
+		sendJsonError(res, "Format must be 'json', 'csv', 'art', or 'zip'", 400);
+		return;
+	}
+	const result = await logger.exportTrajectories({
+		format: body.format,
+		includePrompts: body.includePrompts,
+		trajectoryIds: body.trajectoryIds,
+		startDate: body.startDate,
+		endDate: body.endDate,
+		scenarioId: body.scenarioId,
+		batchId: body.batchId
+	});
+	res.statusCode = 200;
+	res.setHeader("Content-Type", result.mimeType);
+	res.setHeader("Content-Disposition", `attachment; filename="${result.filename}"`);
+	res.end(result.data);
+}
+async function handleDeleteTrajectories(req, res, runtime) {
+	const logger = getTrajectoryLogger(runtime);
+	if (!logger) {
+		sendJsonError(res, "Trajectory logger service not available", 503);
+		return;
+	}
+	const body = await readJsonBody(req, res);
+	if (!body) return;
+	if (body.all) {
+		sendJson(res, { deleted: await logger.clearAllTrajectories() });
+		return;
+	}
+	if (Array.isArray(body.trajectoryIds) && body.trajectoryIds.length > 0) {
+		sendJson(res, { deleted: await logger.deleteTrajectories(body.trajectoryIds) });
+		return;
+	}
+	sendJson(res, { deleted: 0 });
+}
+async function handleTrajectoryRoute(req, res, runtime, pathname, method) {
+	if (!pathname.startsWith("/api/trajectories")) return false;
+	if (pathname === "/api/trajectories/config" && method === "GET") {
+		await handleGetConfig(req, res, runtime);
+		return true;
+	}
+	if (pathname === "/api/trajectories/config" && method === "PUT") {
+		await handlePutConfig(req, res, runtime);
+		return true;
+	}
+	if (pathname === "/api/trajectories/export" && method === "POST") {
+		await handleExportTrajectories(req, res, runtime);
+		return true;
+	}
+	if (pathname === "/api/trajectories" && method === "DELETE") {
+		await handleDeleteTrajectories(req, res, runtime);
+		return true;
+	}
+	if (pathname === "/api/trajectories/stats" && method === "GET") {
+		await handleGetStats(req, res, runtime);
+		return true;
+	}
+	const detailMatch = pathname.match(/^\/api\/trajectories\/([^/]+)$/);
+	if (detailMatch && method === "GET") {
+		await handleGetTrajectoryDetail(req, res, runtime, detailMatch[1]);
+		return true;
+	}
+	if (pathname === "/api/trajectories" && method === "GET") {
+		await handleGetTrajectories(req, res, runtime);
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleTrajectoryRoute };