@gesslar/mediawiki-mcp 1.0.0

package/.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "daily"
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "daily"

package/.github/workflows/Quality.yaml

@@ -0,0 +1,21 @@
+name: Quality
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: "20 14 * * 1"
+
+jobs:
+  Quality:
+    permissions:
+      contents: read
+    uses: gesslar/Maint/.github/workflows/Quality.yaml@main
+    secrets: inherit
+    with:
+      package_manager: "auto"
+      perform_linting: "${{ vars.PERFORM_LINTING || 'yes' }}"
+      perform_testing: "${{ vars.PERFORM_TESTING || 'no' }}"

package/.github/workflows/Release.yaml

@@ -0,0 +1,17 @@
+name: Release
+
+on:
+  pull_request:
+    types: [closed]
+    branches: [main]
+
+jobs:
+  Release:
+    if: github.event.pull_request.merged == true
+    uses: gesslar/Maint/.github/workflows/Release.yaml@main
+    secrets: inherit
+    with:
+      package_manager: "auto"
+      quality_check: "Quality"
+    permissions:
+      contents: write

package/LICENSE.txt

@@ -0,0 +1,12 @@
+Copyright (C) 2026 by Brian M. Workman bmw@gesslar.dev
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+# @gesslar/mediawiki-mcp
+
+A [Model Context Protocol](https://modelcontextprotocol.io/) server that lets
+MCP-compatible clients create, edit, delete, read, and search articles on a
+MediaWiki instance.
+
+## Requirements
+
+- Node.js `>=24.11.0`
+- A MediaWiki instance with API access
+- A [bot account](https://www.mediawiki.org/wiki/Manual:Bot_passwords) with
+  sufficient permissions for the operations you intend to perform
+
+## Installation
+
+```bash
+npm install -g @gesslar/mediawiki-mcp
+```
+
+Or run it directly via `npx`:
+
+```bash
+npx @gesslar/mediawiki-mcp
+```
+
+## Configuration
+
+The server is configured through environment variables:
+
+| Variable | Description |
+| --- | --- |
+| `MEDIAWIKI_URL` | Base URL of the MediaWiki instance (e.g. `https://wiki.example.com`) |
+| `MEDIAWIKI_BOT_USERNAME` | Bot account username |
+| `MEDIAWIKI_BOT_PASSWORD` | Bot account password |
+
+All three variables are required. The server will exit on startup if any are
+missing.
+
+> **Note:** The server currently authenticates all reads and writes
+> (`private: true` on the underlying `Wikid` client). This is intentional for
+> wikis that require authentication for read access. If you're pointing this at
+> a fully public wiki, reads will still work — they'll just be authenticated
+> when they wouldn't strictly need to be. This package is released under
+> [0BSD](LICENSE.txt), so if the hardcoded behaviour doesn't suit your setup,
+> you're welcome to fork it and tweak the `Wikid` constructor options to taste.
+
+## Usage with an MCP client
+
+Add the server to your MCP client configuration. For example, in a Claude
+Desktop `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "mediawiki": {
+      "command": "npx",
+      "args": ["-y", "@gesslar/mediawiki-mcp"],
+      "env": {
+        "MEDIAWIKI_URL": "https://wiki.example.com",
+        "MEDIAWIKI_BOT_USERNAME": "YourBot@YourBotPassword",
+        "MEDIAWIKI_BOT_PASSWORD": "your-bot-password"
+      }
+    }
+  }
+}
+```
+
+The server communicates over stdio.
+
+## Tools
+
+The server exposes the following tools:
+
+### `mediawiki_create_article`
+
+Create a new article. Fails if the article already exists.
+
+| Parameter | Type | Required | Description |
+| --- | --- | --- | --- |
+| `title` | string | yes | Title of the article to create |
+| `content` | string | yes | Wikitext content for the article |
+| `summary` | string | no | Edit summary |
+
+### `mediawiki_edit_article`
+
+Edit an existing article. Supports full replacement, append, or prepend.
+
+| Parameter | Type | Required | Description |
+| --- | --- | --- | --- |
+| `title` | string | yes | Title of the article to edit |
+| `content` | string | yes | New wikitext content |
+| `summary` | string | no | Edit summary |
+| `append` | boolean | no | Append `content` instead of replacing |
+| `prepend` | boolean | no | Prepend `content` instead of replacing |
+
+### `mediawiki_delete_article`
+
+Delete an article. Requires delete permissions on the bot account.
+
+| Parameter | Type | Required | Description |
+| --- | --- | --- | --- |
+| `title` | string | yes | Title of the article to delete |
+| `reason` | string | no | Reason for deletion |
+
+### `mediawiki_get_article`
+
+Return the current wikitext content of an article.
+
+| Parameter | Type | Required | Description |
+| --- | --- | --- | --- |
+| `title` | string | yes | Title of the article to retrieve |
+
+### `mediawiki_search`
+
+Search articles on the wiki.
+
+| Parameter | Type | Required | Description |
+| --- | --- | --- | --- |
+| `query` | string | yes | Search query |
+| `limit` | number | no | Maximum number of results (default: 10) |
+
+## Development
+
+```bash
+# Start the server locally
+npm start
+
+# Lint
+npm run lint
+npm run lint:fix
+```
+
+## License
+
+`@gesslar/mediawiki-mcp` is released under the [0BSD](LICENSE.txt).
+
+This package includes or depends on third-party components under their own
+licenses:
+
+| Dependency | License |
+| --- | --- |
+| [@gesslar/wikid](https://github.com/gesslar/wikid) | 0BSD |
+| [@modelcontextprotocol/sdk](https://github.com/modelcontextprotocol/typescript-sdk) | MIT |
+| [zod](https://github.com/colinhacks/zod) | MIT |

package/eslint.config.js

@@ -0,0 +1,11 @@
+import uglify from "@gesslar/uglier"
+
+export default [
+  ...uglify({
+    with: [
+      "lints-js", // default files: ["**/*.{js,mjs,cjs}"]
+      "lints-jsdoc", // default files: ["**/*.{js,mjs,cjs}"]
+      "node", // default files: ["**/*.{js,mjs,cjs}"]
+    ]
+  })
+]

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@gesslar/mediawiki-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Integrating with MediaWiki",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "mediawiki-mcp": "./src/index.js"
+  },
+  "engines": {
+    "node": ">=24.11.0"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "submit": "npm publish --access public --//registry.npmjs.org/:_authToken=\"${NPM_ACCESS_TOKEN}\"",
+    "update": "npx npm-check-updates -u && npm install",
+    "pr": "gt submit --ai -p",
+    "patch": "npm version patch",
+    "minor": "npm version minor",
+    "major": "npm version major"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gesslar/mediawiki-mcp.git"
+  },
+  "keywords": [
+    "wiki",
+    "mediawiki",
+    "mcp",
+    "model-context-protocol",
+    "janet",
+    "jackson",
+    "was",
+    "played"
+  ],
+  "author": "gesslar",
+  "license": "0BSD",
+  "homepage": "https://github.com/gesslar/mediawiki-mcp#readme",
+  "dependencies": {
+    "@gesslar/wikid": "^2.3.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@gesslar/uglier": "^2.4.1",
+    "eslint": "^10.2.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+
+import Wikid from "@gesslar/wikid"
+import {McpServer} from "@modelcontextprotocol/sdk/server/mcp.js"
+import {StdioServerTransport} from "@modelcontextprotocol/sdk/server/stdio.js"
+import * as z from "zod/v4"
+import pkg from "../package.json" with {type: "json"}
+
+class MediaWikiMCPServer {
+  #client
+
+  constructor() {
+    this.server = new McpServer(
+      {
+        name: "mediawiki-mcp-server",
+        version: pkg.version,
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    )
+
+    // Required environment variables
+    this.wikiUrl = process.env.MEDIAWIKI_URL
+    this.botUsername = process.env.MEDIAWIKI_BOT_USERNAME
+    this.botPassword = process.env.MEDIAWIKI_BOT_PASSWORD
+
+    if(!this.wikiUrl || !this.botUsername || !this.botPassword) {
+      console.error("Error: Required environment variables not set:")
+      console.error("  MEDIAWIKI_URL - The base URL of your MediaWiki instance")
+      console.error("  MEDIAWIKI_BOT_USERNAME - Bot account username")
+      console.error("  MEDIAWIKI_BOT_PASSWORD - Bot account password")
+      process.exit(1)
+    }
+
+    // Normalize URL (remove trailing slash)
+    this.wikiUrl = this.wikiUrl.replace(/\/$/, "")
+
+    this.setupTools()
+  }
+
+  /**
+   * Create and authenticate a MediaWiki client
+   *
+   * @returns {Promise<Wikid>} Authenticated client
+   */
+  async #assureClient() {
+    if(!this.#client) {
+      const client = new Wikid({
+        baseUrl: this.wikiUrl,
+        botUsername: this.botUsername,
+        botPassword: this.botPassword,
+        private: true // Your wiki requires auth for reads
+      })
+
+      const loginResult = await client.login()
+
+      if(!loginResult.ok)
+        throw new Error(`Login failed: ${loginResult.error?.message ?? "unknown error"}`)
+
+      this.#client = client
+    }
+
+    return this.#client
+  }
+
+  setupTools() {
+    this.server.registerTool("mediawiki_create_article", {
+      description:
+        "Create a new article on the MediaWiki instance. Will fail if the article already exists.",
+      inputSchema: z.object({
+        title: z.string().describe("Title of the article to create"),
+        content: z.string().describe("Wikitext content for the article"),
+        summary: z.string().optional().describe("Edit summary (reason for creating the article)"),
+      }),
+    }, async({title, content, summary}) => {
+      try {
+        await this.#assureClient()
+
+        const result = await this.#client.post("api.php", {
+          action: "edit",
+          title,
+          text: content,
+          summary: summary || "Created via MediaWiki MCP",
+          createonly: "true",
+          format: "json"
+        })
+
+        if(result.edit?.result !== "Success")
+          throw new Error(`Edit failed: ${JSON.stringify(result)}`)
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `✓ Successfully created article "${title}"\nRevision ID: ${result.edit.newrevid}\nTimestamp: ${result.edit.newtimestamp}`,
+            },
+          ],
+        }
+      } catch(error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`,
+            },
+          ],
+          isError: true,
+        }
+      }
+    })
+
+    this.server.registerTool("mediawiki_edit_article", {
+      description:
+        "Edit an existing article on the MediaWiki instance. Creates the article if it does not already exist.",
+      inputSchema: z.object({
+        title: z.string().describe("Title of the article to edit"),
+        content: z.string().describe("New wikitext content for the article"),
+        summary: z.string().optional().describe("Edit summary (reason for the edit)"),
+        append: z.boolean().optional().describe("If true, append content instead of replacing. Default: false"),
+        prepend: z.boolean().optional().describe("If true, prepend content instead of replacing. Default: false"),
+      }),
+    }, async({title, content, summary, append, prepend}) => {
+      try {
+        await this.#assureClient()
+
+        const editParams = {
+          action: "edit",
+          title,
+          summary: summary || "Edited via MediaWiki MCP",
+          format: "json"
+        }
+
+        if(append)
+          editParams.appendtext = content
+        else if(prepend)
+          editParams.prependtext = content
+        else
+          editParams.text = content
+
+        const result = await this.#client.post("api.php", editParams)
+
+        if(result.edit?.result !== "Success")
+          throw new Error(`Edit failed: ${JSON.stringify(result)}`)
+
+        const action = result.edit.new ? "created" : "edited"
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `✓ Successfully ${action} article "${title}"\nRevision ID: ${result.edit.newrevid}\nTimestamp: ${result.edit.newtimestamp}`,
+            },
+          ],
+        }
+      } catch(error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`,
+            },
+          ],
+          isError: true,
+        }
+      }
+    })
+
+    this.server.registerTool("mediawiki_delete_article", {
+      description:
+        "Delete an article from the MediaWiki instance. Requires appropriate permissions.",
+      inputSchema: z.object({
+        title: z.string().describe("Title of the article to delete"),
+        reason: z.string().optional().describe("Reason for deletion"),
+      }),
+    }, async({title, reason}) => {
+      try {
+        await this.#assureClient()
+
+        const deleteReason = reason || "Deleted via MediaWiki MCP"
+        const result = await this.#client.post("api.php", {
+          action: "delete",
+          title,
+          reason: deleteReason,
+          format: "json"
+        })
+
+        if(!result.delete)
+          throw new Error(`Delete failed: ${JSON.stringify(result)}`)
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `✓ Successfully deleted article "${title}"\nReason: ${deleteReason}`,
+            },
+          ],
+        }
+      } catch(error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`,
+            },
+          ],
+          isError: true,
+        }
+      }
+    })
+
+    this.server.registerTool("mediawiki_get_article", {
+      description:
+        "Get the current content of an article from the MediaWiki instance.",
+      inputSchema: z.object({
+        title: z.string().describe("Title of the article to retrieve"),
+      }),
+    }, async({title}) => {
+      try {
+        await this.#assureClient()
+
+        const data = await this.#client.get("api.php", {
+          action: "query",
+          titles: title,
+          prop: "revisions",
+          rvprop: "content",
+          rvslots: "main",
+          format: "json"
+        })
+
+        const pages = data.query.pages
+        const pageId = Object.keys(pages)[0]
+        const page = pages[pageId]
+
+        if(page.missing) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Article "${title}" does not exist.`,
+              },
+            ],
+          }
+        }
+
+        const content = page.revisions?.[0]?.slots?.main?.["*"] ?? ""
+
+        if(!content) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Article "${title}" exists but has no readable content.`,
+              },
+            ],
+          }
+        }
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Content of "${title}":\n\n${content}`,
+            },
+          ],
+        }
+      } catch(error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`,
+            },
+          ],
+          isError: true,
+        }
+      }
+    })
+
+    this.server.registerTool("mediawiki_search", {
+      description: "Search for articles on the MediaWiki instance.",
+      inputSchema: z.object({
+        query: z.string().describe("Search query"),
+        limit: z.number().optional().describe("Maximum number of results to return (default: 10)"),
+      }),
+    }, async({query, limit}) => {
+      try {
+        await this.#assureClient()
+
+        const data = await this.#client.get("api.php", {
+          action: "query",
+          list: "search",
+          srsearch: query,
+          srlimit: limit || 10,
+          format: "json"
+        })
+
+        const results = data.query.search
+
+        if(results.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No results found for "${query}".`,
+              },
+            ],
+          }
+        }
+
+        const stripTags = s => {
+          let prev
+          let curr = s
+
+          do {
+            prev = curr
+            curr = curr.replace(/<[^<>]*>/g, "")
+          } while(curr !== prev)
+
+          return curr
+        }
+
+        const formatted = results.map((r, i) =>
+          `${i + 1}. ${r.title}\n   Snippet: ${stripTags(r.snippet)}`
+        ).join("\n\n")
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Found ${results.length} result(s) for "${query}":\n\n${formatted}`,
+            },
+          ],
+        }
+      } catch(error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`,
+            },
+          ],
+          isError: true,
+        }
+      }
+    })
+  }
+
+  async run() {
+    const transport = new StdioServerTransport()
+    await this.server.connect(transport)
+
+    console.error("MediaWiki MCP Server running on stdio")
+  }
+}
+
+const server = new MediaWikiMCPServer()
+server.run().catch(console.error)