fantsec-docmost-cli 2.2.0

package/build/mcp.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { pathToFileURL } from "url";
+import { getVersion } from "./program.js";
+import { executeTool, listMcpTools, parseDocmostBearer, } from "./lib/mcp-tooling.js";
+function formatExecutionResult(tool, result) {
+    if (result.parsed !== undefined) {
+        return JSON.stringify(result.parsed, null, 2);
+    }
+    if (tool.requiresOutputPath && result.outputPath) {
+        return JSON.stringify({
+            ok: result.ok,
+            data: {
+                outputPath: result.outputPath,
+                command: tool.commandName,
+            },
+            stderr: result.stderr.trim() || undefined,
+        }, null, 2);
+    }
+    return JSON.stringify({
+        ok: result.ok,
+        stdout: result.stdout.trim() || undefined,
+        stderr: result.stderr.trim() || undefined,
+    }, null, 2);
+}
+function createCatalogResource(tools) {
+    return {
+        tools: tools.map((tool) => ({
+            toolName: tool.toolName,
+            commandName: tool.commandName,
+            description: tool.description,
+            requiresOutputPath: tool.requiresOutputPath,
+            parameters: tool.options.map((option) => ({
+                name: option.name,
+                flag: option.long,
+                description: option.description,
+                required: option.required,
+            })),
+        })),
+    };
+}
+export function createMcpServer() {
+    const tools = listMcpTools();
+    const server = new McpServer({
+        name: "docmost-mcp",
+        version: getVersion(),
+    }, {
+        capabilities: {
+            logging: {},
+        },
+    });
+    const catalog = createCatalogResource(tools);
+    server.registerResource("docmost-tool-catalog", "docmost://commands", {
+        title: "Docmost tool catalog",
+        description: "A read-only catalog of Docmost MCP tools and their underlying CLI commands.",
+        mimeType: "application/json",
+    }, async () => ({
+        contents: [
+            {
+                uri: "docmost://commands",
+                mimeType: "application/json",
+                text: JSON.stringify(catalog, null, 2),
+            },
+        ],
+    }));
+    for (const tool of tools) {
+        server.registerTool(tool.toolName, {
+            title: tool.toolName,
+            description: `${tool.description} (CLI: ${tool.commandName})`,
+            inputSchema: tool.inputSchema,
+            annotations: tool.annotations,
+        }, async (args, extra) => {
+            const authHeader = getAuthorizationHeader(extra?.requestInfo?.headers);
+            if (!authHeader) {
+                throw new Error("Authorization header is required for Docmost tool calls.");
+            }
+            const auth = parseDocmostBearer(extractBearerToken(authHeader));
+            const result = await executeTool(tool, args, auth);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatExecutionResult(tool, result),
+                    },
+                ],
+                isError: !result.ok,
+            };
+        });
+    }
+    return server;
+}
+function getAuthorizationHeader(headers) {
+    if (!headers) {
+        return undefined;
+    }
+    const value = headers.authorization ?? headers.Authorization;
+    return Array.isArray(value) ? value[0] : value;
+}
+function extractBearerToken(headerValue) {
+    if (!headerValue) {
+        return undefined;
+    }
+    const trimmed = headerValue.trim();
+    const prefix = "Bearer ";
+    return trimmed.toLowerCase().startsWith(prefix.toLowerCase())
+        ? trimmed.slice(prefix.length).trim()
+        : trimmed;
+}
+function createHttpApp() {
+    const app = createMcpExpressApp({ host: "0.0.0.0" });
+    app.get("/healthz", (_req, res) => {
+        res.json({ ok: true, service: "docmost-mcp", version: getVersion() });
+    });
+    app.post("/mcp", async (req, res) => {
+        const server = createMcpServer();
+        try {
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+            res.on("close", () => {
+                void transport.close();
+                void server.close();
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message,
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    app.get("/mcp", (_req, res) => {
+        res.status(405).json({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed.",
+            },
+            id: null,
+        });
+    });
+    app.delete("/mcp", (_req, res) => {
+        res.status(405).json({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed.",
+            },
+            id: null,
+        });
+    });
+    return app;
+}
+async function main() {
+    const mode = process.argv[2] || "stdio";
+    if (mode === "http") {
+        const port = Number(process.env.PORT || "8000");
+        const app = createHttpApp();
+        app.listen(port, "0.0.0.0", () => {
+            console.error(`Docmost MCP HTTP server listening on port ${port}`);
+        });
+        return;
+    }
+    const server = createMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Docmost MCP server error: ${message}`);
+        process.exit(1);
+    });
+}

package/build/program.js

@@ -0,0 +1,60 @@
+import { readFileSync } from "fs";
+import { Command } from "commander";
+import { register as registerPageCommands } from "./commands/page.js";
+import { register as registerWorkspaceCommands } from "./commands/workspace.js";
+import { register as registerInviteCommands } from "./commands/invite.js";
+import { register as registerUserCommands } from "./commands/user.js";
+import { register as registerSpaceCommands } from "./commands/space.js";
+import { register as registerGroupCommands } from "./commands/group.js";
+import { register as registerCommentCommands } from "./commands/comment.js";
+import { register as registerShareCommands } from "./commands/share.js";
+import { register as registerFileCommands } from "./commands/file.js";
+import { register as registerSearchCommands } from "./commands/search.js";
+import { register as registerDiscoveryCommands } from "./commands/discovery.js";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+export function createProgram() {
+    const program = new Command()
+        .name("docmost")
+        .description("Agent-first CLI for Docmost documentation platform")
+        .version(pkg.version)
+        .showHelpAfterError()
+        .option("-u, --api-url <url>", "Docmost API URL")
+        .option("-e, --email <email>", "Docmost account email")
+        .option("--password <password>", "Docmost account password (prefer DOCMOST_PASSWORD env var)")
+        .option("-t, --token <token>", "Docmost API auth token")
+        .option("-f, --format <format>", "Output format: json | table | text", "json")
+        .option("-q, --quiet", "Suppress output, exit code only")
+        .option("--limit <n>", "Items per API page (1-100)")
+        .option("--max-items <n>", "Stop after N total items")
+        .addHelpText("after", [
+        "",
+        "Examples:",
+        "  docmost workspace-info",
+        "  docmost page-list --space-id <space-id> --format table",
+        "  docmost page-info --page-id <page-id> --format text",
+        "  docmost search --query \"onboarding\"",
+        "  docmost space-list --format table",
+        "",
+        "Auth precedence:",
+        "  1) --token, then DOCMOST_TOKEN",
+        "  2) --email/--password, then DOCMOST_EMAIL/DOCMOST_PASSWORD",
+        "",
+        "Security: CLI flags are visible in process lists. Use env vars for credentials.",
+    ].join("\n"))
+        .exitOverride();
+    registerPageCommands(program);
+    registerWorkspaceCommands(program);
+    registerInviteCommands(program);
+    registerUserCommands(program);
+    registerSpaceCommands(program);
+    registerGroupCommands(program);
+    registerCommentCommands(program);
+    registerShareCommands(program);
+    registerFileCommands(program);
+    registerSearchCommands(program);
+    registerDiscoveryCommands(program);
+    return program;
+}
+export function getVersion() {
+    return pkg.version;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "fantsec-docmost-cli",
+  "version": "2.2.0",
+  "description": "A Docmost CLI and standard MCP server for documentation automation.",
+  "main": "build/index.js",
+  "bin": {
+    "docmost": "build/index.js",
+    "docmost-mcp": "build/mcp.js"
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc",
+    "start": "node build/index.js",
+    "start:mcp": "node build/mcp.js",
+    "start:mcp:http": "node build/mcp.js http",
+    "test": "vitest run",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:all": "vitest run && vitest run --config vitest.integration.config.ts",
+    "test:watch": "vitest",
+    "watch": "tsc --watch"
+  },
+  "keywords": [
+    "cli",
+    "docmost",
+    "documentation",
+    "ai",
+    "agent"
+  ],
+  "author": "Moritz Krause",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@hocuspocus/provider": "^3.4.4",
+    "@hocuspocus/transformer": "^3.4.4",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@tiptap/core": "^3.18.0",
+    "@tiptap/extension-image": "^3.18.0",
+    "@tiptap/extension-link": "^3.18.0",
+    "@tiptap/extension-table": "^3.20.1",
+    "@tiptap/extension-table-cell": "^3.20.1",
+    "@tiptap/extension-table-header": "^3.20.1",
+    "@tiptap/extension-table-row": "^3.20.1",
+    "@tiptap/html": "^3.18.0",
+    "@tiptap/starter-kit": "^3.18.0",
+    "axios": "^1.6.0",
+    "commander": "^14.0.1",
+    "form-data": "^4.0.0",
+    "jsdom": "^27.4.0",
+    "marked": "^17.0.1",
+    "ws": "^8.19.0",
+    "yjs": "^13.6.29",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/form-data": "^2.5.0",
+    "@types/jsdom": "^27.0.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
+  }
+}