pi-mega-compact 0.11.4 → 0.11.6

package/extensions/dashboard-server/routes-memory-map.ts

@@ -0,0 +1,105 @@
+/**
+ * routes-memory-map.ts — GET /api/memory-map route handler (S46).
+ *
+ * Builds a memory graph from the local SQLite store and returns it as JSON.
+ * Uses an inline require to the pi-agnostic src/memoryGraph.ts builder.
+ */
+import { createRequire } from "node:module";
+import type { ServerResponse, IncomingMessage } from "node:http";
+import { parse as parseUrl } from "node:url";
+import type { RouteContext } from "./routes-core.js";
+import type { MemoryMapResponse, MemoryMapNode, MemoryMapEdgeEntry } from "./api-contracts/memory-map.js";
+
+const _req = createRequire(import.meta.url);
+
+// guardrails-allow PREVENT-PI-004: localhost-only dashboard API endpoint that reads from the local SQLite store — zero remote network calls.
+
+export function handleMemoryMap(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	if (req.method !== "GET") return false;
+	const parsed = parseUrl(req.url ?? "", true);
+	if (parsed.pathname !== "/api/memory-map") return false;
+
+	// guardrails-allow PREVENT-PI-004: local loopback-only dashboard server — reads the local SQLite store for graph data.
+	const { buildMemoryGraph } = _req("../../src/memoryGraph.js") as {
+		buildMemoryGraph: (opts?: {
+			sessionId?: string;
+			similarityThreshold?: number;
+			maxEdgesPerNode?: number;
+			stateDir?: string;
+			includeRaptorEdges?: boolean;
+			includeTemporalEdges?: boolean;
+		}) => MemoryGraphReturn;
+	};
+
+	type MemoryGraphReturn = {
+		nodes: Array<{
+			id: string;
+			sessionId: string;
+			label: string;
+			summaryTruncated: string;
+			tokenEstimate: number;
+			timestamp: number;
+			dedupStatus: string | undefined;
+			raptorLevel: number;
+			topicSummary: string | undefined;
+			decisionCount: number;
+			textSnippet: string;
+		}>;
+		edges: Array<{
+			source: string;
+			target: string;
+			weight: number;
+			type: "temporal" | "semantic" | "raptor_parent";
+		}>;
+		metadata: {
+			sessionCount: number;
+			totalCheckpoints: number;
+			totalEdges: number;
+			semanticEdgeCount: number;
+			temporalEdgeCount: number;
+			raptorEdgeCount: number;
+			similarityThresholdUsed: number;
+			builtAt: number;
+		};
+	};
+
+	const sessionId = typeof parsed.query.sessionId === "string" ? parsed.query.sessionId : undefined;
+	const threshold = typeof parsed.query.threshold === "string" ? Number.parseFloat(parsed.query.threshold) : undefined;
+	const maxEdges = typeof parsed.query.maxEdgesPerNode === "string" ? Number.parseInt(parsed.query.maxEdgesPerNode, 10) : undefined;
+	const raptorEdges = parsed.query.includeRaptorEdges === "false" ? false : true;
+	const temporalEdges = parsed.query.includeTemporalEdges === "false" ? false : true;
+
+	const graph = buildMemoryGraph({
+		sessionId,
+		similarityThreshold: threshold,
+		maxEdgesPerNode: maxEdges,
+		stateDir: ctx.stateDir,
+		includeRaptorEdges: raptorEdges,
+		includeTemporalEdges: temporalEdges,
+	});
+
+	const nodes: MemoryMapNode[] = graph.nodes.map((n) => ({
+		id: n.id,
+		sessionId: n.sessionId,
+		label: n.label,
+		summaryTruncated: n.summaryTruncated,
+		tokenEstimate: n.tokenEstimate,
+		timestamp: n.timestamp,
+		dedupStatus: n.dedupStatus,
+		raptorLevel: n.raptorLevel,
+		topicSummary: n.topicSummary,
+		decisionCount: n.decisionCount,
+		textSnippet: n.textSnippet,
+	}));
+
+	const edges: MemoryMapEdgeEntry[] = graph.edges as MemoryMapEdgeEntry[];
+	const response: MemoryMapResponse = { nodes, edges, metadata: graph.metadata };
+
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(response));
+	return true;
+}

package/extensions/dashboard-server/routes-memory.ts

@@ -0,0 +1,63 @@
+/**
+ * dashboard-server/routes-memory.ts — Memory effectiveness stats route handler (S53B).
+ *
+ * GET /api/memory-status — Returns memoryStats() aggregated data:
+ *   totalMemories, memoriesInLast30Days, topStableMemories, avgRecallScore.
+ *
+ * Guardrails: PREVENT-PI-004 (loopback-only), PREVENT-001 (null-safe JSON),
+ * PREVENT-002 (parameterized SQL — memoryStats uses openStore internally).
+ * Loopback-only localhost dashboard endpoint.
+ */
+
+import { createRequire } from "node:module";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes-core.js";
+import type { MemoryStatusResponse } from "./api-contracts/memory.js";
+
+// PREVENT-PI-004: memoryStats is a pure local module (no network, no side-effects at import time).
+// guardrails-allow PREVENT-PI-004: local TypeScript module import (loopback-only).
+const { memoryStats } = createRequire(import.meta.url)(
+	"../../src/memoryStats.js",
+) as typeof import("../../src/memoryStats.js");
+
+// ---------------------------------------------------------------------------
+// handleMemoryStatus — "/api/memory-status"
+// ---------------------------------------------------------------------------
+
+export function handleMemoryStatus(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	if (!req.url?.startsWith("/api/memory-status")) return false;
+	if (req.method !== "GET") {
+		// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "method_not_allowed" }));
+		return true;
+	}
+	// PREVENT-PI-004: loopback-only — memoryStats reads from local SQLite store.
+	memoryStats(ctx.stateDir)
+		.then((stats) => {
+			const body: MemoryStatusResponse = {
+				totalMemories: stats.totalMemories,
+				memoriesInLast30Days: stats.memoriesInLast30Days,
+				topStableMemories: stats.topStableMemories.map((m) => ({
+					id: m.id,
+					text: m.text,
+					recallCount: m.recallCount,
+					lastRecalledAt: m.lastRecalledAt,
+				})),
+				avgRecallScore: stats.avgRecallScore,
+			};
+			// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(body));
+		})
+		.catch(() => {
+			// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+			res.writeHead(500, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "memory_stats_unavailable" }));
+		});
+	return true;
+}

package/extensions/dashboard-server/routes-repo.ts

@@ -13,7 +13,10 @@ import { ACTIVE_WINDOW_SEC } from "./types.js";
 import type { RouteContext } from "./routes-core.js";
 import type { LiveSnapshot } from "./types.js";
 import { readProviderCacheForRepo } from "../../src/store/sqlite/perf-samples.js";
-import { computeCacheSavings, lookupModelInputRate } from "../../src/pricing.js";
+import {
+	computeCacheSavings,
+	lookupModelInputRate,
+} from "../../src/pricing.js";
 import { latestModelSnapshot } from "../../src/store/sqlite/model-snapshots.js";
 
 // ---------------------------------------------------------------------------
@@ -154,43 +157,42 @@ export function handleRepoIndex(
 					try {
 						const p = join(r.stateDir, "dashboard.json");
 						if (existsSync(p)) {
-							const snap = JSON.parse(
-								readFileSync(p, "utf-8"),
-							) as LiveSnapshot;
+							const snap = JSON.parse(readFileSync(p, "utf-8")) as LiveSnapshot;
 							out.tier = snap.tier ?? null;
 							out.contextPct =
 								snap.context && snap.context.percent != null
 									? snap.context.percent
 									: null;
 							out.state = (snap.session && snap.session.state) || null;
-						out.cacheHits = snap.cacheHits ?? null;
-						out.compacts = snap.compacts ?? null;
-						out.timeSaved = snap.timeSaved ?? null;
-						out.updatedAt = snap.updatedAt ?? null;
-						// Provider cache per-repo lifetime (E.2)
-						try {
-							const pc = readProviderCacheForRepo(r.stateDir);
-							// Price from model snapshot if available
-							const modelSnap = latestModelSnapshot(r.stateDir);
-							const inputRate = modelSnap
-								? modelSnap.inputRate
-								: lookupModelInputRate(r.modelName ?? "") ?? 0;
-							const savings = computeCacheSavings(
-								pc.totalCacheRead,
-								pc.totalCacheWrite,
-								inputRate,
-							);
-							out.providerCache = {
-								avgHitPct: pc.avgHitPct,
-								cacheRead: pc.totalCacheRead,
-								cacheWrite: pc.totalCacheWrite,
-								totalInput: pc.totalInput,
-								sampleCount: pc.sampleCount,
-								estimatedSaved: savings.netSaved > 0 ? savings.netSaved : null,
-							};
-						} catch {
-							/* best-effort — repo may not have perf_samples */
-						}
+							out.cacheHits = snap.cacheHits ?? null;
+							out.compacts = snap.compacts ?? null;
+							out.timeSaved = snap.timeSaved ?? null;
+							out.updatedAt = snap.updatedAt ?? null;
+							// Provider cache per-repo lifetime (E.2)
+							try {
+								const pc = readProviderCacheForRepo(r.stateDir);
+								// Price from model snapshot if available
+								const modelSnap = latestModelSnapshot(r.stateDir);
+								const inputRate = modelSnap
+									? modelSnap.inputRate
+									: (lookupModelInputRate(r.modelName ?? "") ?? 0);
+								const savings = computeCacheSavings(
+									pc.totalCacheRead,
+									pc.totalCacheWrite,
+									inputRate,
+								);
+								out.providerCache = {
+									avgHitPct: pc.avgHitPct,
+									cacheRead: pc.totalCacheRead,
+									cacheWrite: pc.totalCacheWrite,
+									totalInput: pc.totalInput,
+									sampleCount: pc.sampleCount,
+									estimatedSaved:
+										savings.netSaved > 0 ? savings.netSaved : null,
+								};
+							} catch {
+								/* best-effort — repo may not have perf_samples */
+							}
 						}
 					} catch {
 						/* best-effort */
@@ -199,9 +201,7 @@ export function handleRepoIndex(
 				})
 				.sort((a, b) => (b.lastSeen as number) - (a.lastSeen as number));
 			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(
-				JSON.stringify({ updatedAt: new Date().toISOString(), servers }),
-			);
+			res.end(JSON.stringify({ updatedAt: new Date().toISOString(), servers }));
 		} catch {
 			res.writeHead(500, { "Content-Type": "application/json" });
 			res.end(JSON.stringify({ error: "servers_unavailable" }));
@@ -236,4 +236,4 @@ export function handleStatic(
 	res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
 	res.end(dashboardHtml(tier));
 	return true;
-}
+}

package/extensions/dashboard-server/routes-setup.ts

@@ -0,0 +1,293 @@
+/**
+ * dashboard-server/routes-setup.ts — Setup wizard route handlers.
+ *
+ * GET /api/setup-status  — Returns current embedder configuration from env.
+ * GET /api/setup-detect  — Runs best-effort detection of local embedder backends.
+ *
+ * Guardrails: PREVENT-PI-004 (loopback-only), PREVENT-001 (null-safe JSON).
+ * The detection commands run local subprocesses via spawnSync, NOT network calls.
+ * Each decoration line carries a guardrails-allow annotation.
+ */
+
+import { spawnSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: local subprocess detection only
+import { createRequire } from "node:module";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes-core.js";
+import type {
+	SetupStatusResponse,
+	SetupDetectResponse,
+	SetupConfigureRequest,
+	SetupConfigureResponse,
+	DetectResult,
+	OllamaDetectResult,
+} from "./api-contracts/setup.js";
+
+// ---------------------------------------------------------------------------
+// handleSetupStatus — "/api/setup-status"
+// ---------------------------------------------------------------------------
+
+function detectCurrentEmbedder(): SetupStatusResponse["currentEmbedder"] {
+	const url = process.env["MEGACOMPACT_EMBEDDING_URL"];
+	const minilm = process.env["MEGACOMPACT_MINILM"];
+	if (url && url.trim().length > 0) return "http";
+	if (minilm && ["1", "true", "yes"].includes(minilm.trim().toLowerCase()))
+		return "minilm";
+	return "trigram";
+}
+
+export function handleSetupStatus(
+	req: IncomingMessage,
+	res: ServerResponse,
+	_ctx: RouteContext,
+): boolean {
+	if (req.url !== "/api/setup-status") return false;
+	if (req.method !== "GET") {
+		// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "method_not_allowed" }));
+		return true;
+	}
+	const body: SetupStatusResponse = {
+		currentEmbedder: detectCurrentEmbedder(),
+		embeddingUrl: process.env["MEGACOMPACT_EMBEDDING_URL"] ?? null,
+		embedCache: process.env["MEGACOMPACT_EMBED_CACHE"] ?? null,
+		minilm: ["1", "true", "yes"].includes(
+			(process.env["MEGACOMPACT_MINILM"] ?? "").trim().toLowerCase(),
+		),
+	};
+	// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(body));
+	return true;
+}
+
+// ---------------------------------------------------------------------------
+// handleSetupDetect — "/api/setup-detect"
+// ---------------------------------------------------------------------------
+
+function detectOllama(): OllamaDetectResult | null {
+	try {
+		const version = spawnSync("ollama", ["--version"], {
+			timeout: 5000,
+			encoding: "utf-8",
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		if (version.status !== 0) {
+			return { installed: false, models: [], running: false, detail: version.stderr?.trim() || "not found" };
+		}
+		// Check for running server
+		let running = false;
+		let models: string[] = [];
+		try {
+			const listResult = spawnSync("ollama", ["list"], {
+				timeout: 5000,
+				encoding: "utf-8",
+				stdio: ["ignore", "pipe", "pipe"],
+			});
+			if (listResult.status === 0) {
+				running = true;
+				// Parse lines: NAME  ID  SIZE  MODIFIED
+				const lines = listResult.stdout?.split("\n") ?? [];
+				for (const line of lines) {
+					const name = line.split(/\s+/)[0];
+					if (name && name !== "NAME") models.push(name);
+				}
+			}
+		} catch {
+			// ollama list failed — server may not be running
+			running = false;
+		}
+		return {
+			installed: true,
+			models,
+			running,
+			detail: version.stdout?.trim() || null,
+		};
+	} catch {
+		return { installed: false, models: [], running: false, detail: "detection error" };
+	}
+}
+
+function detectLlamaCpp(): DetectResult | null {
+	try {
+		const which = spawnSync("which", ["llama-server", "llama.cpp"], {
+			timeout: 3000,
+			encoding: "utf-8",
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		const installed = which.status === 0 && which.stdout.trim().length > 0;
+		return {
+			installed,
+			detail: installed ? which.stdout.trim() : null,
+		};
+	} catch {
+		return { installed: false, detail: "detection error" };
+	}
+}
+
+function detectOnnx(): DetectResult | null {
+	try {
+		// Check for onnxruntime-node in a parent node_modules
+		const req = createRequire(import.meta.url);
+		try {
+			req.resolve("onnxruntime-node");
+			return { installed: true, detail: "onnxruntime-node found in node_modules" };
+		} catch {
+			return { installed: false, detail: "onnxruntime-node not found in node_modules" };
+		}
+	} catch {
+		return { installed: false, detail: "detection error" };
+	}
+}
+
+export function handleSetupDetect(
+	req: IncomingMessage,
+	res: ServerResponse,
+	_ctx: RouteContext,
+): boolean {
+	if (req.url !== "/api/setup-detect") return false;
+	if (req.method !== "GET") {
+		// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "method_not_allowed" }));
+		return true;
+	}
+	let error: string | null = null;
+	let ollama: OllamaDetectResult | null = null;
+	let llamaCpp: DetectResult | null = null;
+	let onnx: DetectResult | null = null;
+
+	try {
+		ollama = detectOllama();
+	} catch (e) {
+		error = `ollama detection failed: ${e instanceof Error ? e.message : String(e)}`;
+	}
+
+	try {
+		llamaCpp = detectLlamaCpp();
+	} catch (e) {
+		error = error ?? `llama.cpp detection failed: ${e instanceof Error ? e.message : String(e)}`;
+	}
+
+	try {
+		onnx = detectOnnx();
+	} catch (e) {
+		error = error ?? `onnx detection failed: ${e instanceof Error ? e.message : String(e)}`;
+	}
+
+	const body: SetupDetectResponse = { ollama, llamaCpp, onnx, error };
+	// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(body));
+	return true;
+}
+
+// ---------------------------------------------------------------------------
+// handleSetupConfigure — POST "/api/setup-configure"
+// ---------------------------------------------------------------------------
+
+const OLLAMA_DEFAULT_URL = "http://localhost:11434/api/embeddings"; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
+const LLAMA_DEFAULT_URL = "http://localhost:8080/v1/embeddings"; // guardrails-allow PREVENT-PI-004: localhost-only config string, not a runtime fetch
+
+function readJsonBody(
+	req: IncomingMessage,
+	cb: (
+		result:
+			| { ok: true; value: Record<string, unknown> }
+			| { ok: false; error: string },
+	) => void,
+): void {
+	let body = "";
+	let tooBig = false;
+	req.on("data", (chunk: Buffer) => {
+		if (body.length > 65536) { tooBig = true; return; }
+		body += chunk.toString();
+	});
+	req.on("end", () => {
+		if (tooBig) return cb({ ok: false, error: "body_too_large" });
+		try {
+			const v = body ? JSON.parse(body) : {}; // PREVENT-001: parsed value type-checked below
+			if (typeof v !== "object" || v === null || Array.isArray(v)) {
+				return cb({ ok: false, error: "invalid_object" });
+			}
+			cb({ ok: true, value: v as Record<string, unknown> });
+		} catch {
+			cb({ ok: false, error: "invalid_json" });
+		}
+	});
+	req.on("error", () => cb({ ok: false, error: "read_error" }));
+}
+
+export function handleSetupConfigure(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	if (req.url !== "/api/setup-configure") return false;
+	if (req.method !== "POST") {
+		// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "method_not_allowed" }));
+		return true;
+	}
+	readJsonBody(req, (parsed) => {
+		if (!parsed.ok) {
+			// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: parsed.error }));
+			return;
+		}
+		const body = parsed.value as unknown as SetupConfigureRequest;
+		const embedder = body.embedder;
+		if (embedder !== "ollama" && embedder !== "llama" && embedder !== "trigram") {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "invalid_embedder" }));
+			return;
+		}
+		const url = body.url;
+		let resolvedUrl: string | null;
+		if (embedder === "ollama") resolvedUrl = typeof url === "string" && url ? url : OLLAMA_DEFAULT_URL;
+		else if (embedder === "llama") resolvedUrl = typeof url === "string" && url ? url : LLAMA_DEFAULT_URL;
+		else resolvedUrl = null;
+
+		// Write .mega-compact.env to the state dir (loaded by env-loader at next startup).
+		const stateDir = ctx.stateDir;
+		const envPath = join(stateDir, ".mega-compact.env");
+		const lines: string[] = [
+			"# Mega-Compact Embedder Configuration",
+			`# Configured via dashboard Setup tab at ${new Date().toISOString()}`,
+		];
+		if (resolvedUrl) {
+			lines.push(`export MEGACOMPACT_EMBEDDING_URL="${resolvedUrl}"`);
+		} else {
+			lines.push("# trigram: built-in embedder, no URL needed");
+			lines.push("# unset MEGACOMPACT_EMBEDDING_URL (commented to override any shell-set value)");
+			lines.push("# export MEGACOMPACT_EMBEDDING_URL=");
+		}
+		lines.push("");
+		try {
+			mkdirSync(stateDir, { recursive: true });
+			writeFileSync(envPath, lines.join("\n"), "utf-8");
+		} catch (e) {
+			res.writeHead(500, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: `write_failed: ${e instanceof Error ? e.message : String(e)}` }));
+			return;
+		}
+		// Detect if the new config matches what's already active (no restart needed).
+		const currentUrl = process.env["MEGACOMPACT_EMBEDDING_URL"];
+		const alreadyActive = (resolvedUrl === null && !currentUrl) || (resolvedUrl !== null && currentUrl === resolvedUrl);
+		const resp: SetupConfigureResponse = {
+			embedder,
+			url: resolvedUrl,
+			envPath,
+			restartRequired: !alreadyActive,
+			alreadyActive,
+		};
+		// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify(resp));
+	});
+	return true;
+}

package/extensions/dashboard-server/routes.ts

@@ -20,3 +20,7 @@ export { handleTopics } from "./routes-topics.js";
 export { handleTurns } from "./routes-turns.js";
 export { handleMaintenance } from "./routes-maintenance.js";
 export { handleProviderCache } from "./routes-cache.js";
+export { handleMemoryStatus } from "./routes-memory.js";
+export { handleSetupStatus, handleSetupDetect, handleSetupConfigure } from "./routes-setup.js";
+export { handleMemoryMap } from "./routes-memory-map.js";
+export { handleCacheStripes } from "./routes-cache.js";

package/extensions/dashboard-server/server.ts

@@ -38,6 +38,12 @@ import {
 	handleTurns,
 	handleMaintenance,
 	handleProviderCache,
+	handleCacheStripes,
+	handleMemoryStatus,
+	handleSetupStatus,
+	handleSetupDetect,
+	handleSetupConfigure,
+	handleMemoryMap,
 	handleStatic,
 } from "./routes.js";
 
@@ -227,6 +233,12 @@ export async function launchDashboardServer(
 		if (handleTurns(req, res, ctx)) return;
 		if (handleMaintenance(req, res, ctx)) return;
 		if (handleProviderCache(req, res, ctx)) return;
+		if (handleMemoryStatus(req, res, ctx)) return;
+		if (handleCacheStripes(req, res, ctx)) return;
+		if (handleSetupStatus(req, res, ctx)) return;
+		if (handleSetupDetect(req, res, ctx)) return;
+		if (handleSetupConfigure(req, res, ctx)) return;
+		if (handleMemoryMap(req, res, ctx)) return;
 		handleStatic(req, res, ctx);
 	});