@sourcepress/server 0.1.0

package/src/__tests__/knowledge.test.ts

@@ -0,0 +1,121 @@
+import type { KnowledgeFile } from "@sourcepress/core";
+import { Hono } from "hono";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { EngineContext } from "../engine.js";
+import { errorHandler } from "../middleware/error-handler.js";
+import { knowledgeRoutes } from "../routes/knowledge.js";
+
+const mockKnowledgeFiles: KnowledgeFile[] = [
+	{
+		path: "knowledge/clients/acme.md",
+		type: "project-notes",
+		quality: "structured",
+		quality_score: 8,
+		entities: [{ type: "client", name: "Acme Corp" }],
+		ingested_at: "2026-04-01T00:00:00Z",
+		source: "manual",
+		body: "Meeting notes with Acme Corp...",
+	},
+];
+
+function createMockEngine(): EngineContext {
+	return {
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		config: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		github: {} as any,
+		knowledge: {
+			ingest: vi.fn().mockResolvedValue(mockKnowledgeFiles[0]),
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		} as any,
+		knowledgeStore: {
+			list: vi.fn().mockResolvedValue(mockKnowledgeFiles),
+			retrieve: vi.fn().mockImplementation(async (path: string) => {
+				return mockKnowledgeFiles.find((f) => f.path === path) ?? null;
+			}),
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		cache: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		budget: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		provider: {} as any,
+		listContent: vi.fn().mockResolvedValue([]),
+		getContent: vi.fn().mockResolvedValue(null),
+		getCollectionDef: vi.fn().mockReturnValue(null),
+		listCollections: vi.fn().mockReturnValue([]),
+	};
+}
+
+function createTestApp(engine: EngineContext) {
+	const app = new Hono().basePath("/api");
+	app.use("*", errorHandler());
+	app.route("/", knowledgeRoutes(engine));
+	return app;
+}
+
+describe("Knowledge routes", () => {
+	let engine: EngineContext;
+	let app: Hono;
+
+	beforeEach(() => {
+		engine = createMockEngine();
+		app = createTestApp(engine);
+	});
+
+	describe("GET /api/knowledge", () => {
+		it("returns list of knowledge files", async () => {
+			const res = await app.request("/api/knowledge");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.total).toBe(1);
+			expect(body.items[0].path).toBe("knowledge/clients/acme.md");
+		});
+	});
+
+	describe("GET /api/knowledge/:path", () => {
+		it("returns a specific knowledge file", async () => {
+			const res = await app.request("/api/knowledge/knowledge/clients/acme.md");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.path).toBe("knowledge/clients/acme.md");
+			expect(body.body).toContain("Acme Corp");
+		});
+
+		it("returns 404 for unknown path", async () => {
+			const res = await app.request("/api/knowledge/unknown.md");
+			expect(res.status).toBe(404);
+		});
+	});
+
+	describe("POST /api/knowledge", () => {
+		it("ingests knowledge and returns result", async () => {
+			const res = await app.request("/api/knowledge", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					path: "knowledge/clients/acme.md",
+					body: "Meeting notes with Acme Corp...",
+					source: "manual",
+				}),
+			});
+			expect(res.status).toBe(201);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.ingested).toBe(true);
+			expect(body.quality).toBe("structured");
+		});
+
+		it("returns 400 for missing required fields", async () => {
+			const res = await app.request("/api/knowledge", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ path: "test.md" }),
+			});
+			expect(res.status).toBe(400);
+		});
+	});
+});

package/src/__tests__/media-routes.test.ts

@@ -0,0 +1,109 @@
+import type { MediaRef } from "@sourcepress/core";
+import type { MediaStorage } from "@sourcepress/media";
+import { Hono } from "hono";
+import { describe, expect, it, vi } from "vitest";
+import type { EngineContext } from "../engine.js";
+import { mediaRoutes } from "../routes/media.js";
+
+const sampleRef: MediaRef = {
+	path: "assets/hero.webp",
+	content_type: "image/webp",
+	size_bytes: 50000,
+	hash: "abc123",
+	source: "uploaded",
+	uploaded_at: "2026-04-04T10:00:00Z",
+	uploaded_by: "test-user",
+	alt: "Hero image",
+};
+
+function createMockMedia(): MediaStorage {
+	return {
+		upload: vi.fn().mockResolvedValue(sampleRef),
+		get: vi.fn().mockResolvedValue(Buffer.from("data")),
+		delete: vi.fn().mockResolvedValue(undefined),
+		list: vi.fn().mockResolvedValue([sampleRef]),
+		getMeta: vi.fn().mockResolvedValue(sampleRef),
+		updateMeta: vi.fn().mockResolvedValue({ ...sampleRef, alt: "Updated" }),
+	};
+}
+
+function createApp(media?: MediaStorage) {
+	const engine = { media } as EngineContext;
+	const app = new Hono().basePath("/api");
+	app.route("/", mediaRoutes(engine));
+	return app;
+}
+
+describe("media routes", () => {
+	it("GET /api/media — lists media", async () => {
+		const media = createMockMedia();
+		const app = createApp(media);
+
+		const res = await app.request("/api/media");
+		expect(res.status).toBe(200);
+
+		// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+		const body = (await res.json()) as any;
+		expect(body.items).toHaveLength(1);
+		expect(body.items[0].path).toBe("assets/hero.webp");
+	});
+
+	it("GET /api/media/:path — returns metadata", async () => {
+		const media = createMockMedia();
+		const app = createApp(media);
+
+		const res = await app.request("/api/media/assets/hero.webp");
+		expect(res.status).toBe(200);
+
+		// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+		const body = (await res.json()) as any;
+		expect(body.path).toBe("assets/hero.webp");
+		expect(body.alt).toBe("Hero image");
+	});
+
+	it("GET /api/media/:path — 404 for missing file", async () => {
+		const media = createMockMedia();
+		(media.getMeta as ReturnType<typeof vi.fn>).mockResolvedValueOnce(null);
+		const app = createApp(media);
+
+		const res = await app.request("/api/media/assets/missing.webp");
+		expect(res.status).toBe(404);
+	});
+
+	it("PUT /api/media/:path — updates metadata", async () => {
+		const media = createMockMedia();
+		const app = createApp(media);
+
+		const res = await app.request("/api/media/assets/hero.webp", {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ alt: "Updated" }),
+		});
+		expect(res.status).toBe(200);
+
+		// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+		const body = (await res.json()) as any;
+		expect(body.alt).toBe("Updated");
+	});
+
+	it("DELETE /api/media/:path — deletes file", async () => {
+		const media = createMockMedia();
+		const app = createApp(media);
+
+		const res = await app.request("/api/media/assets/hero.webp", {
+			method: "DELETE",
+		});
+		expect(res.status).toBe(200);
+
+		// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+		const body = (await res.json()) as any;
+		expect(body.deleted).toBe(true);
+	});
+
+	it("returns 501 when media is not configured", async () => {
+		const app = createApp(undefined);
+
+		const res = await app.request("/api/media");
+		expect(res.status).toBe(501);
+	});
+});

package/src/__tests__/schema.test.ts

@@ -0,0 +1,100 @@
+import { Hono } from "hono";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { EngineContext } from "../engine.js";
+import { errorHandler } from "../middleware/error-handler.js";
+import { schemaRoutes } from "../routes/schema.js";
+
+const mockCollections = {
+	posts: {
+		name: "Blog Posts",
+		path: "content/posts",
+		format: "mdx" as const,
+		fields: {
+			title: { type: "string" as const, required: true },
+			draft: { type: "boolean" as const, default: true },
+		},
+	},
+	team: {
+		name: "Team",
+		path: "content/team",
+		format: "yaml" as const,
+		fields: {
+			name: { type: "string" as const, required: true },
+			role: { type: "string" as const },
+		},
+	},
+};
+
+function createMockEngine(): EngineContext {
+	return {
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		config: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		github: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		knowledge: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		knowledgeStore: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		cache: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		budget: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		provider: {} as any,
+		listContent: vi.fn().mockResolvedValue([]),
+		getContent: vi.fn().mockResolvedValue(null),
+		getCollectionDef: vi.fn().mockImplementation((name: string) => {
+			// biome-ignore lint/suspicious/noExplicitAny: index access on typed const object
+			return (mockCollections as any)[name] ?? null;
+		}),
+		listCollections: vi.fn().mockReturnValue(["posts", "team"]),
+	};
+}
+
+function createTestApp(engine: EngineContext) {
+	const app = new Hono().basePath("/api");
+	app.use("*", errorHandler());
+	app.route("/", schemaRoutes(engine));
+	return app;
+}
+
+describe("Schema routes", () => {
+	let engine: EngineContext;
+	let app: Hono;
+
+	beforeEach(() => {
+		engine = createMockEngine();
+		app = createTestApp(engine);
+	});
+
+	describe("GET /api/schema", () => {
+		it("returns all collection schemas", async () => {
+			const res = await app.request("/api/schema");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.total).toBe(2);
+			expect(body.collections.posts.name).toBe("Blog Posts");
+			expect(body.collections.team.name).toBe("Team");
+		});
+	});
+
+	describe("GET /api/schema/:collection", () => {
+		it("returns schema for a valid collection", async () => {
+			const res = await app.request("/api/schema/posts");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.name).toBe("Blog Posts");
+			expect(body.fields.title.type).toBe("string");
+		});
+
+		it("returns 404 for unknown collection", async () => {
+			const res = await app.request("/api/schema/unknown");
+			expect(res.status).toBe(404);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.code).toBe("COLLECTION_NOT_FOUND");
+		});
+	});
+});

package/src/app.ts

@@ -0,0 +1,92 @@
+import { Hono } from "hono";
+import { secureHeaders } from "hono/secure-headers";
+import type { EngineContext } from "./engine.js";
+import { authMiddleware, corsMiddleware, errorHandler, requireAuth } from "./middleware/index.js";
+import { aiRateLimit, generalRateLimit } from "./middleware/rate-limit.js";
+import { approvalRoutes } from "./routes/approval.js";
+import { contentRoutes } from "./routes/content.js";
+import { evalRoutes } from "./routes/eval.js";
+import { graphRoutes } from "./routes/graph.js";
+import { healthRoutes } from "./routes/health.js";
+import { importRoutes } from "./routes/import.js";
+import { intentRoutes } from "./routes/intent.js";
+import { jobRoutes } from "./routes/jobs.js";
+import { knowledgeRoutes } from "./routes/knowledge.js";
+import { mediaRoutes } from "./routes/media.js";
+import { schemaRoutes } from "./routes/schema.js";
+
+/**
+ * Create a fully wired SourcePress API app.
+ * If no engine is provided, only health endpoint is available.
+ */
+export function createApp(engine?: EngineContext, apiKeys?: string[]) {
+	const app = new Hono().basePath("/api");
+
+	// Global middleware
+	app.use("*", secureHeaders());
+	app.use("*", corsMiddleware());
+	app.use("*", errorHandler());
+	app.use("*", authMiddleware(apiKeys));
+	app.use("*", generalRateLimit());
+
+	// Tighter rate limits for AI-consuming endpoints
+	app.use("/eval/*", aiRateLimit());
+	app.use("/knowledge", aiRateLimit());
+	app.use("/knowledge/import/*", aiRateLimit());
+	app.use("/knowledge/import", aiRateLimit());
+	app.use("/graph/rebuild", aiRateLimit());
+
+	// Protect all write endpoints
+	app.use("/content/*", async (c, next) => {
+		if (c.req.method === "POST" || c.req.method === "PUT" || c.req.method === "DELETE") {
+			return requireAuth()(c, next);
+		}
+		await next();
+	});
+	app.use("/knowledge", async (c, next) => {
+		if (c.req.method === "POST") {
+			return requireAuth()(c, next);
+		}
+		await next();
+	});
+	app.use("/knowledge/import/*", requireAuth());
+	app.use("/knowledge/import", requireAuth());
+	app.use("/graph/rebuild", requireAuth());
+	app.use("/eval/*", async (c, next) => {
+		if (c.req.method === "POST" || c.req.method === "PUT") {
+			return requireAuth()(c, next);
+		}
+		await next();
+	});
+	app.use("/approval/*", async (c, next) => {
+		if (c.req.method === "POST" || c.req.method === "PUT" || c.req.method === "DELETE") {
+			return requireAuth()(c, next);
+		}
+		await next();
+	});
+	app.use("/media/*", async (c, next) => {
+		if (c.req.method === "POST" || c.req.method === "PUT" || c.req.method === "DELETE") {
+			return requireAuth()(c, next);
+		}
+		await next();
+	});
+
+	// Health is always available
+	app.route("/", healthRoutes());
+
+	// Engine-dependent routes
+	if (engine) {
+		app.route("/", contentRoutes(engine));
+		app.route("/", knowledgeRoutes(engine));
+		app.route("/", graphRoutes(engine));
+		app.route("/", schemaRoutes(engine));
+		app.route("/", intentRoutes(engine));
+		app.route("/", evalRoutes(engine));
+		app.route("/", mediaRoutes(engine));
+		app.route("/", jobRoutes(engine));
+		app.route("/", importRoutes(engine));
+		app.route("/", approvalRoutes(engine));
+	}
+
+	return app;
+}

package/src/engine.ts

@@ -0,0 +1,168 @@
+import { join } from "node:path";
+import { BudgetTracker, resolveProvider } from "@sourcepress/ai";
+import type { ResolvedProvider } from "@sourcepress/ai";
+import { MemoryCache } from "@sourcepress/cache";
+import type { CacheProvider } from "@sourcepress/cache";
+import type {
+	ApprovalProvider,
+	CollectionDefinition,
+	ContentFile,
+	SourcePressConfig,
+} from "@sourcepress/core";
+import {
+	GitHubClient,
+	GitHubPRApprovalProvider,
+	getContentFile,
+	listContentFiles,
+	listKnowledgeFiles,
+} from "@sourcepress/github";
+import { InProcessJobProvider } from "@sourcepress/jobs";
+import type { JobProvider } from "@sourcepress/jobs";
+import { InMemoryKnowledgeStore, JsonFileStore, KnowledgeEngine } from "@sourcepress/knowledge";
+import type { KnowledgeGraph, KnowledgeStoreBackend } from "@sourcepress/knowledge";
+import { GitMediaStorage } from "@sourcepress/media";
+import type { MediaStorage } from "@sourcepress/media";
+
+export interface EngineContext {
+	config: SourcePressConfig;
+	github: GitHubClient;
+	knowledge: KnowledgeEngine;
+	knowledgeStore: KnowledgeStoreBackend;
+	cache: CacheProvider;
+	budget: BudgetTracker;
+	provider: ResolvedProvider;
+	media?: MediaStorage;
+	jobs?: JobProvider;
+	approval?: ApprovalProvider;
+
+	// Convenience methods that combine packages
+	listContent(collection: string): Promise<ContentFile[]>;
+	getContent(collection: string, slug: string): Promise<ContentFile | null>;
+	getCollectionDef(collection: string): CollectionDefinition | null;
+	listCollections(): string[];
+}
+
+export function resolveApprovalRule(
+	config: SourcePressConfig,
+	collection: string,
+	path: string,
+): "pr" | "direct" {
+	if (!config.approval?.rules) return "direct";
+	for (const [pattern, rule] of Object.entries(config.approval.rules)) {
+		if (path.startsWith(pattern.replace("/*", "/")) || path === pattern) {
+			return rule;
+		}
+	}
+	return "direct";
+}
+
+export interface CreateEngineOptions {
+	config: SourcePressConfig;
+	githubToken: string;
+	aiApiKey?: string;
+	apiKeys?: string[];
+	knowledgeStore?: KnowledgeStoreBackend;
+	cache?: CacheProvider;
+	media?: MediaStorage;
+	jobs?: JobProvider;
+}
+
+export async function createEngine(options: CreateEngineOptions): Promise<EngineContext> {
+	const { config, githubToken, aiApiKey } = options;
+
+	// GitHub client
+	const github = new GitHubClient({
+		owner: config.repository.owner,
+		repo: config.repository.repo,
+		branch: config.repository.branch,
+		token: githubToken,
+	});
+
+	// AI provider + budget
+	const provider = resolveProvider({
+		provider: config.ai.provider,
+		model: config.ai.model,
+		apiKey: aiApiKey,
+	});
+
+	const budget = new BudgetTracker({
+		daily_limit_usd: config.ai.daily_limit_usd ?? 5.0,
+		warn_at_usd: config.ai.warn_at_usd ?? 3.0,
+	});
+
+	// Knowledge store + engine
+	const knowledgeStore =
+		options.knowledgeStore ??
+		(config.knowledge.graph.backend === "local"
+			? new JsonFileStore(join(process.cwd(), ".sourcepress"))
+			: new InMemoryKnowledgeStore());
+	const knowledge = new KnowledgeEngine(knowledgeStore, provider, budget);
+	await knowledge.initialize();
+
+	// Cache
+	const cache = options.cache ?? new MemoryCache();
+
+	// Media storage (optional — only if configured)
+	let media: MediaStorage | undefined;
+	if (config.media) {
+		media = options.media ?? new GitMediaStorage(github, config.media);
+	}
+
+	// Job provider (always available, default is in-process)
+	const jobs: JobProvider = options.jobs ?? new InProcessJobProvider();
+
+	// Approval provider (optional — only if configured)
+	let approval: ApprovalProvider | undefined;
+	if (config.approval?.provider === "github-pr") {
+		approval = new GitHubPRApprovalProvider(github);
+	}
+
+	// Convenience methods
+	async function listContent(collection: string): Promise<ContentFile[]> {
+		const collDef = config.collections[collection];
+		if (!collDef) return [];
+		const paths = await listContentFiles(github, collDef.path);
+		const files: ContentFile[] = [];
+		for (const path of paths) {
+			const file = await getContentFile(github, path, collection);
+			if (file) files.push(file);
+		}
+		return files;
+	}
+
+	async function getContent(collection: string, slug: string): Promise<ContentFile | null> {
+		const collDef = config.collections[collection];
+		if (!collDef) return null;
+		if (!/^[a-z0-9-]+$/.test(slug)) return null;
+		const ext =
+			collDef.format === "yaml" ? "yaml" : collDef.format === "json" ? "json" : collDef.format;
+		const basePath = collDef.path.replace(/\/+$/, "");
+		const path = `${basePath}/${slug}.${ext}`;
+		return getContentFile(github, path, collection);
+	}
+
+	function getCollectionDef(collection: string): CollectionDefinition | null {
+		return config.collections[collection] ?? null;
+	}
+
+	function listCollections(): string[] {
+		return Object.keys(config.collections);
+	}
+
+	return {
+		config,
+		github,
+		knowledge,
+		knowledgeStore,
+		cache,
+		budget,
+		provider,
+		media,
+		jobs,
+		approval,
+		listContent,
+		getContent,
+		getCollectionDef,
+		listCollections,
+	};
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+// App factory
+export { createApp } from "./app.js";
+
+// Engine
+export { createEngine, resolveApprovalRule } from "./engine.js";
+export type { EngineContext, CreateEngineOptions } from "./engine.js";
+
+// Routes
+export {
+	approvalRoutes,
+	healthRoutes,
+	contentRoutes,
+	knowledgeRoutes,
+	graphRoutes,
+	schemaRoutes,
+	intentRoutes,
+	evalRoutes,
+	mediaRoutes,
+	jobRoutes,
+	importRoutes,
+} from "./routes/index.js";
+export type { HealthStatus } from "./routes/health.js";
+
+// Middleware
+export {
+	corsMiddleware,
+	errorHandler,
+	authMiddleware,
+	SourcePressError,
+} from "./middleware/index.js";
+export type { ApiError, AuthContext } from "./middleware/index.js";

package/src/middleware/auth.ts

@@ -0,0 +1,66 @@
+import { timingSafeEqual } from "node:crypto";
+import type { Context, Next } from "hono";
+
+export interface AuthContext {
+	authenticated: boolean;
+	user?: string;
+	method?: "api-key" | "bearer" | "none";
+}
+
+function safeCompare(a: string, b: string): boolean {
+	const aBuf = Buffer.from(a, "utf-8");
+	const bBuf = Buffer.from(b, "utf-8");
+	if (aBuf.length !== bBuf.length) {
+		// Still run comparison on equal-length buffers to avoid timing leak on length
+		timingSafeEqual(aBuf, aBuf);
+		return false;
+	}
+	return timingSafeEqual(aBuf, bBuf);
+}
+
+export function authMiddleware(apiKeys?: string[]) {
+	return async (c: Context, next: Next) => {
+		const authHeader = c.req.header("Authorization");
+
+		const auth: AuthContext = {
+			authenticated: false,
+			method: "none",
+		};
+
+		if (authHeader?.startsWith("Bearer ") || authHeader?.startsWith("ApiKey ")) {
+			const scheme = authHeader.startsWith("Bearer ") ? "bearer" : "api-key";
+			const token = authHeader.slice(scheme === "bearer" ? 7 : 7);
+
+			if (!apiKeys || apiKeys.length === 0) {
+				// No keys configured — accept any token (warn once is gone; engine should configure keys)
+				auth.authenticated = true;
+				auth.method = scheme;
+				auth.user = "anonymous";
+			} else {
+				const matched = apiKeys.some((key) => safeCompare(token, key));
+				if (matched) {
+					auth.authenticated = true;
+					auth.method = scheme;
+					auth.user = "api-client";
+				}
+			}
+		}
+
+		c.set("auth", auth);
+		await next();
+	};
+}
+
+/**
+ * Middleware that rejects unauthenticated requests with 401.
+ * Apply to write endpoints (POST, PUT, DELETE).
+ */
+export function requireAuth() {
+	return async (c: Context, next: Next) => {
+		const auth = c.get("auth") as AuthContext | undefined;
+		if (!auth?.authenticated) {
+			return c.json({ status: 401, message: "Unauthorized", code: "UNAUTHORIZED" }, 401);
+		}
+		await next();
+	};
+}