@fswap/mcp-outline 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gleb Okhrimenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# @fswap/mcp-outline
+
+An [MCP](https://modelcontextprotocol.io) server for [Outline](https://www.getoutline.com) that lets Claude Desktop, Claude Code, Cursor and other MCP clients search, read, create and update your wiki.
+
+Runs locally over stdio. No install step — clients launch it with `npx`.
+
+## Quick start
+
+1. Create an API token in Outline under **Settings → API**.
+2. Run the interactive setup once:
+
+   ```bash
+   npx -y @fswap/mcp-outline setup
+   ```
+
+   It asks for your Outline URL and token, verifies them against `auth.info`, and stores them in your OS config directory (mode `0600`).
+
+3. Add the server to your client. Every value asked in `setup` can be skipped with Enter; anything you skip goes into the `env` block shown below instead. `setup --print` shows these snippets again at any time.
+
+   **Claude Desktop** (`claude_desktop_config.json`) and **Cursor** (`~/.cursor/mcp.json` or `<project>/.cursor/mcp.json`):
+
+   ```json
+   {
+     "mcpServers": {
+       "outline": {
+         "command": "npx",
+         "args": ["-y", "@fswap/mcp-outline"]
+       }
+     }
+   }
+   ```
+
+   **Codex** (`~/.codex/config.toml`):
+
+   ```toml
+   [mcp_servers.outline]
+   command = "npx"
+   args = ["-y", "@fswap/mcp-outline"]
+   ```
+
+   **Claude Code**:
+
+   ```bash
+   claude mcp add outline -- npx -y @fswap/mcp-outline
+   ```
+
+### Without `setup` (environment variables)
+
+Environment variables take precedence over the config file, so you can skip `setup` entirely (or skip individual values in it and set them here):
+
+```json
+{
+  "mcpServers": {
+    "outline": {
+      "command": "npx",
+      "args": ["-y", "@fswap/mcp-outline"],
+      "env": {
+        "OUTLINE_URL": "https://app.getoutline.com",
+        "OUTLINE_API_TOKEN": "ol_api_..."
+      }
+    }
+  }
+}
+```
+
+Codex equivalent:
+
+```toml
+[mcp_servers.outline]
+command = "npx"
+args = ["-y", "@fswap/mcp-outline"]
+[mcp_servers.outline.env]
+OUTLINE_URL = "https://app.getoutline.com"
+OUTLINE_API_TOKEN = "ol_api_..."
+```
+
+| Variable | Purpose |
+|---|---|
+| `OUTLINE_URL` | Outline base URL (cloud or self-hosted) |
+| `OUTLINE_API_TOKEN` | API token |
+| `OUTLINE_ALLOW_DELETE` | `true` to expose `delete_document` |
+| `OUTLINE_DEFAULT_COLLECTION` | Optional default collection name |
+
+## Tools
+
+| Tool | Outline endpoint | Notes |
+|---|---|---|
+| `list_collections` | `collections.list` | id, name, description, url |
+| `get_collection` | `collections.info` | includes document tree |
+| `search_documents` | `documents.search` | query, optional `collectionId`; returns snippets, not bodies |
+| `get_document` | `documents.info` | full markdown body; accepts id or URL slug |
+| `list_documents` | `documents.list` | filter by `collectionId` / `parentDocumentId` |
+| `create_document` | `documents.create` | title, markdown, collection, optional parent; published by default |
+| `update_document` | `documents.update` | title/text; `append=true` appends instead of replacing |
+| `move_document` | `documents.move` | change collection and/or parent |
+| `archive_document` | `documents.archive` | reversible |
+| `delete_document` | `documents.delete` | only when delete is allowed (setup answer or `OUTLINE_ALLOW_DELETE=true`) |
+
+API errors are returned to the model as `isError` results rather than crashing the server.
+
+## Development
+
+TypeScript source in `src/`, bundled to `dist/` with [tsdown](https://tsdown.dev). Only `dist/` is published.
+
+```bash
+npm install
+npm run build        # tsdown → dist/index.js
+npm run lint         # eslint (typescript-eslint)
+npm run typecheck    # tsc --noEmit
+npm test             # builds, then spawns the server and checks the tool list
+npm run check        # all of the above (also runs on prepublishOnly)
+OUTLINE_URL=... OUTLINE_API_TOKEN=... npm run inspect   # MCP Inspector UI against dist/
+```
+
+Never write to stdout from server code — it is the protocol channel. Use `console.error`.
+
+## Reset
+
+```bash
+npx -y @fswap/mcp-outline setup --reset
+```
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,556 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import fs from "node:fs";
+import path from "node:path";
+import envPaths from "env-paths";
+import { z } from "zod";
+import * as p from "@clack/prompts";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/config.ts
+function configPath() {
+	return path.join(paths.config, "config.json");
+}
+function truthy(v) {
+	return v != null && /^(1|true|yes|on)$/i.test(v.trim());
+}
+function readConfigFile() {
+	try {
+		return JSON.parse(fs.readFileSync(configPath(), "utf8"));
+	} catch (err) {
+		if (err.code === "ENOENT") return null;
+		console.error(`Warning: could not read ${configPath()}: ${err.message}`);
+		return null;
+	}
+}
+/**
+* Resolve runtime configuration.
+* Precedence: environment variables > config file written by `setup`.
+* Returns null when neither provides url + token.
+*/
+function loadConfig() {
+	const env = process.env;
+	const file = readConfigFile() ?? {};
+	const url = env.OUTLINE_URL || file.url;
+	const token = env.OUTLINE_API_TOKEN || file.token;
+	if (!url || !token) return null;
+	const deleteEnv = env.OUTLINE_ALLOW_DELETE ?? env.ALLOW_DELETE;
+	const allowDelete = deleteEnv != null ? truthy(deleteEnv) : Boolean(file.allowDelete);
+	return {
+		url: url.replace(/\/+$/, ""),
+		token,
+		allowDelete,
+		defaultCollection: env.OUTLINE_DEFAULT_COLLECTION || file.defaultCollection || ""
+	};
+}
+function saveConfig(config) {
+	const file = configPath();
+	fs.mkdirSync(path.dirname(file), {
+		recursive: true,
+		mode: 448
+	});
+	fs.writeFileSync(file, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+	fs.chmodSync(file, 384);
+	return file;
+}
+function deleteConfig() {
+	try {
+		fs.unlinkSync(configPath());
+		return true;
+	} catch (err) {
+		if (err.code === "ENOENT") return false;
+		throw err;
+	}
+}
+var pkg, PACKAGE_NAME, VERSION, paths;
+var init_config = __esmMin((() => {
+	pkg = createRequire(import.meta.url)("../package.json");
+	PACKAGE_NAME = pkg.name;
+	VERSION = pkg.version;
+	paths = envPaths("mcp-outline", { suffix: "" });
+}));
+//#endregion
+//#region src/client.ts
+function makeClient(baseUrl, token) {
+	const base = baseUrl.replace(/\/+$/, "");
+	async function post(endpoint, body = {}) {
+		const url = `${base}/api/${endpoint}`;
+		let res;
+		try {
+			res = await fetch(url, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${token}`,
+					"Content-Type": "application/json",
+					Accept: "application/json"
+				},
+				body: JSON.stringify(body)
+			});
+		} catch (err) {
+			throw new Error(`POST ${endpoint} failed: ${err.message}`);
+		}
+		if (!res.ok) {
+			const text = await res.text();
+			let detail = text;
+			try {
+				const json = JSON.parse(text);
+				detail = json.message || json.error || text;
+			} catch {}
+			throw new Error(`POST ${endpoint} → ${res.status}: ${detail}`);
+		}
+		return await res.json();
+	}
+	return {
+		post,
+		baseUrl: base
+	};
+}
+/** Cheap authenticated call used by `setup` to validate URL + token. */
+async function authInfo(baseUrl, token) {
+	const { post } = makeClient(baseUrl, token);
+	const { data } = await post("auth.info");
+	return data;
+}
+var init_client = __esmMin((() => {}));
+//#endregion
+//#region src/tools/_shared.ts
+init_config();
+init_client();
+function ok(value) {
+	return { content: [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}] };
+}
+function fail(err) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: `Error: ${err instanceof Error ? err.message : String(err)}`
+		}]
+	};
+}
+/** Wrap a tool handler so API errors become isError results instead of crashes. */
+function guard(fn) {
+	return async (args) => {
+		try {
+			return await fn(args);
+		} catch (err) {
+			return fail(err);
+		}
+	};
+}
+function stripUndefined(obj) {
+	return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+//#endregion
+//#region src/tools/collections.ts
+function registerCollectionTools(server, outline) {
+	server.registerTool("list_collections", {
+		title: "List collections",
+		description: "List Outline collections (top-level groupings of documents). Returns id, name, description and url. Use the id with search_documents, list_documents or create_document.",
+		inputSchema: {
+			query: z.string().optional().describe("Filter collections by name (substring match)"),
+			limit: z.number().int().min(1).max(100).default(25).describe("Max collections to return")
+		}
+	}, guard(async ({ query, limit }) => {
+		const body = {
+			limit,
+			sort: "name",
+			direction: "ASC"
+		};
+		if (query) body.query = query;
+		const { data } = await outline.post("collections.list", body);
+		return ok(data.map((c) => ({
+			id: c.id,
+			name: c.name,
+			description: c.description || null,
+			url: c.url
+		})));
+	}));
+	server.registerTool("get_collection", {
+		title: "Get collection",
+		description: "Get one Outline collection including its document tree (ids, titles and nesting). Useful to understand how a collection is organised before creating or moving documents.",
+		inputSchema: { id: z.string().describe("Collection id") }
+	}, guard(async ({ id }) => {
+		const { data } = await outline.post("collections.info", { id });
+		return ok({
+			id: data.id,
+			name: data.name,
+			description: data.description || null,
+			url: data.url,
+			documents: data.documents ?? []
+		});
+	}));
+}
+//#endregion
+//#region src/tools/documents.ts
+function summarize(d) {
+	return {
+		id: d.id,
+		title: d.title,
+		url: d.url,
+		urlId: d.urlId,
+		collectionId: d.collectionId,
+		parentDocumentId: d.parentDocumentId ?? null,
+		updatedAt: d.updatedAt,
+		publishedAt: d.publishedAt ?? null,
+		archivedAt: d.archivedAt ?? null
+	};
+}
+function registerDocumentTools(server, outline, { allowDelete = false } = {}) {
+	server.registerTool("search_documents", {
+		title: "Search documents",
+		description: "Full-text search across Outline documents. Returns id, title, url and a short context snippet per hit. Does NOT return document bodies — call get_document with an id to read one.",
+		inputSchema: {
+			query: z.string().min(1).describe("Search terms"),
+			collectionId: z.string().optional().describe("Restrict results to one collection"),
+			limit: z.number().int().min(1).max(50).default(10).describe("Max results"),
+			offset: z.number().int().min(0).default(0).describe("Pagination offset")
+		}
+	}, guard(async ({ query, collectionId, limit, offset }) => {
+		const { data } = await outline.post("documents.search", stripUndefined({
+			query,
+			collectionId,
+			limit,
+			offset
+		}));
+		return ok(data.map((r) => ({
+			id: r.document.id,
+			title: r.document.title,
+			url: r.document.url,
+			collectionId: r.document.collectionId,
+			updatedAt: r.document.updatedAt,
+			snippet: r.context,
+			ranking: r.ranking
+		})));
+	}));
+	server.registerTool("get_document", {
+		title: "Get document",
+		description: "Fetch a single Outline document including its full markdown body. Accepts a document id, a urlId (the slug part of the URL) or a share id.",
+		inputSchema: { id: z.string().describe("Document id, urlId or share id") }
+	}, guard(async ({ id }) => {
+		const { data } = await outline.post("documents.info", { id });
+		return ok({
+			...summarize(data),
+			text: data.text ?? ""
+		});
+	}));
+	server.registerTool("list_documents", {
+		title: "List documents",
+		description: "List documents, optionally filtered by collection and/or parent document. Returns id, title, url and timestamps (no bodies). Sorted by most recently updated by default.",
+		inputSchema: {
+			collectionId: z.string().optional().describe("Only documents in this collection"),
+			parentDocumentId: z.string().optional().describe("Only direct children of this document"),
+			sort: z.enum([
+				"updatedAt",
+				"createdAt",
+				"title",
+				"index"
+			]).default("updatedAt"),
+			direction: z.enum(["ASC", "DESC"]).default("DESC"),
+			limit: z.number().int().min(1).max(100).default(25),
+			offset: z.number().int().min(0).default(0)
+		}
+	}, guard(async ({ collectionId, parentDocumentId, sort, direction, limit, offset }) => {
+		const { data } = await outline.post("documents.list", stripUndefined({
+			collectionId,
+			parentDocumentId,
+			sort,
+			direction,
+			limit,
+			offset
+		}));
+		return ok(data.map(summarize));
+	}));
+	server.registerTool("create_document", {
+		title: "Create document",
+		description: "Create a new Outline document from markdown. Published by default; pass publish=false to save a draft. Requires a collectionId (use list_collections). Optionally nest under a parent document.",
+		inputSchema: {
+			title: z.string().min(1).describe("Document title"),
+			text: z.string().default("").describe("Document body in markdown"),
+			collectionId: z.string().describe("Collection to create the document in"),
+			parentDocumentId: z.string().optional().describe("Nest under this document"),
+			publish: z.boolean().default(true).describe("Publish immediately (false = draft)")
+		}
+	}, guard(async ({ title, text, collectionId, parentDocumentId, publish }) => {
+		const { data } = await outline.post("documents.create", stripUndefined({
+			title,
+			text,
+			collectionId,
+			parentDocumentId,
+			publish
+		}));
+		return ok(summarize(data));
+	}));
+	server.registerTool("update_document", {
+		title: "Update document",
+		description: "Update an existing document's title and/or markdown body. By default `text` REPLACES the body; set append=true to add `text` to the end instead. Only the fields you pass are changed.",
+		inputSchema: {
+			id: z.string().describe("Document id"),
+			title: z.string().optional().describe("New title"),
+			text: z.string().optional().describe("New markdown body (or text to append when append=true)"),
+			append: z.boolean().default(false).describe("Append `text` to the existing body instead of replacing it"),
+			publish: z.boolean().optional().describe("Publish a draft as part of this update"),
+			done: z.boolean().optional().describe("Mark the editing session as finished (triggers notifications)")
+		}
+	}, guard(async ({ id, title, text, append, publish, done }) => {
+		if (title === void 0 && text === void 0 && publish === void 0) throw new Error("Nothing to update: pass title, text or publish.");
+		const { data } = await outline.post("documents.update", stripUndefined({
+			id,
+			title,
+			text,
+			append: text !== void 0 ? append : void 0,
+			publish,
+			done
+		}));
+		return ok(summarize(data));
+	}));
+	server.registerTool("move_document", {
+		title: "Move document",
+		description: "Move a document to another collection and/or under a different parent document. Omit parentDocumentId to move it to the top level of the collection.",
+		inputSchema: {
+			id: z.string().describe("Document id"),
+			collectionId: z.string().optional().describe("Target collection id"),
+			parentDocumentId: z.string().optional().describe("Target parent document id"),
+			index: z.number().int().min(0).optional().describe("Position among siblings")
+		}
+	}, guard(async ({ id, collectionId, parentDocumentId, index }) => {
+		if (!collectionId && !parentDocumentId) throw new Error("Pass collectionId and/or parentDocumentId.");
+		const { data } = await outline.post("documents.move", stripUndefined({
+			id,
+			collectionId,
+			parentDocumentId,
+			index
+		}));
+		return ok({ documents: (data.documents ?? []).map(summarize) });
+	}));
+	server.registerTool("archive_document", {
+		title: "Archive document",
+		description: "Archive a document (reversible; it disappears from the collection but can be restored from the archive). Prefer this over delete_document.",
+		inputSchema: { id: z.string().describe("Document id") }
+	}, guard(async ({ id }) => {
+		const { data } = await outline.post("documents.archive", { id });
+		return ok(summarize(data));
+	}));
+	if (allowDelete) server.registerTool("delete_document", {
+		title: "Delete document",
+		description: "Move a document to the trash. Documents in the trash are permanently deleted after 30 days. Only use when the user explicitly asks to delete; archive_document is the safer alternative.",
+		inputSchema: {
+			id: z.string().describe("Document id"),
+			permanent: z.boolean().default(false).describe("Permanently delete instead of trashing (irreversible)")
+		}
+	}, guard(async ({ id, permanent }) => {
+		await outline.post("documents.delete", {
+			id,
+			permanent
+		});
+		return ok({
+			deleted: id,
+			permanent
+		});
+	}));
+}
+//#endregion
+//#region src/snippets.ts
+function jsonSnippet(missing) {
+	const server = {
+		command: "npx",
+		args: ["-y", PACKAGE_NAME]
+	};
+	if (Object.keys(missing).length > 0) server.env = missing;
+	return JSON.stringify({ mcpServers: { [SERVER_KEY]: server } }, null, 2);
+}
+function tomlSnippet(missing) {
+	const lines = [
+		`[mcp_servers.${SERVER_KEY}]`,
+		"command = \"npx\"",
+		`args = ["-y", "${PACKAGE_NAME}"]`
+	];
+	if (Object.keys(missing).length > 0) {
+		lines.push(`[mcp_servers.${SERVER_KEY}.env]`);
+		for (const [k, v] of Object.entries(missing)) lines.push(`${k} = "${v}"`);
+	}
+	return lines.join("\n");
+}
+function claudeCodeSnippet(missing) {
+	const env = Object.entries(missing).map(([k, v]) => `-e ${k}=${v} `).join("");
+	return `claude mcp add ${SERVER_KEY} ${env}-- npx -y ${PACKAGE_NAME}`;
+}
+function clientSnippets(missing = {}) {
+	return [
+		{
+			title: "Claude Desktop — claude_desktop_config.json",
+			body: jsonSnippet(missing)
+		},
+		{
+			title: "Cursor — ~/.cursor/mcp.json (or <project>/.cursor/mcp.json)",
+			body: jsonSnippet(missing)
+		},
+		{
+			title: "Codex — ~/.codex/config.toml",
+			body: tomlSnippet(missing)
+		},
+		{
+			title: "Claude Code",
+			body: claudeCodeSnippet(missing)
+		}
+	];
+}
+var SERVER_KEY, ENV_URL, ENV_TOKEN;
+var init_snippets = __esmMin((() => {
+	SERVER_KEY = "outline";
+	ENV_URL = "OUTLINE_URL";
+	ENV_TOKEN = "OUTLINE_API_TOKEN";
+}));
+//#endregion
+//#region src/setup.ts
+var setup_exports = /* @__PURE__ */ __exportAll({ runSetup: () => runSetup });
+function abort() {
+	p.cancel("Setup aborted.");
+	process.exit(1);
+}
+function printSnippets(missing) {
+	for (const s of clientSnippets(missing)) p.note(s.body, s.title);
+}
+async function runSetup(args = []) {
+	if (args.includes("--reset")) {
+		const removed = deleteConfig();
+		console.log(removed ? `Removed ${configPath()}` : `Nothing to remove (${configPath()} does not exist)`);
+		return;
+	}
+	const existing = readConfigFile() ?? {};
+	if (args.includes("--print")) {
+		const missing = {};
+		if (!existing.url) missing[ENV_URL] = "https://app.getoutline.com";
+		if (!existing.token) missing[ENV_TOKEN] = "ol_api_...";
+		printSnippets(missing);
+		return;
+	}
+	p.intro(`${PACKAGE_NAME} setup`);
+	p.log.info("Press Enter to skip any value. Skipped values can be supplied later via the env block of your MCP client config.");
+	const answers = await p.group({
+		url: () => p.text({
+			message: `Outline URL (${ENV_URL})`,
+			placeholder: "https://app.getoutline.com  — Enter to skip",
+			initialValue: existing.url ?? "",
+			validate: (v) => !v || /^https?:\/\/\S+$/.test(v) ? void 0 : "Must start with http:// or https://"
+		}),
+		token: () => p.password({
+			message: `API token (${ENV_TOKEN}; Settings → API in Outline) — Enter to skip`,
+			mask: "▪"
+		}),
+		defaultCollection: () => p.text({
+			message: "Default collection name (optional)",
+			initialValue: existing.defaultCollection ?? "",
+			defaultValue: ""
+		}),
+		allowDelete: () => p.confirm({
+			message: "Allow delete tools?",
+			initialValue: Boolean(existing.allowDelete)
+		})
+	}, { onCancel: abort });
+	const url = (answers.url ?? "").trim().replace(/\/+$/, "") || void 0;
+	const token = (answers.token ?? "").trim() || existing.token || void 0;
+	if (url && token) {
+		const s = p.spinner();
+		s.start("Checking connection");
+		try {
+			const me = await authInfo(url, token);
+			const who = me.user?.email ?? me.user?.name ?? "unknown user";
+			s.stop(`ok (logged in as ${who} on ${me.team?.name ?? url})`);
+		} catch (err) {
+			s.stop("failed");
+			p.cancel(`Could not authenticate: ${err.message}`);
+			process.exit(1);
+		}
+	} else p.log.warn("Skipping connection check because URL and/or token were not provided.");
+	const config = {
+		defaultCollection: (answers.defaultCollection ?? "").trim(),
+		allowDelete: Boolean(answers.allowDelete)
+	};
+	if (url) config.url = url;
+	if (token) config.token = token;
+	const file = saveConfig(config);
+	const missing = {};
+	if (!url) missing[ENV_URL] = "https://app.getoutline.com";
+	if (!token) missing[ENV_TOKEN] = "ol_api_...";
+	if (Object.keys(missing).length > 0) p.log.warn(`Still needed: ${Object.keys(missing).join(", ")}. Add them to the env block below, or run setup again.`);
+	printSnippets(missing);
+	p.outro(`Saved to ${file}`);
+}
+var init_setup = __esmMin((() => {
+	init_config();
+	init_snippets();
+}));
+//#endregion
+//#region src/index.ts
+init_config();
+init_client();
+const [cmd, ...rest] = process.argv.slice(2);
+if (cmd === "setup") {
+	const { runSetup } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+	await runSetup(rest);
+} else if (cmd === "--help" || cmd === "-h" || cmd === "help") printHelp();
+else if (cmd === "--version" || cmd === "-v") console.log(VERSION);
+else await runServer();
+function printHelp() {
+	console.log(`${PACKAGE_NAME} ${VERSION}
+
+Usage:
+  npx ${PACKAGE_NAME}                 start the MCP server (stdio)
+  npx ${PACKAGE_NAME} setup           interactive configuration
+  npx ${PACKAGE_NAME} setup --reset   delete stored configuration
+  npx ${PACKAGE_NAME} setup --print   print MCP client config snippets
+
+Configuration precedence:
+  1. OUTLINE_URL, OUTLINE_API_TOKEN, OUTLINE_ALLOW_DELETE env vars
+  2. ${configPath()}
+`);
+}
+async function runServer() {
+	const config = loadConfig();
+	if (!config) {
+		console.error(`No configuration found. Run: npx ${PACKAGE_NAME} setup`);
+		console.error("(or set OUTLINE_URL and OUTLINE_API_TOKEN in the environment)");
+		process.exit(1);
+	}
+	if (process.stdin.isTTY) {
+		console.error(`${PACKAGE_NAME} is an MCP stdio server and expects to be launched by an MCP client.`);
+		console.error(`Run "npx ${PACKAGE_NAME} setup" to configure it, or "npx ${PACKAGE_NAME} --help".`);
+		process.exit(1);
+	}
+	const outline = makeClient(config.url, config.token);
+	const server = new McpServer({
+		name: "mcp-outline",
+		version: VERSION
+	});
+	registerCollectionTools(server, outline);
+	registerDocumentTools(server, outline, { allowDelete: config.allowDelete });
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	console.error(`mcp-outline ${VERSION} connected (${config.url}, delete tools ${config.allowDelete ? "enabled" : "disabled"})`);
+}
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@fswap/mcp-outline",
+  "version": "0.1.0",
+  "description": "MCP server for Outline (getoutline.com) — search, read, create and update wiki documents from Claude",
+  "type": "module",
+  "bin": {
+    "mcp-outline": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src test",
+    "test": "npm run build && node test/smoke.test.mjs",
+    "check": "npm run lint && npm run typecheck && npm test",
+    "start": "node dist/index.js",
+    "setup": "node dist/index.js setup",
+    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
+    "prepublishOnly": "npm run check"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "env-paths": "^4.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "eslint": "^10.0.0",
+    "tsdown": "^0.23.0",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.70.0"
+  },
+  "keywords": [
+    "mcp",
+    "outline",
+    "getoutline",
+    "wiki",
+    "claude",
+    "modelcontextprotocol"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sunblob/mcp-outline.git"
+  },
+  "homepage": "https://github.com/sunblob/mcp-outline#readme",
+  "bugs": {
+    "url": "https://github.com/sunblob/mcp-outline/issues"
+  }
+}