@sondt2709/wikijs-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1020 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { parseArgs } from "node:util";
+import { z } from "zod";
+import pino, { destination } from "pino";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+//#region src/config.ts
+const ConfigSchema = z.object({
+	wikijsUrl: z.url({ message: "must be a valid URL like https://wiki.example.com" }),
+	wikijsToken: z.string().min(1, "must not be empty"),
+	transport: z.enum(["stdio", "http"]).default("stdio"),
+	port: z.coerce.number().int().min(1).max(65535).default(3e3),
+	logLevel: z.enum([
+		"fatal",
+		"error",
+		"warn",
+		"info",
+		"debug",
+		"trace"
+	]).default("info")
+});
+function loadConfig(argv = process.argv.slice(2)) {
+	const { values } = parseArgs({
+		args: argv,
+		options: {
+			url: { type: "string" },
+			token: { type: "string" },
+			transport: { type: "string" },
+			port: { type: "string" },
+			"log-level": { type: "string" }
+		}
+	});
+	const parsed = ConfigSchema.safeParse({
+		wikijsUrl: values.url ?? process.env.WIKIJS_URL,
+		wikijsToken: values.token ?? process.env.WIKIJS_TOKEN,
+		transport: values.transport ?? process.env.TRANSPORT,
+		port: values.port ?? process.env.PORT,
+		logLevel: values["log-level"] ?? process.env.LOG_LEVEL
+	});
+	if (!parsed.success) {
+		const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+		throw new Error(`Invalid configuration — ${issues}. Set WIKIJS_URL and WIKIJS_TOKEN env vars (or --url/--token flags). See .env.example.`);
+	}
+	return parsed.data;
+}
+//#endregion
+//#region src/logger.ts
+function createLogger(level) {
+	return pino({
+		level,
+		base: void 0
+	}, destination(2));
+}
+//#endregion
+//#region package.json
+var version = "0.1.0";
+//#endregion
+//#region src/client/graphql.ts
+var WikiJsError = class extends Error {
+	kind;
+	slug;
+	errorCode;
+	constructor(message, kind, slug, errorCode) {
+		super(message);
+		this.name = "WikiJsError";
+		this.kind = kind;
+		this.slug = slug;
+		this.errorCode = errorCode;
+	}
+};
+function assertSucceeded(rr, action) {
+	if (!rr.succeeded) throw new WikiJsError(`Wiki.js error ${rr.slug} while ${action}: ${rr.message ?? "no message provided"}`, "application", rr.slug, rr.errorCode);
+}
+const AUTH_HINT = " (check that WIKIJS_TOKEN is a valid, unexpired API key and that its group has the required page permissions)";
+var GraphQLClient = class {
+	endpoint;
+	token;
+	timeoutMs;
+	constructor(opts) {
+		this.endpoint = new URL("/graphql", opts.baseUrl).toString();
+		this.token = opts.token;
+		this.timeoutMs = opts.timeoutMs ?? 3e4;
+	}
+	async request(query, variables) {
+		let res;
+		try {
+			res = await fetch(this.endpoint, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					authorization: `Bearer ${this.token}`
+				},
+				body: JSON.stringify({
+					query,
+					variables
+				}),
+				signal: AbortSignal.timeout(this.timeoutMs)
+			});
+		} catch (err) {
+			throw new WikiJsError(`Cannot reach Wiki.js at ${this.endpoint}: ${err.message}`, "transport");
+		}
+		if (res.status === 401 || res.status === 403) throw new WikiJsError(`Wiki.js rejected the request with HTTP ${res.status}${AUTH_HINT}`, "transport");
+		if (!res.ok) throw new WikiJsError(`Wiki.js returned HTTP ${res.status} for GraphQL request`, "transport");
+		let body;
+		try {
+			body = await res.json();
+		} catch {
+			throw new WikiJsError(`Wiki.js returned a non-JSON response (HTTP ${res.status})`, "transport");
+		}
+		if (body.errors?.length) {
+			const message = body.errors.map((e) => e.message).join("; ");
+			throw new WikiJsError(`GraphQL error: ${message}${/forbidden|unauthorized|not authorized/i.test(message) ? AUTH_HINT : ""}`, "graphql");
+		}
+		if (body.data == null) throw new WikiJsError("Wiki.js returned an empty GraphQL response", "graphql");
+		return body.data;
+	}
+};
+//#endregion
+//#region src/client/wikijs.ts
+function isPageNotFoundError(err) {
+	return err instanceof WikiJsError && err.kind === "graphql" && /does not exist/i.test(err.message);
+}
+const SearchResultSchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	description: z.string(),
+	path: z.string(),
+	locale: z.string()
+});
+const SearchResponseSchema = z.object({
+	results: z.array(SearchResultSchema),
+	suggestions: z.array(z.string().nullable()).transform((a) => a.filter((s) => s != null)),
+	totalHits: z.number()
+});
+const PageListItemSchema = z.object({
+	id: z.number(),
+	path: z.string(),
+	locale: z.string(),
+	title: z.string().nullish(),
+	description: z.string().nullish(),
+	contentType: z.string(),
+	isPublished: z.boolean(),
+	isPrivate: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	tags: z.array(z.string().nullable()).nullish().transform((a) => (a ?? []).filter((t) => t != null))
+});
+const PageDetailSchema = z.object({
+	id: z.number(),
+	path: z.string(),
+	locale: z.string(),
+	title: z.string(),
+	description: z.string(),
+	content: z.string(),
+	contentType: z.string(),
+	editor: z.string(),
+	isPublished: z.boolean(),
+	isPrivate: z.boolean(),
+	tags: z.array(z.object({ tag: z.string() }).nullable()).transform((a) => a.filter((t) => t != null).map((t) => t.tag)),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+const TreeItemSchema = z.object({
+	id: z.number(),
+	path: z.string(),
+	depth: z.number(),
+	title: z.string(),
+	isFolder: z.boolean(),
+	pageId: z.number().nullish(),
+	parent: z.number().nullish(),
+	locale: z.string()
+});
+const TagSchema = z.object({
+	id: z.number(),
+	tag: z.string(),
+	title: z.string().nullish()
+});
+const PAGE_DETAIL_FIELDS = `
+  id path locale title description content contentType editor
+  isPublished isPrivate tags { tag } createdAt updatedAt
+`;
+const PageRefSchema = z.object({
+	id: z.number(),
+	path: z.string(),
+	locale: z.string(),
+	title: z.string()
+});
+const MutationPageSchema = z.object({
+	id: z.number(),
+	path: z.string(),
+	title: z.string()
+});
+const MutationResponseSchema = z.object({
+	responseResult: z.object({
+		succeeded: z.boolean(),
+		errorCode: z.number(),
+		slug: z.string(),
+		message: z.string().nullish()
+	}),
+	page: MutationPageSchema.nullish()
+});
+const HistoryEntrySchema = z.object({
+	versionId: z.number(),
+	versionDate: z.string(),
+	authorId: z.number(),
+	authorName: z.string(),
+	actionType: z.string(),
+	valueBefore: z.string().nullish(),
+	valueAfter: z.string().nullish()
+});
+const PageVersionSchema = z.object({
+	versionId: z.number(),
+	versionDate: z.string(),
+	action: z.string(),
+	authorName: z.string(),
+	pageId: z.number(),
+	path: z.string(),
+	locale: z.string(),
+	title: z.string(),
+	description: z.string(),
+	content: z.string(),
+	contentType: z.string(),
+	editor: z.string(),
+	isPublished: z.boolean(),
+	tags: z.array(z.string().nullable()).transform((a) => a.filter((t) => t != null)),
+	createdAt: z.string()
+});
+const AssetFolderSchema = z.object({
+	id: z.number(),
+	slug: z.string(),
+	name: z.string().nullish()
+});
+const AssetItemSchema = z.object({
+	id: z.number(),
+	filename: z.string(),
+	ext: z.string(),
+	kind: z.string(),
+	mime: z.string(),
+	fileSize: z.number(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+var WikiJsClient = class {
+	gql;
+	constructor(gql) {
+		this.gql = gql;
+	}
+	async searchPages(args) {
+		const data = await this.gql.request(`query ($query: String!, $path: String, $locale: String) {
+        pages { search(query: $query, path: $path, locale: $locale) {
+          results { id title description path locale }
+          suggestions
+          totalHits
+        } }
+      }`, args);
+		return SearchResponseSchema.parse(data.pages.search);
+	}
+	async listPages(args) {
+		const data = await this.gql.request(`query ($limit: Int, $orderBy: PageOrderBy, $orderByDirection: PageOrderByDirection, $tags: [String!], $locale: String) {
+        pages { list(limit: $limit, orderBy: $orderBy, orderByDirection: $orderByDirection, tags: $tags, locale: $locale) {
+          id path locale title description contentType isPublished isPrivate createdAt updatedAt tags
+        } }
+      }`, args);
+		return z.array(PageListItemSchema).parse(data.pages.list);
+	}
+	async getPageById(id) {
+		try {
+			const data = await this.gql.request(`query ($id: Int!) { pages { single(id: $id) { ${PAGE_DETAIL_FIELDS} } } }`, { id });
+			return data.pages.single == null ? null : PageDetailSchema.parse(data.pages.single);
+		} catch (err) {
+			if (isPageNotFoundError(err)) return null;
+			throw err;
+		}
+	}
+	async getPageByPath(path, locale) {
+		try {
+			const data = await this.gql.request(`query ($path: String!, $locale: String!) { pages { singleByPath(path: $path, locale: $locale) { ${PAGE_DETAIL_FIELDS} } } }`, {
+				path,
+				locale
+			});
+			return data.pages.singleByPath == null ? null : PageDetailSchema.parse(data.pages.singleByPath);
+		} catch (err) {
+			if (isPageNotFoundError(err)) return null;
+			throw err;
+		}
+	}
+	async getTree(args) {
+		const requestMode = args.mode === "PAGES" ? "ALL" : args.mode;
+		const data = await this.gql.request(`query ($parent: Int, $path: String, $mode: PageTreeMode!, $locale: String!, $includeAncestors: Boolean) {
+        pages { tree(parent: $parent, path: $path, mode: $mode, locale: $locale, includeAncestors: $includeAncestors) {
+          id path depth title isFolder pageId parent locale
+        } }
+      }`, {
+			...args,
+			mode: requestMode
+		});
+		const items = z.array(TreeItemSchema.nullable()).parse(data.pages.tree ?? []).filter((t) => t != null);
+		return args.mode === "PAGES" ? items.filter((t) => !t.isFolder) : items;
+	}
+	async listTags() {
+		const data = await this.gql.request(`query { pages { tags { id tag title } } }`);
+		return z.array(TagSchema.nullable()).parse(data.pages.tags).filter((t) => t != null);
+	}
+	async searchTags(query) {
+		const data = await this.gql.request(`query ($query: String!) { pages { searchTags(query: $query) } }`, { query });
+		return z.array(z.string().nullable()).parse(data.pages.searchTags).filter((t) => t != null);
+	}
+	async createPage(input) {
+		const data = await this.gql.request(`mutation ($content: String!, $description: String!, $editor: String!, $isPublished: Boolean!,
+                 $isPrivate: Boolean!, $locale: String!, $path: String!, $tags: [String]!, $title: String!) {
+        pages { create(content: $content, description: $description, editor: $editor, isPublished: $isPublished,
+                       isPrivate: $isPrivate, locale: $locale, path: $path, tags: $tags, title: $title) {
+          responseResult { succeeded errorCode slug message }
+          page { id path title }
+        } }
+      }`, {
+			content: input.content,
+			description: input.description ?? "",
+			editor: input.editor ?? "markdown",
+			isPublished: input.isPublished ?? true,
+			isPrivate: input.isPrivate ?? false,
+			locale: input.locale ?? "en",
+			path: input.path,
+			tags: input.tags ?? [],
+			title: input.title
+		});
+		const res = MutationResponseSchema.parse(data.pages.create);
+		assertSucceeded(res.responseResult, `creating page at ${input.path}`);
+		if (!res.page) throw new WikiJsError("Wiki.js reported success but returned no page", "application");
+		return PageRefSchema.parse({
+			...res.page,
+			locale: input.locale ?? "en"
+		});
+	}
+	async updatePage(input) {
+		const { id, ...fields } = input;
+		const current = fields.tags == null || fields.content == null || fields.isPublished == null || fields.isPrivate == null ? await this.getPageById(id) : null;
+		const tags = fields.tags ?? current?.tags ?? [];
+		const content = fields.content ?? current?.content;
+		const isPublished = fields.isPublished ?? current?.isPublished;
+		const isPrivate = fields.isPrivate ?? current?.isPrivate;
+		const data = await this.gql.request(`mutation ($id: Int!, $content: String, $description: String, $isPrivate: Boolean, $isPublished: Boolean,
+                 $locale: String, $path: String, $tags: [String]!, $title: String) {
+        pages { update(id: $id, content: $content, description: $description, isPrivate: $isPrivate,
+                       isPublished: $isPublished, locale: $locale, path: $path, tags: $tags, title: $title) {
+          responseResult { succeeded errorCode slug message }
+          page { id path title }
+        } }
+      }`, {
+			id,
+			...fields,
+			tags,
+			content,
+			isPublished,
+			isPrivate
+		});
+		const res = MutationResponseSchema.parse(data.pages.update);
+		assertSucceeded(res.responseResult, `updating page ${id}`);
+		if (!res.page) throw new WikiJsError("Wiki.js reported success but returned no page", "application");
+		const updated = await this.getPageById(id);
+		if (!updated) throw new WikiJsError(`Page ${id} vanished immediately after a successful update`, "application");
+		return PageRefSchema.parse({
+			id: updated.id,
+			path: updated.path,
+			locale: updated.locale,
+			title: updated.title
+		});
+	}
+	async movePage(id, destinationPath, destinationLocale) {
+		const data = await this.gql.request(`mutation ($id: Int!, $destinationPath: String!, $destinationLocale: String!) {
+        pages { move(id: $id, destinationPath: $destinationPath, destinationLocale: $destinationLocale) {
+          responseResult { succeeded errorCode slug message }
+        } }
+      }`, {
+			id,
+			destinationPath,
+			destinationLocale
+		});
+		assertSucceeded(z.object({ responseResult: MutationResponseSchema.shape.responseResult }).parse(data.pages.move).responseResult, `moving page ${id} to ${destinationLocale}/${destinationPath}`);
+	}
+	async deletePage(id) {
+		const data = await this.gql.request(`mutation ($id: Int!) {
+        pages { delete(id: $id) { responseResult { succeeded errorCode slug message } } }
+      }`, { id });
+		assertSucceeded(z.object({ responseResult: MutationResponseSchema.shape.responseResult }).parse(data.pages.delete).responseResult, `deleting page ${id}`);
+	}
+	async getHistory(id, offsetPage, offsetSize) {
+		const data = await this.gql.request(`query ($id: Int!, $offsetPage: Int, $offsetSize: Int) {
+        pages { history(id: $id, offsetPage: $offsetPage, offsetSize: $offsetSize) {
+          trail { versionId versionDate authorId authorName actionType valueBefore valueAfter }
+          total
+        } }
+      }`, {
+			id,
+			offsetPage,
+			offsetSize
+		});
+		return z.object({
+			trail: z.array(HistoryEntrySchema.nullable()).nullish().transform((a) => (a ?? []).filter((e) => e != null)),
+			total: z.number()
+		}).parse(data.pages.history);
+	}
+	async getVersion(pageId, versionId) {
+		const data = await this.gql.request(`query ($pageId: Int!, $versionId: Int!) {
+        pages { version(pageId: $pageId, versionId: $versionId) {
+          versionId versionDate action authorName pageId path locale title description
+          content contentType editor isPublished tags createdAt
+        } }
+      }`, {
+			pageId,
+			versionId
+		});
+		if (data.pages.version == null) throw new WikiJsError(`Version ${versionId} of page ${pageId} not found`, "application");
+		return PageVersionSchema.parse(data.pages.version);
+	}
+	async restoreVersion(pageId, versionId) {
+		const data = await this.gql.request(`mutation ($pageId: Int!, $versionId: Int!) {
+        pages { restore(pageId: $pageId, versionId: $versionId) {
+          responseResult { succeeded errorCode slug message }
+        } }
+      }`, {
+			pageId,
+			versionId
+		});
+		assertSucceeded(z.object({ responseResult: MutationResponseSchema.shape.responseResult }).parse(data.pages.restore).responseResult, `restoring page ${pageId} to version ${versionId}`);
+	}
+	async listAssetFolders(parentFolderId) {
+		const data = await this.gql.request(`query ($parentFolderId: Int!) { assets { folders(parentFolderId: $parentFolderId) { id slug name } } }`, { parentFolderId });
+		return z.array(AssetFolderSchema.nullable()).parse(data.assets.folders ?? []).filter((f) => f != null);
+	}
+	async listAssets(folderId, kind) {
+		const data = await this.gql.request(`query ($folderId: Int!, $kind: AssetKind!) {
+        assets { list(folderId: $folderId, kind: $kind) {
+          id filename ext kind mime fileSize createdAt updatedAt
+        } }
+      }`, {
+			folderId,
+			kind
+		});
+		return z.array(AssetItemSchema.nullable()).parse(data.assets.list ?? []).filter((a) => a != null);
+	}
+};
+//#endregion
+//#region src/tools/result.ts
+/**
+* Wraps a tool handler to log its name and duration (ms) at debug level on
+* every call. Never logs arguments or tokens — timing/name only.
+*/
+function instrument(logger, name, handler) {
+	return async (...args) => {
+		const start = performance.now();
+		try {
+			return await handler(...args);
+		} finally {
+			const durationMs = performance.now() - start;
+			logger.debug({
+				tool: name,
+				durationMs
+			}, "tool call");
+		}
+	};
+}
+function ok(structured, summary) {
+	const json = JSON.stringify(structured);
+	return {
+		content: [{
+			type: "text",
+			text: summary ? `${summary}\n\n${json}` : json
+		}],
+		structuredContent: structured
+	};
+}
+function fail(err) {
+	return {
+		content: [{
+			type: "text",
+			text: err instanceof WikiJsError || err instanceof Error ? err.message : String(err)
+		}],
+		isError: true
+	};
+}
+/**
+* Slices text content by 0-based, inclusive line range. Negative bounds
+* count from the end (Python-style: -1 = last line). Bounds are clamped to
+* the available lines, and an empty result is returned if start > end.
+*/
+function sliceLines(content, startLine, endLine) {
+	const lines = content === "" ? [] : content.split("\n");
+	const totalLines = lines.length;
+	if (totalLines === 0) return {
+		content: "",
+		totalLines: 0,
+		startLine: 0,
+		endLine: 0
+	};
+	const resolveIndex = (n) => n < 0 ? totalLines + n : n;
+	const clamp = (n) => Math.min(Math.max(n, 0), totalLines - 1);
+	const resolvedStart = clamp(resolveIndex(startLine));
+	const resolvedEnd = clamp(resolveIndex(endLine));
+	return {
+		content: resolvedStart > resolvedEnd ? "" : lines.slice(resolvedStart, resolvedEnd + 1).join("\n"),
+		totalLines,
+		startLine: resolvedStart,
+		endLine: resolvedEnd
+	};
+}
+//#endregion
+//#region src/tools/discovery.ts
+const pageSummaryShape = {
+	id: z.number(),
+	path: z.string(),
+	locale: z.string(),
+	title: z.string().nullable(),
+	description: z.string().nullable(),
+	isPublished: z.boolean(),
+	isPrivate: z.boolean(),
+	tags: z.array(z.string()),
+	createdAt: z.string(),
+	updatedAt: z.string()
+};
+function registerDiscoveryTools(server, wiki, logger) {
+	server.registerTool("search_pages", {
+		title: "Search pages",
+		description: "Full-text search Wiki.js pages. Returns matching pages with id, title, path and locale. Use get_page to fetch content.",
+		inputSchema: {
+			query: z.string().min(1).describe("Search keywords"),
+			path: z.string().optional().describe("Restrict results to this path prefix"),
+			locale: z.string().optional().describe("Locale code, e.g. \"en\"")
+		},
+		outputSchema: {
+			results: z.array(z.object({
+				id: z.string(),
+				title: z.string(),
+				description: z.string(),
+				path: z.string(),
+				locale: z.string()
+			})),
+			suggestions: z.array(z.string()),
+			totalHits: z.number()
+		}
+	}, instrument(logger, "search_pages", async (args) => {
+		try {
+			return ok(await wiki.searchPages(args));
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+	server.registerTool("list_pages", {
+		title: "List pages",
+		description: "List Wiki.js pages with optional ordering, tag and locale filters.",
+		inputSchema: {
+			limit: z.number().int().min(1).max(500).default(50).describe("Max pages to return"),
+			orderBy: z.enum([
+				"CREATED",
+				"ID",
+				"PATH",
+				"TITLE",
+				"UPDATED"
+			]).optional(),
+			orderByDirection: z.enum(["ASC", "DESC"]).optional(),
+			tags: z.array(z.string()).optional().describe("Only pages having all these tags"),
+			locale: z.string().optional()
+		},
+		outputSchema: {
+			pages: z.array(z.object({
+				...pageSummaryShape,
+				contentType: z.string()
+			})),
+			total: z.number()
+		}
+	}, instrument(logger, "list_pages", async (args) => {
+		try {
+			const pages = await wiki.listPages(args);
+			return ok({
+				pages: pages.map((p) => ({
+					...p,
+					title: p.title ?? null,
+					description: p.description ?? null
+				})),
+				total: pages.length
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+	server.registerTool("get_page", {
+		title: "Get page",
+		description: "Fetch one page by numeric id OR by path (+ locale, default \"en\"). Optionally slice its content by line range with startLine/endLine: 0-based, inclusive on both ends. Default (0..-1) returns the whole page. Negative values count from the end, Python-style (-1 = last line, -2 = second-to-last).",
+		inputSchema: {
+			id: z.number().int().optional().describe("Page id (preferred when known)"),
+			path: z.string().optional().describe("Page path, e.g. \"guides/install\""),
+			locale: z.string().default("en").describe("Locale for path lookup"),
+			startLine: z.number().int().default(0).describe("0-based start line, inclusive. Negative counts from the end."),
+			endLine: z.number().int().default(-1).describe("0-based end line, inclusive. -1 (default) means the last line.")
+		},
+		outputSchema: {
+			page: z.object({
+				id: z.number(),
+				path: z.string(),
+				locale: z.string(),
+				title: z.string(),
+				description: z.string(),
+				content: z.string(),
+				contentType: z.string(),
+				editor: z.string(),
+				isPublished: z.boolean(),
+				isPrivate: z.boolean(),
+				tags: z.array(z.string()),
+				createdAt: z.string(),
+				updatedAt: z.string()
+			}),
+			totalLines: z.number(),
+			startLine: z.number(),
+			endLine: z.number()
+		}
+	}, instrument(logger, "get_page", async (args) => {
+		try {
+			if (args.id == null && !args.path) return fail(/* @__PURE__ */ new Error("Provide either \"id\" or \"path\""));
+			const page = args.id != null ? await wiki.getPageById(args.id) : await wiki.getPageByPath(args.path, args.locale);
+			if (!page) return fail(/* @__PURE__ */ new Error(`Page not found: ${args.id != null ? `id ${args.id}` : `${args.locale}/${args.path}`}`));
+			const sliced = sliceLines(page.content, args.startLine, args.endLine);
+			return ok({
+				page: {
+					...page,
+					content: sliced.content
+				},
+				totalLines: sliced.totalLines,
+				startLine: sliced.startLine,
+				endLine: sliced.endLine
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+	server.registerTool("get_page_tree", {
+		title: "Browse page tree",
+		description: "Browse the page/folder hierarchy one level at a time. Omit parent for the root level; pass a folder item id as parent to descend.",
+		inputSchema: {
+			parent: z.number().int().optional().describe("Tree item id to list children of (omit for root)"),
+			mode: z.enum([
+				"ALL",
+				"PAGES",
+				"FOLDERS"
+			]).default("ALL"),
+			locale: z.string().default("en"),
+			includeAncestors: z.boolean().optional()
+		},
+		outputSchema: { items: z.array(z.object({
+			id: z.number(),
+			path: z.string(),
+			depth: z.number(),
+			title: z.string(),
+			isFolder: z.boolean(),
+			pageId: z.number().nullable(),
+			parent: z.number().nullable(),
+			locale: z.string()
+		})) }
+	}, instrument(logger, "get_page_tree", async (args) => {
+		try {
+			return ok({ items: (await wiki.getTree({
+				...args,
+				parent: args.parent ?? 0
+			})).map((i) => ({
+				...i,
+				pageId: i.pageId ?? null,
+				parent: i.parent ?? null
+			})) });
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+	server.registerTool("list_tags", {
+		title: "List tags",
+		description: "List all page tags, or search tags matching a query string.",
+		inputSchema: { query: z.string().optional().describe("If set, search tags matching this text") },
+		outputSchema: { tags: z.array(z.object({
+			tag: z.string(),
+			title: z.string().nullable()
+		})) }
+	}, instrument(logger, "list_tags", async (args) => {
+		try {
+			if (args.query) return ok({ tags: (await wiki.searchTags(args.query)).map((t) => ({
+				tag: t,
+				title: null
+			})) });
+			return ok({ tags: (await wiki.listTags()).map((t) => ({
+				tag: t.tag,
+				title: t.title ?? null
+			})) });
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+}
+//#endregion
+//#region src/tools/pages.ts
+const pageRefShape = {
+	id: z.number(),
+	path: z.string(),
+	locale: z.string(),
+	title: z.string()
+};
+function registerPageTools(server, wiki, logger) {
+	server.registerTool("create_page", {
+		title: "Create page",
+		description: "Create a new Wiki.js page. Path must not start with the locale (use \"guides/install\", not \"en/guides/install\").",
+		inputSchema: {
+			path: z.string().min(1).describe("Page path, e.g. \"guides/install\""),
+			title: z.string().min(1),
+			content: z.string().min(1).describe("Page content (markdown by default)"),
+			description: z.string().default("").describe("Short page description"),
+			editor: z.string().default("markdown").describe("Editor type: markdown, ckeditor, code"),
+			locale: z.string().default("en"),
+			isPublished: z.boolean().default(true),
+			isPrivate: z.boolean().default(false),
+			tags: z.array(z.string()).default([])
+		},
+		outputSchema: {
+			succeeded: z.literal(true),
+			page: z.object(pageRefShape)
+		}
+	}, instrument(logger, "create_page", async (args) => {
+		try {
+			const page = await wiki.createPage(args);
+			return ok({
+				succeeded: true,
+				page
+			}, `Created page ${page.id} at ${page.locale}/${page.path}`);
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+	server.registerTool("update_page", {
+		title: "Update page",
+		description: "Update an existing page by id. Only the provided fields change. Get the id from get_page, list_pages or search_pages first.",
+		inputSchema: {
+			id: z.number().int().describe("Page id"),
+			content: z.string().optional(),
+			title: z.string().optional(),
+			description: z.string().optional(),
+			isPublished: z.boolean().optional(),
+			isPrivate: z.boolean().optional(),
+			tags: z.array(z.string()).optional().describe("Replaces the whole tag list")
+		},
+		outputSchema: {
+			succeeded: z.literal(true),
+			page: z.object(pageRefShape)
+		}
+	}, instrument(logger, "update_page", async (args) => {
+		try {
+			const page = await wiki.updatePage(args);
+			return ok({
+				succeeded: true,
+				page
+			}, `Updated page ${page.id} at ${page.locale}/${page.path}`);
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+	server.registerTool("move_page", {
+		title: "Move / rename page",
+		description: "Move a page to a new path (and optionally another locale). Requires the manage:pages permission on the API key.",
+		inputSchema: {
+			id: z.number().int().describe("Page id"),
+			destinationPath: z.string().min(1),
+			destinationLocale: z.string().default("en")
+		},
+		outputSchema: {
+			succeeded: z.literal(true),
+			id: z.number(),
+			destinationPath: z.string(),
+			destinationLocale: z.string()
+		}
+	}, instrument(logger, "move_page", async (args) => {
+		try {
+			await wiki.movePage(args.id, args.destinationPath, args.destinationLocale);
+			return ok({
+				succeeded: true,
+				id: args.id,
+				destinationPath: args.destinationPath,
+				destinationLocale: args.destinationLocale
+			}, `Moved page ${args.id} to ${args.destinationLocale}/${args.destinationPath}`);
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+	server.registerTool("delete_page", {
+		title: "Delete page",
+		description: "Permanently delete a page by id. DESTRUCTIVE and irreversible — confirm with the user before calling this.",
+		inputSchema: { id: z.number().int().describe("Page id to delete") },
+		outputSchema: {
+			succeeded: z.literal(true),
+			id: z.number()
+		}
+	}, instrument(logger, "delete_page", async (args) => {
+		try {
+			await wiki.deletePage(args.id);
+			return ok({
+				succeeded: true,
+				id: args.id
+			}, `Deleted page ${args.id}`);
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+}
+//#endregion
+//#region src/tools/history.ts
+function registerHistoryTools(server, wiki, logger) {
+	server.registerTool("get_page_history", {
+		title: "Get page history",
+		description: "List the version history trail of a page (newest first), paginated.",
+		inputSchema: {
+			id: z.number().int().describe("Page id"),
+			offsetPage: z.number().int().min(0).default(0).describe("Zero-based page of the trail"),
+			offsetSize: z.number().int().min(1).max(100).default(25).describe("Entries per page")
+		},
+		outputSchema: {
+			trail: z.array(z.object({
+				versionId: z.number(),
+				versionDate: z.string(),
+				authorId: z.number(),
+				authorName: z.string(),
+				actionType: z.string(),
+				valueBefore: z.string().nullable(),
+				valueAfter: z.string().nullable()
+			})),
+			total: z.number()
+		}
+	}, instrument(logger, "get_page_history", async (args) => {
+		try {
+			const history = await wiki.getHistory(args.id, args.offsetPage, args.offsetSize);
+			return ok({
+				trail: history.trail.map((e) => ({
+					...e,
+					valueBefore: e.valueBefore ?? null,
+					valueAfter: e.valueAfter ?? null
+				})),
+				total: history.total
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+	server.registerTool("get_page_version", {
+		title: "Get page version",
+		description: "Fetch the content of a specific historical version of a page. Optionally slice its content by line range with startLine/endLine: 0-based, inclusive on both ends. Default (0..-1) returns the whole version content. Negative values count from the end, Python-style (-1 = last line, -2 = second-to-last).",
+		inputSchema: {
+			pageId: z.number().int(),
+			versionId: z.number().int().describe("From get_page_history trail"),
+			startLine: z.number().int().default(0).describe("0-based start line, inclusive. Negative counts from the end."),
+			endLine: z.number().int().default(-1).describe("0-based end line, inclusive. -1 (default) means the last line.")
+		},
+		outputSchema: {
+			version: z.object({
+				versionId: z.number(),
+				versionDate: z.string(),
+				action: z.string(),
+				authorName: z.string(),
+				pageId: z.number(),
+				path: z.string(),
+				locale: z.string(),
+				title: z.string(),
+				description: z.string(),
+				content: z.string(),
+				contentType: z.string(),
+				editor: z.string(),
+				isPublished: z.boolean(),
+				tags: z.array(z.string()),
+				createdAt: z.string()
+			}),
+			totalLines: z.number(),
+			startLine: z.number(),
+			endLine: z.number()
+		}
+	}, instrument(logger, "get_page_version", async (args) => {
+		try {
+			const version = await wiki.getVersion(args.pageId, args.versionId);
+			const sliced = sliceLines(version.content, args.startLine, args.endLine);
+			return ok({
+				version: {
+					...version,
+					content: sliced.content
+				},
+				totalLines: sliced.totalLines,
+				startLine: sliced.startLine,
+				endLine: sliced.endLine
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+	server.registerTool("restore_page_version", {
+		title: "Restore page version",
+		description: "Restore a page to a previous version from its history. The current state is preserved as a new history entry.",
+		inputSchema: {
+			pageId: z.number().int(),
+			versionId: z.number().int().describe("Version to restore, from get_page_history")
+		},
+		outputSchema: {
+			succeeded: z.literal(true),
+			pageId: z.number(),
+			versionId: z.number()
+		}
+	}, instrument(logger, "restore_page_version", async (args) => {
+		try {
+			await wiki.restoreVersion(args.pageId, args.versionId);
+			return ok({
+				succeeded: true,
+				pageId: args.pageId,
+				versionId: args.versionId
+			}, `Restored page ${args.pageId} to version ${args.versionId}`);
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+}
+//#endregion
+//#region src/tools/assets.ts
+function registerAssetTools(server, wiki, logger) {
+	server.registerTool("list_assets", {
+		title: "List assets",
+		description: "List uploaded assets (images/files) and subfolders in an asset folder. folderId 0 is the root folder.",
+		inputSchema: {
+			folderId: z.number().int().min(0).default(0),
+			kind: z.enum([
+				"IMAGE",
+				"BINARY",
+				"ALL"
+			]).default("ALL")
+		},
+		outputSchema: {
+			folders: z.array(z.object({
+				id: z.number(),
+				slug: z.string(),
+				name: z.string().nullable()
+			})),
+			assets: z.array(z.object({
+				id: z.number(),
+				filename: z.string(),
+				ext: z.string(),
+				kind: z.string(),
+				mime: z.string(),
+				fileSize: z.number(),
+				createdAt: z.string(),
+				updatedAt: z.string()
+			}))
+		}
+	}, instrument(logger, "list_assets", async (args) => {
+		try {
+			const [folders, assets] = await Promise.all([wiki.listAssetFolders(args.folderId), wiki.listAssets(args.folderId, args.kind)]);
+			return ok({
+				folders: folders.map((f) => ({
+					...f,
+					name: f.name ?? null
+				})),
+				assets
+			});
+		} catch (err) {
+			return fail(err);
+		}
+	}));
+}
+//#endregion
+//#region src/server.ts
+const VERSION = version;
+function buildServer(config, logger) {
+	const wiki = new WikiJsClient(new GraphQLClient({
+		baseUrl: config.wikijsUrl,
+		token: config.wikijsToken
+	}));
+	const server = new McpServer({
+		name: "wikijs-mcp",
+		version: VERSION
+	});
+	registerDiscoveryTools(server, wiki, logger);
+	registerPageTools(server, wiki, logger);
+	registerHistoryTools(server, wiki, logger);
+	registerAssetTools(server, wiki, logger);
+	logger.debug("MCP server built");
+	return server;
+}
+async function probeConnection(config, logger) {
+	const wiki = new WikiJsClient(new GraphQLClient({
+		baseUrl: config.wikijsUrl,
+		token: config.wikijsToken,
+		timeoutMs: 1e4
+	}));
+	try {
+		await wiki.listPages({ limit: 1 });
+		logger.info({ url: config.wikijsUrl }, "Connected to Wiki.js");
+	} catch (err) {
+		logger.warn({
+			url: config.wikijsUrl,
+			err: err.message
+		}, "Wiki.js connectivity check failed — starting anyway");
+	}
+}
+//#endregion
+//#region src/index.ts
+async function main() {
+	const config = loadConfig();
+	const logger = createLogger(config.logLevel);
+	await probeConnection(config, logger);
+	if (config.transport === "http") {
+		const { startHttpServer } = await import("./http-D7MoxUTD.js");
+		startHttpServer(config, logger);
+		return;
+	}
+	await buildServer(config, logger).connect(new StdioServerTransport());
+	logger.info("wikijs-mcp listening on stdio");
+}
+main().catch((err) => {
+	console.error(err instanceof Error ? err.message : String(err));
+	process.exit(1);
+});
+//#endregion
+export { buildServer as t };
+
+//# sourceMappingURL=index.js.map