fantsec-docmost-cli 2.2.0

package/build/lib/mcp-tooling.js

@@ -0,0 +1,295 @@
+import { format } from "util";
+import { z } from "zod";
+import { getSafeOutput, isCommanderHelpExit, normalizeError, printError, } from "./cli-utils.js";
+import { createProgram } from "../program.js";
+const EXCLUDED_COMMANDS = new Set(["commands"]);
+const FILE_OUTPUT_COMMANDS = new Set(["file-download", "page-export", "space-export"]);
+let executionQueue = Promise.resolve();
+function toBuffer(chunk, encoding) {
+    if (typeof chunk === "string") {
+        return Buffer.from(chunk, encoding);
+    }
+    return Buffer.from(chunk);
+}
+function captureWrite(target) {
+    return (chunk, encoding, cb) => {
+        const normalizedEncoding = typeof encoding === "string" ? encoding : undefined;
+        const callback = typeof encoding === "function" ? encoding : cb;
+        target.push(toBuffer(chunk, normalizedEncoding));
+        callback?.(null);
+        return true;
+    };
+}
+async function withCapturedStdio(run) {
+    const output = { stdout: [], stderr: [] };
+    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    const originalStderrWrite = process.stderr.write.bind(process.stderr);
+    const originalConsoleLog = console.log;
+    const originalConsoleError = console.error;
+    process.stdout.write = captureWrite(output.stdout);
+    process.stderr.write = captureWrite(output.stderr);
+    console.log = (...args) => {
+        output.stdout.push(Buffer.from(`${format(...args)}\n`, "utf-8"));
+    };
+    console.error = (...args) => {
+        output.stderr.push(Buffer.from(`${format(...args)}\n`, "utf-8"));
+    };
+    try {
+        const result = await run();
+        return {
+            result,
+            stdout: Buffer.concat(output.stdout).toString("utf-8"),
+            stderr: Buffer.concat(output.stderr).toString("utf-8"),
+        };
+    }
+    finally {
+        process.stdout.write = originalStdoutWrite;
+        process.stderr.write = originalStderrWrite;
+        console.log = originalConsoleLog;
+        console.error = originalConsoleError;
+    }
+}
+function isNativeParseInt(option) {
+    return option.parseArg === parseInt || option.parseArg?.name === "parseInt";
+}
+function makeBooleanSchema(description, required, defaultValue) {
+    let schema = z.boolean().describe(description);
+    if (defaultValue !== undefined) {
+        schema = schema.default(defaultValue);
+    }
+    else if (!required) {
+        schema = schema.optional();
+    }
+    return schema;
+}
+function makeNumberSchema(description, required, defaultValue) {
+    let schema = z.number().int().describe(description);
+    if (defaultValue !== undefined) {
+        schema = schema.default(defaultValue);
+    }
+    else if (!required) {
+        schema = schema.optional();
+    }
+    return schema;
+}
+function makeStringSchema(description, required, choices, defaultValue) {
+    let schema = z.string().describe(description);
+    if (choices && choices.length > 0) {
+        schema = schema.refine((value) => typeof value === "string" && choices.includes(value), {
+            message: `Expected one of: ${choices.join(", ")}`,
+        });
+    }
+    if (defaultValue !== undefined) {
+        schema = schema.default(defaultValue);
+    }
+    else if (!required) {
+        schema = schema.optional();
+    }
+    return schema;
+}
+function createOptionSchema(option, commandName) {
+    const name = option.attributeName();
+    const long = option.long;
+    if (!long) {
+        throw new Error(`Option '${option.flags}' on command '${commandName}' is missing a long flag.`);
+    }
+    const required = FILE_OUTPUT_COMMANDS.has(commandName) && name === "output"
+        ? true
+        : option.mandatory === true;
+    const optionDescription = option.description || option.flags;
+    const description = FILE_OUTPUT_COMMANDS.has(commandName) && name === "output"
+        ? `${optionDescription} Required in MCP mode so binary output is written to a local file.`
+        : optionDescription;
+    if (option.isBoolean()) {
+        return {
+            name,
+            long,
+            description,
+            required,
+            schema: makeBooleanSchema(description, required, option.defaultValue),
+            serialize: (value) => (value ? [long] : []),
+        };
+    }
+    if (option.argChoices?.length === 2 && option.argChoices.includes("true") && option.argChoices.includes("false")) {
+        return {
+            name,
+            long,
+            description,
+            required,
+            schema: makeBooleanSchema(description, required, option.defaultValue),
+            serialize: (value) => (value === undefined ? [] : [long, String(value)]),
+        };
+    }
+    if (isNativeParseInt(option)) {
+        return {
+            name,
+            long,
+            description,
+            required,
+            schema: makeNumberSchema(description, required, option.defaultValue),
+            serialize: (value) => (value === undefined ? [] : [long, String(value)]),
+        };
+    }
+    return {
+        name,
+        long,
+        description,
+        required,
+        schema: makeStringSchema(description, required, option.argChoices, option.defaultValue),
+        serialize: (value) => (value === undefined ? [] : [long, String(value)]),
+    };
+}
+function getAnnotations(commandName) {
+    const readOnlyPrefixes = [
+        "page-list",
+        "page-info",
+        "page-history",
+        "page-breadcrumbs",
+        "page-tree",
+        "page-trash",
+        "space-list",
+        "space-info",
+        "space-member-list",
+        "workspace-info",
+        "workspace-public",
+        "member-list",
+        "user-me",
+        "group-list",
+        "group-info",
+        "group-member-list",
+        "comment-list",
+        "comment-info",
+        "share-list",
+        "share-info",
+        "share-for-page",
+        "invite-list",
+        "invite-info",
+        "invite-link",
+        "search",
+        "search-suggest",
+    ];
+    const destructiveTokens = ["delete", "remove", "revoke"];
+    const readOnlyHint = readOnlyPrefixes.some((prefix) => commandName.startsWith(prefix));
+    const destructiveHint = destructiveTokens.some((token) => commandName.includes(token));
+    const idempotentHint = readOnlyHint || commandName.endsWith("-update") || commandName.endsWith("-role");
+    return {
+        readOnlyHint: readOnlyHint || undefined,
+        destructiveHint: destructiveHint || undefined,
+        idempotentHint: idempotentHint || undefined,
+        openWorldHint: true,
+    };
+}
+export function listMcpTools() {
+    const program = createProgram();
+    return program.commands
+        .filter((command) => !EXCLUDED_COMMANDS.has(command.name()))
+        .map((command) => {
+        const commandName = command.name();
+        const options = command.options.map((option) => createOptionSchema(option, commandName));
+        const inputSchema = Object.fromEntries(options.map((option) => [option.name, option.schema]));
+        const toolName = commandName.replace(/-/g, "_");
+        const baseDescription = command.description();
+        const description = FILE_OUTPUT_COMMANDS.has(commandName)
+            ? `${baseDescription}. This MCP wrapper requires \`output\` so exported/downloaded bytes are saved to a local file instead of streamed over stdio.`
+            : baseDescription;
+        return {
+            commandName,
+            toolName,
+            description,
+            inputSchema,
+            options,
+            annotations: getAnnotations(commandName),
+            requiresOutputPath: FILE_OUTPUT_COMMANDS.has(commandName),
+        };
+    });
+}
+function buildArgv(tool, args, auth) {
+    const argv = ["node", "docmost", "--format", "json"];
+    if (auth?.apiUrl) {
+        argv.push("--api-url", auth.apiUrl);
+    }
+    if (auth?.token) {
+        argv.push("--token", auth.token);
+    }
+    else if (auth?.email && auth?.password) {
+        argv.push("--email", auth.email, "--password", auth.password);
+    }
+    argv.push(tool.commandName);
+    for (const option of tool.options) {
+        argv.push(...option.serialize(args[option.name]));
+    }
+    return argv;
+}
+async function executeToolInternal(tool, args, auth) {
+    const program = createProgram();
+    const argv = buildArgv(tool, args, auth);
+    const { stdout, stderr } = await withCapturedStdio(async () => {
+        try {
+            await program.parseAsync(argv);
+        }
+        catch (error) {
+            if (isCommanderHelpExit(error)) {
+                return;
+            }
+            const normalized = normalizeError(error);
+            printError(normalized, getSafeOutput(program));
+        }
+    });
+    const combinedStdout = stdout.trim();
+    const combinedStderr = stderr.trim();
+    const parsed = combinedStdout
+        ? safeJsonParse(combinedStdout)
+        : (combinedStderr ? safeJsonParse(combinedStderr) : undefined);
+    const ok = isSuccessResult(parsed, stderr);
+    return {
+        ok,
+        stdout,
+        stderr,
+        parsed,
+        outputPath: typeof args.output === "string" ? args.output : undefined,
+    };
+}
+function safeJsonParse(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSuccessResult(parsed, stderr) {
+    if (!parsed || typeof parsed !== "object") {
+        return stderr.trim().length === 0;
+    }
+    const envelope = parsed;
+    if (typeof envelope.ok === "boolean") {
+        return envelope.ok;
+    }
+    return stderr.trim().length === 0;
+}
+export function parseDocmostBearer(bearerToken, defaultApiUrl = process.env.DOCMOST_API_URL) {
+    const trimmed = bearerToken?.trim();
+    if (!defaultApiUrl) {
+        throw new Error("DOCMOST_API_URL is not set.");
+    }
+    if (!trimmed) {
+        return { apiUrl: defaultApiUrl };
+    }
+    const separatorIndex = trimmed.indexOf(":");
+    if (separatorIndex === -1) {
+        return {
+            apiUrl: defaultApiUrl,
+            token: trimmed,
+        };
+    }
+    return {
+        apiUrl: defaultApiUrl,
+        email: trimmed.slice(0, separatorIndex),
+        password: trimmed.slice(separatorIndex + 1),
+    };
+}
+export function executeTool(tool, args, auth) {
+    const run = executionQueue.then(() => executeToolInternal(tool, args, auth));
+    executionQueue = run.then(() => undefined, () => undefined);
+    return run;
+}

package/build/lib/page-mentions.js

@@ -0,0 +1,162 @@
+import { randomUUID } from "crypto";
+import { marked } from "marked";
+import { generateJSON } from "@tiptap/html";
+import { JSDOM } from "jsdom";
+import { tiptapExtensions } from "./tiptap-extensions.js";
+const EXCLUDED_PARENT_TAGS = new Set(["A", "CODE", "PRE", "SCRIPT", "STYLE"]);
+function ensureDomEnvironment(dom) {
+    if (typeof window === "undefined") {
+        global.window = dom.window;
+    }
+    if (typeof document === "undefined") {
+        global.document = dom.window.document;
+    }
+    if (typeof Element === "undefined") {
+        global.Element = dom.window.Element;
+    }
+}
+function isAsciiWordChar(char) {
+    return /[A-Za-z0-9_]/.test(char);
+}
+function isMentionBoundary(text, atIndex) {
+    if (atIndex === 0) {
+        return true;
+    }
+    return !isAsciiWordChar(text[atIndex - 1]);
+}
+function isPlainMentionStopChar(char) {
+    return /\s/.test(char) || /[\\/`'".,!?;:()[\]{}<>|~^&*=+#$%，。！？；：、（）【】《》]/.test(char);
+}
+function extractMentionTokens(text) {
+    const tokens = [];
+    for (let index = 0; index < text.length; index += 1) {
+        if (text[index] !== "@" || !isMentionBoundary(text, index)) {
+            continue;
+        }
+        if (text[index + 1] === "[") {
+            const closingIndex = text.indexOf("]", index + 2);
+            if (closingIndex === -1) {
+                continue;
+            }
+            const label = text.slice(index + 2, closingIndex).trim();
+            if (!label) {
+                continue;
+            }
+            tokens.push({
+                start: index,
+                end: closingIndex + 1,
+                raw: text.slice(index, closingIndex + 1),
+                label,
+            });
+            index = closingIndex;
+            continue;
+        }
+        let end = index + 1;
+        while (end < text.length && !isPlainMentionStopChar(text[end])) {
+            end += 1;
+        }
+        const label = text.slice(index + 1, end).trim();
+        if (!label) {
+            continue;
+        }
+        tokens.push({
+            start: index,
+            end,
+            raw: text.slice(index, end),
+            label,
+        });
+        index = end - 1;
+    }
+    return tokens;
+}
+async function injectPageMentionsIntoHtml(html, resolvePageMention, creatorId) {
+    const dom = new JSDOM(`<!DOCTYPE html><html><body>${html}</body></html>`);
+    ensureDomEnvironment(dom);
+    const { document, NodeFilter } = dom.window;
+    const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, {
+        acceptNode: (node) => {
+            const text = node.textContent ?? "";
+            if (!text.includes("@")) {
+                return NodeFilter.FILTER_REJECT;
+            }
+            const parentTag = node.parentElement?.tagName;
+            if (parentTag && EXCLUDED_PARENT_TAGS.has(parentTag)) {
+                return NodeFilter.FILTER_REJECT;
+            }
+            return NodeFilter.FILTER_ACCEPT;
+        },
+    });
+    const textNodes = [];
+    let currentNode = walker.nextNode();
+    while (currentNode) {
+        textNodes.push(currentNode);
+        currentNode = walker.nextNode();
+    }
+    const labels = new Set();
+    const nodeTokens = new Map();
+    for (const textNode of textNodes) {
+        const tokens = extractMentionTokens(textNode.textContent ?? "");
+        if (tokens.length === 0) {
+            continue;
+        }
+        nodeTokens.set(textNode, tokens);
+        for (const token of tokens) {
+            labels.add(token.label);
+        }
+    }
+    if (labels.size === 0) {
+        return html;
+    }
+    const resolvedMentions = new Map();
+    for (const label of labels) {
+        resolvedMentions.set(label, await resolvePageMention(label));
+    }
+    for (const [textNode, tokens] of nodeTokens.entries()) {
+        const originalText = textNode.textContent ?? "";
+        const fragment = document.createDocumentFragment();
+        let cursor = 0;
+        let replaced = false;
+        for (const token of tokens) {
+            if (token.start > cursor) {
+                fragment.append(document.createTextNode(originalText.slice(cursor, token.start)));
+            }
+            const resolved = resolvedMentions.get(token.label);
+            if (resolved) {
+                const mention = document.createElement("span");
+                mention.setAttribute("data-type", "mention");
+                mention.setAttribute("data-id", randomUUID());
+                mention.setAttribute("data-entity-type", "page");
+                mention.setAttribute("data-entity-id", resolved.id);
+                mention.setAttribute("data-label", resolved.title);
+                mention.setAttribute("data-slug-id", resolved.slugId);
+                if (creatorId) {
+                    mention.setAttribute("data-creator-id", creatorId);
+                }
+                mention.textContent = resolved.title;
+                fragment.append(mention);
+                replaced = true;
+            }
+            else {
+                fragment.append(document.createTextNode(token.raw));
+            }
+            cursor = token.end;
+        }
+        if (cursor < originalText.length) {
+            fragment.append(document.createTextNode(originalText.slice(cursor)));
+        }
+        if (replaced) {
+            textNode.parentNode?.replaceChild(fragment, textNode);
+        }
+    }
+    return document.body.innerHTML;
+}
+export async function markdownToProseMirrorJson(markdown, options = {}) {
+    const html = await marked.parse(markdown);
+    const resolvedHtml = options.resolvePageMention
+        ? await injectPageMentionsIntoHtml(html, options.resolvePageMention, options.creatorId)
+        : html;
+    return generateJSON(resolvedHtml, tiptapExtensions);
+}
+export function __internal_extractMentionTokens(text) {
+    return extractMentionTokens(text);
+}

package/build/lib/tiptap-extensions.js

@@ -0,0 +1,86 @@
+import { mergeAttributes, Node } from "@tiptap/core";
+import StarterKit from "@tiptap/starter-kit";
+import Image from "@tiptap/extension-image";
+import Link from "@tiptap/extension-link";
+import { Table } from "@tiptap/extension-table";
+import { TableRow } from "@tiptap/extension-table-row";
+import { TableCell } from "@tiptap/extension-table-cell";
+import { TableHeader } from "@tiptap/extension-table-header";
+const Mention = Node.create({
+    name: "mention",
+    group: "inline",
+    inline: true,
+    atom: true,
+    selectable: true,
+    addAttributes() {
+        return {
+            id: {
+                default: null,
+                parseHTML: (element) => element.getAttribute("data-id"),
+                renderHTML: (attributes) => attributes.id ? { "data-id": attributes.id } : {},
+            },
+            label: {
+                default: null,
+                parseHTML: (element) => element.getAttribute("data-label"),
+                renderHTML: (attributes) => attributes.label ? { "data-label": attributes.label } : {},
+            },
+            entityType: {
+                default: null,
+                parseHTML: (element) => element.getAttribute("data-entity-type"),
+                renderHTML: (attributes) => attributes.entityType ? { "data-entity-type": attributes.entityType } : {},
+            },
+            entityId: {
+                default: null,
+                parseHTML: (element) => element.getAttribute("data-entity-id"),
+                renderHTML: (attributes) => attributes.entityId ? { "data-entity-id": attributes.entityId } : {},
+            },
+            slugId: {
+                default: null,
+                parseHTML: (element) => element.getAttribute("data-slug-id"),
+                renderHTML: (attributes) => attributes.slugId ? { "data-slug-id": attributes.slugId } : {},
+            },
+            creatorId: {
+                default: null,
+                parseHTML: (element) => element.getAttribute("data-creator-id"),
+                renderHTML: (attributes) => attributes.creatorId ? { "data-creator-id": attributes.creatorId } : {},
+            },
+            anchorId: {
+                default: null,
+                parseHTML: (element) => element.getAttribute("data-anchor-id"),
+                renderHTML: (attributes) => attributes.anchorId ? { "data-anchor-id": attributes.anchorId } : {},
+            },
+        };
+    },
+    parseHTML() {
+        return [{ tag: 'span[data-type="mention"]' }];
+    },
+    renderHTML({ node, HTMLAttributes }) {
+        return [
+            "span",
+            mergeAttributes({ "data-type": "mention" }, HTMLAttributes),
+            node.attrs.label ?? node.attrs.entityId ?? "",
+        ];
+    },
+});
+// Define extensions compatible with standard Markdown features
+// We use the default Tiptap extensions to handle basic content
+export const tiptapExtensions = [
+    StarterKit.configure({
+        // Explicitly enable features that might be disabled in some contexts
+        codeBlock: {},
+        heading: {},
+    }),
+    Image.configure({
+        inline: true,
+    }),
+    Link.configure({
+        openOnClick: false,
+    }),
+    Mention,
+    Table.configure({
+        resizable: false,
+    }),
+    TableRow,
+    TableCell,
+    TableHeader,
+];