fantsec-docmost-cli 2.2.0

package/build/commands/space.js

@@ -0,0 +1,154 @@
+import { writeFileSync } from "fs";
+import { resolve, relative } from "path";
+import { Option } from "commander";
+import { CliError, ensureOutputSupported, parseCommaSeparatedIds, printResult, withClient, } from "../lib/cli-utils.js";
+export function register(program) {
+    program
+        .command("space-list")
+        .description("List all available spaces")
+        .action(() => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts, { allowTable: true });
+        const result = await client.getSpaces();
+        printResult(result.items, opts, { allowTable: true, hasMore: result.hasMore });
+    }));
+    program
+        .command("space-info")
+        .description("Get space details")
+        .requiredOption("--space-id <id>", "Space ID")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts, { allowTable: true });
+        const result = await client.getSpaceInfo(options.spaceId);
+        printResult(result, opts, { allowTable: true });
+    }));
+    program
+        .command("space-create")
+        .description("Create a new space")
+        .requiredOption("--name <name>", "Space name")
+        .option("--slug <slug>", "Space slug")
+        .option("--description <description>", "Space description")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        const result = await client.createSpace(options.name, options.slug, options.description);
+        printResult(result, opts);
+    }));
+    program
+        .command("space-update")
+        .description("Update space settings")
+        .requiredOption("--space-id <id>", "Space ID")
+        .option("--name <name>", "Space name")
+        .option("--description <description>", "Space description")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        const params = {
+            ...(options.name !== undefined && { name: options.name }),
+            ...(options.description !== undefined && { description: options.description }),
+        };
+        if (Object.keys(params).length === 0) {
+            throw new CliError("VALIDATION_ERROR", "At least one update flag is required (--name or --description).");
+        }
+        const result = await client.updateSpace(options.spaceId, params);
+        printResult(result, opts);
+    }));
+    program
+        .command("space-delete")
+        .description("Delete a space")
+        .requiredOption("--space-id <id>", "Space ID")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        const result = await client.deleteSpace(options.spaceId);
+        printResult(result, opts);
+    }));
+    program
+        .command("space-export")
+        .description("Export a space")
+        .requiredOption("--space-id <id>", "Space ID")
+        .addOption(new Option("--export-format <format>", "Export format")
+        .choices(["html", "markdown"]))
+        .option("--include-attachments", "Include attachments in export")
+        .option("--output <path>", "Output file path (default: stdout)")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        const data = await client.exportSpace(options.spaceId, options.exportFormat, options.includeAttachments);
+        if (options.output) {
+            const resolved = resolve(options.output);
+            const rel = relative(process.cwd(), resolved);
+            if (rel.startsWith("..") || resolve(rel) !== resolved) {
+                process.stderr.write(`Warning: writing to path outside CWD: ${resolved}\n`);
+            }
+            writeFileSync(resolved, Buffer.from(data));
+            printResult({ success: true, message: `Exported to ${resolved}` }, opts);
+        }
+        else {
+            process.stdout.write(Buffer.from(data));
+        }
+    }));
+    program
+        .command("space-member-list")
+        .description("List space members")
+        .requiredOption("--space-id <id>", "Space ID")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts, { allowTable: true });
+        const result = await client.getSpaceMembers(options.spaceId);
+        printResult(result.items, opts, { allowTable: true, hasMore: result.hasMore });
+    }));
+    program
+        .command("space-member-add")
+        .description("Add members to a space")
+        .requiredOption("--space-id <id>", "Space ID")
+        .addOption(new Option("--role <role>", "Member role")
+        .choices(["admin", "writer", "reader"])
+        .makeOptionMandatory())
+        .option("--user-ids <ids>", "Comma-separated user IDs")
+        .option("--group-ids <ids>", "Comma-separated group IDs")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        if (!options.userIds && !options.groupIds) {
+            throw new CliError("VALIDATION_ERROR", "At least one of --user-ids or --group-ids is required.");
+        }
+        const userIds = options.userIds
+            ? parseCommaSeparatedIds("--user-ids", options.userIds)
+            : undefined;
+        const groupIds = options.groupIds
+            ? parseCommaSeparatedIds("--group-ids", options.groupIds)
+            : undefined;
+        const result = await client.addSpaceMembers(options.spaceId, options.role, userIds, groupIds);
+        printResult(result, opts);
+    }));
+    program
+        .command("space-member-remove")
+        .description("Remove a member from a space")
+        .requiredOption("--space-id <id>", "Space ID")
+        .option("--user-id <id>", "User ID to remove")
+        .option("--group-id <id>", "Group ID to remove")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        if (options.userId && options.groupId) {
+            throw new CliError("VALIDATION_ERROR", "Specify either --user-id or --group-id, not both.");
+        }
+        if (!options.userId && !options.groupId) {
+            throw new CliError("VALIDATION_ERROR", "Specify either --user-id or --group-id.");
+        }
+        const result = await client.removeSpaceMember(options.spaceId, options.userId, options.groupId);
+        printResult(result, opts);
+    }));
+    program
+        .command("space-member-role")
+        .description("Change a space member's role")
+        .requiredOption("--space-id <id>", "Space ID")
+        .addOption(new Option("--role <role>", "New role")
+        .choices(["admin", "writer", "reader"])
+        .makeOptionMandatory())
+        .option("--user-id <id>", "User ID")
+        .option("--group-id <id>", "Group ID")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        if (options.userId && options.groupId) {
+            throw new CliError("VALIDATION_ERROR", "Specify either --user-id or --group-id, not both.");
+        }
+        if (!options.userId && !options.groupId) {
+            throw new CliError("VALIDATION_ERROR", "Specify either --user-id or --group-id.");
+        }
+        const result = await client.changeSpaceMemberRole(options.spaceId, options.role, options.userId, options.groupId);
+        printResult(result, opts);
+    }));
+}

package/build/commands/user.js

@@ -0,0 +1,38 @@
+import { Option } from "commander";
+import { CliError, ensureOutputSupported, printResult, withClient, } from "../lib/cli-utils.js";
+export function register(program) {
+    program
+        .command("user-me")
+        .description("Get current user information")
+        .action(() => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts, { allowTable: true });
+        const result = await client.getCurrentUser();
+        printResult(result, opts, { allowTable: true });
+    }));
+    program
+        .command("user-update")
+        .description("Update current user settings")
+        .option("--name <name>", "User display name")
+        .option("--email <email>", "User email")
+        .option("--avatar-url <url>", "Avatar URL")
+        .addOption(new Option("--full-page-width <bool>", "Enable full page width").choices(["true", "false"]))
+        .addOption(new Option("--page-edit-mode <mode>", "Default page edit mode")
+        .choices(["read", "edit"]))
+        .option("--locale <locale>", "User locale")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        const params = {
+            ...(options.name !== undefined && { name: options.name }),
+            ...(options.email !== undefined && { email: options.email }),
+            ...(options.avatarUrl !== undefined && { avatarUrl: options.avatarUrl }),
+            ...(options.fullPageWidth !== undefined && { fullPageWidth: options.fullPageWidth === "true" }),
+            ...(options.pageEditMode !== undefined && { pageEditMode: options.pageEditMode }),
+            ...(options.locale !== undefined && { locale: options.locale }),
+        };
+        if (Object.keys(params).length === 0) {
+            throw new CliError("VALIDATION_ERROR", "At least one update flag is required.");
+        }
+        const result = await client.updateUser(params);
+        printResult(result, opts);
+    }));
+}

package/build/commands/workspace.js

@@ -0,0 +1,77 @@
+import { Option } from "commander";
+import { CliError, ensureOutputSupported, printResult, withClient, withPublicClient, } from "../lib/cli-utils.js";
+export function register(program) {
+    program
+        .command("workspace-info")
+        .description("Get the current Docmost workspace")
+        .action(() => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts, { allowTable: true });
+        const result = await client.getWorkspace();
+        printResult(result.data, opts, { allowTable: true });
+    }));
+    program
+        .command("workspace-public")
+        .description("Get public workspace information (no auth required)")
+        .action(() => withPublicClient(program, async (client, opts) => {
+        ensureOutputSupported(opts, { allowTable: true });
+        const result = await client.getWorkspacePublic();
+        printResult(result, opts, { allowTable: true });
+    }));
+    program
+        .command("workspace-update")
+        .description("Update workspace settings")
+        .option("--name <name>", "Workspace name")
+        .option("--hostname <hostname>", "Workspace hostname")
+        .option("--description <description>", "Workspace description")
+        .option("--logo <logo>", "Workspace logo URL")
+        .option("--email-domains <domains>", "Allowed email domains (comma-separated)")
+        .addOption(new Option("--enforce-sso <bool>", "Enforce SSO authentication").choices(["true", "false"]))
+        .addOption(new Option("--enforce-mfa <bool>", "Enforce multi-factor authentication").choices(["true", "false"]))
+        .addOption(new Option("--restrict-api-to-admins <bool>", "Restrict API access to admins only").choices(["true", "false"]))
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        const params = {
+            ...(options.name !== undefined && { name: options.name }),
+            ...(options.hostname !== undefined && { hostname: options.hostname }),
+            ...(options.description !== undefined && { description: options.description }),
+            ...(options.logo !== undefined && { logo: options.logo }),
+            ...(options.emailDomains !== undefined && { emailDomains: options.emailDomains.split(",").map(d => d.trim()).filter(Boolean) }),
+            ...(options.enforceSso !== undefined && { enableSSO: options.enforceSso === "true" }),
+            ...(options.enforceMfa !== undefined && { enableMFA: options.enforceMfa === "true" }),
+            ...(options.restrictApiToAdmins !== undefined && { restrictApiToAdmins: options.restrictApiToAdmins === "true" }),
+        };
+        if (Object.keys(params).length === 0) {
+            throw new CliError("VALIDATION_ERROR", "At least one update flag is required.");
+        }
+        const result = await client.updateWorkspace(params);
+        printResult(result, opts);
+    }));
+    // Member commands
+    program
+        .command("member-list")
+        .description("List workspace members")
+        .action(() => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts, { allowTable: true });
+        const result = await client.getMembers();
+        printResult(result.items, opts, { allowTable: true, hasMore: result.hasMore });
+    }));
+    program
+        .command("member-remove")
+        .description("Remove a member from the workspace")
+        .requiredOption("--user-id <id>", "User ID to remove")
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        const result = await client.removeMember(options.userId);
+        printResult(result, opts);
+    }));
+    program
+        .command("member-role")
+        .description("Change a member's role")
+        .requiredOption("--user-id <id>", "User ID")
+        .addOption(new Option("--role <role>", "New role").choices(["owner", "admin", "member"]).makeOptionMandatory())
+        .action((options) => withClient(program, async (client, opts) => {
+        ensureOutputSupported(opts);
+        const result = await client.changeMemberRole(options.userId, options.role);
+        printResult(result, opts);
+    }));
+}

package/build/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { isCommanderHelpExit, getSafeOutput, normalizeError, printError, } from "./lib/cli-utils.js";
+import { createProgram } from "./program.js";
+async function main() {
+    const program = createProgram();
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        if (isCommanderHelpExit(error)) {
+            process.exit(0);
+        }
+        const output = getSafeOutput(program);
+        const normalized = normalizeError(error);
+        printError(normalized, output);
+        process.exit(normalized.exitCode);
+    }
+}
+main();

package/build/lib/auth-utils.js

@@ -0,0 +1,53 @@
+import axios from "axios";
+export async function getCollabToken(baseUrl, apiToken) {
+    try {
+        const response = await axios.post(`${baseUrl}/auth/collab-token`, {}, {
+            headers: {
+                Authorization: `Bearer ${apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        // console.error('Collab Token Response:', response.data);
+        // Response is wrapped in { data: { token: ... } }
+        const token = response.data.data?.token || response.data.token;
+        if (!token) {
+            throw new Error("Collab token not found in API response");
+        }
+        return token;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            throw new Error(`Failed to get collab token: ${error.response?.status} ${error.response?.statusText} - ${JSON.stringify(error.response?.data)}`);
+        }
+        throw error;
+    }
+}
+export async function performLogin(baseUrl, email, password) {
+    try {
+        const response = await axios.post(`${baseUrl}/auth/login`, {
+            email,
+            password,
+        });
+        // Extract token from Set-Cookie header
+        const cookies = response.headers["set-cookie"];
+        if (!cookies) {
+            throw new Error("No Set-Cookie header found in login response");
+        }
+        const authCookie = cookies.find((c) => c.startsWith("authToken="));
+        if (!authCookie) {
+            throw new Error("No authToken cookie found in login response");
+        }
+        const token = authCookie.split(";")[0].split("=")[1];
+        if (!token) {
+            throw new Error("authToken cookie is empty in login response");
+        }
+        return token;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            const status = error.response?.status;
+            throw new Error(`Login failed: ${status} ${error.response?.statusText}`);
+        }
+        throw error;
+    }
+}

package/build/lib/cli-utils.js

@@ -0,0 +1,293 @@
+import { readFile } from "fs/promises";
+import axios from "axios";
+import { CommanderError } from "commander";
+import { DocmostClient } from "../client.js";
+export const EXIT_CODES = {
+    AUTH_ERROR: 2,
+    NOT_FOUND: 3,
+    VALIDATION_ERROR: 4,
+    NETWORK_ERROR: 5,
+    INTERNAL_ERROR: 1,
+};
+export class CliError extends Error {
+    code;
+    exitCode;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.exitCode = EXIT_CODES[code];
+        this.details = details;
+    }
+}
+export function normalizeOutputFormat(value) {
+    const normalized = (value || "json").toLowerCase();
+    if (normalized === "json" || normalized === "table" || normalized === "text") {
+        return normalized;
+    }
+    throw new CliError("VALIDATION_ERROR", `Unsupported output format '${value}'. Use json, table, or text.`);
+}
+export function resolveOptions(raw, options) {
+    const requireAuth = options?.requireAuth ?? true;
+    const apiUrl = raw.apiUrl || process.env.DOCMOST_API_URL;
+    const token = raw.token || process.env.DOCMOST_TOKEN;
+    const email = raw.email || process.env.DOCMOST_EMAIL;
+    const password = raw.password || process.env.DOCMOST_PASSWORD;
+    if (!apiUrl) {
+        throw new CliError("VALIDATION_ERROR", "API URL is required. Use --api-url or DOCMOST_API_URL.");
+    }
+    if (requireAuth && !token && (!email || !password)) {
+        throw new CliError("VALIDATION_ERROR", "Authentication is required: provide --token (or DOCMOST_TOKEN) or both --email/--password (or DOCMOST_EMAIL/DOCMOST_PASSWORD).");
+    }
+    const outputFormat = normalizeOutputFormat(raw.format);
+    const parsedLimit = parseInt(raw.limit || "100", 10);
+    if (isNaN(parsedLimit)) {
+        throw new CliError("VALIDATION_ERROR", `Invalid --limit value '${raw.limit}'. Must be a number.`);
+    }
+    const limit = Math.max(1, Math.min(100, parsedLimit));
+    const parsedMaxItems = parseInt(raw.maxItems || "0", 10);
+    if (isNaN(parsedMaxItems)) {
+        throw new CliError("VALIDATION_ERROR", `Invalid --max-items value '${raw.maxItems}'. Must be a number.`);
+    }
+    const maxItems = parsedMaxItems > 0 ? parsedMaxItems : Infinity;
+    const auth = token
+        ? { token }
+        : (email && password ? { email, password } : {});
+    return {
+        apiUrl,
+        format: outputFormat,
+        quiet: raw.quiet ?? false,
+        limit,
+        maxItems,
+        auth,
+    };
+}
+export function flattenForTable(row) {
+    if (row === null || typeof row !== "object") {
+        return { value: row };
+    }
+    const output = {};
+    for (const [key, value] of Object.entries(row)) {
+        if (value === null ||
+            typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            output[key] = value;
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const allPrimitive = value.every((item) => item === null ||
+                typeof item === "string" ||
+                typeof item === "number" ||
+                typeof item === "boolean");
+            output[key] = allPrimitive ? value.join(", ") : JSON.stringify(value);
+            continue;
+        }
+        output[key] = JSON.stringify(value);
+    }
+    return output;
+}
+export function toTableRows(data) {
+    if (Array.isArray(data)) {
+        return data.map((row) => flattenForTable(row));
+    }
+    if (data && typeof data === "object") {
+        const value = data;
+        if (Array.isArray(value.items)) {
+            return value.items.map((row) => flattenForTable(row));
+        }
+        if (value.data && typeof value.data === "object") {
+            const inner = value.data;
+            if (Array.isArray(inner.items)) {
+                return inner.items.map((row) => flattenForTable(row));
+            }
+        }
+    }
+    return [flattenForTable(data)];
+}
+export function printResult(data, opts, options = {}) {
+    if (opts.quiet)
+        return;
+    const output = opts.format;
+    if (output === "json") {
+        if (Array.isArray(data)) {
+            const envelope = {
+                ok: true,
+                data,
+                meta: { count: data.length, hasMore: options.hasMore ?? false },
+            };
+            console.log(JSON.stringify(envelope, null, 2));
+        }
+        else {
+            const envelope = { ok: true, data };
+            console.log(JSON.stringify(envelope, null, 2));
+        }
+        return;
+    }
+    if (output === "table") {
+        if (!options.allowTable) {
+            throw new CliError("VALIDATION_ERROR", "Output format 'table' is not supported for this command.");
+        }
+        const rows = toTableRows(data);
+        if (rows.length === 0) {
+            console.log("(empty)");
+            return;
+        }
+        console.table(rows);
+        return;
+    }
+    if (!options.textExtractor) {
+        throw new CliError("VALIDATION_ERROR", "Output format 'text' is not supported for this command.");
+    }
+    const text = options.textExtractor(data);
+    if (typeof text !== "string") {
+        throw new CliError("VALIDATION_ERROR", "No text content available.");
+    }
+    process.stdout.write(text);
+    if (!text.endsWith("\n")) {
+        process.stdout.write("\n");
+    }
+}
+export function ensureOutputSupported(opts, options = {}) {
+    const output = opts.format;
+    if (output === "table" && !options.allowTable) {
+        throw new CliError("VALIDATION_ERROR", "Output format 'table' is not supported for this command.");
+    }
+    if (output === "text" && !options.allowText) {
+        throw new CliError("VALIDATION_ERROR", "Output format 'text' is not supported for this command.");
+    }
+}
+export function isCommanderHelpExit(error) {
+    return (error instanceof CommanderError &&
+        (error.code === "commander.helpDisplayed" ||
+            error.code === "commander.help" ||
+            error.code === "commander.version" ||
+            error.message === "(outputHelp)"));
+}
+export function normalizeError(error) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    if (error instanceof CommanderError) {
+        return new CliError("VALIDATION_ERROR", error.message);
+    }
+    if (axios.isAxiosError(error)) {
+        const status = error.response?.status;
+        const responseData = error.response?.data;
+        const message = (typeof responseData?.message === "string" && responseData.message) ||
+            error.message ||
+            "Request failed";
+        if (status === 401 || status === 403) {
+            return new CliError("AUTH_ERROR", message, responseData);
+        }
+        if (status === 404) {
+            return new CliError("NOT_FOUND", message, responseData);
+        }
+        if (status === 400 || status === 422) {
+            return new CliError("VALIDATION_ERROR", message, responseData);
+        }
+        if (!status) {
+            return new CliError("NETWORK_ERROR", message, {
+                code: error.code,
+            });
+        }
+        return new CliError("INTERNAL_ERROR", message, responseData);
+    }
+    if (error instanceof Error) {
+        return new CliError("INTERNAL_ERROR", error.message, error.cause ? { cause: error.cause instanceof Error ? error.cause.message : String(error.cause) } : undefined);
+    }
+    return new CliError("INTERNAL_ERROR", "Unknown error");
+}
+export function printError(error, output) {
+    const envelope = {
+        ok: false,
+        error: {
+            code: error.code,
+            message: error.message,
+            details: error.details,
+        },
+    };
+    if (output === "json") {
+        console.error(JSON.stringify(envelope, null, 2));
+    }
+    else {
+        console.error(`Error [${error.code}]: ${error.message}`);
+        if (error.details) {
+            console.error(JSON.stringify(error.details, null, 2));
+        }
+    }
+}
+export function getSafeOutput(program) {
+    const opts = program.opts();
+    try {
+        return normalizeOutputFormat(opts.format);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Warning: ${msg} Falling back to json.`);
+        return "json";
+    }
+}
+export async function readStdin() {
+    if (process.stdin.isTTY) {
+        throw new CliError("VALIDATION_ERROR", "No stdin data. Pipe content or use @file syntax.");
+    }
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => {
+            if (!data.trim()) {
+                reject(new CliError("VALIDATION_ERROR", "Stdin is empty. Provide content via pipe."));
+                return;
+            }
+            resolve(data);
+        });
+        process.stdin.on("error", reject);
+    });
+}
+export async function resolveContentInput(content) {
+    if (content === "-") {
+        return readStdin();
+    }
+    if (content.startsWith("@")) {
+        const filePath = content.slice(1);
+        if (!filePath) {
+            throw new CliError("VALIDATION_ERROR", "Invalid content file syntax. Use --content @path/to/file.md");
+        }
+        try {
+            return await readFile(filePath, "utf-8");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new CliError("VALIDATION_ERROR", `Cannot read file '${filePath}': ${msg}`);
+        }
+    }
+    return content;
+}
+export function parseCommaSeparatedIds(flagName, csv) {
+    const ids = csv
+        .split(",")
+        .map((id) => id.trim())
+        .filter(Boolean);
+    if (ids.length === 0) {
+        throw new CliError("VALIDATION_ERROR", `${flagName} must not be empty`);
+    }
+    return ids;
+}
+/** @deprecated Use parseCommaSeparatedIds instead */
+export function parsePageIds(csv) {
+    return parseCommaSeparatedIds("--page-ids", csv);
+}
+export async function withClient(program, run) {
+    const opts = resolveOptions(program.opts());
+    const client = new DocmostClient(opts.apiUrl, opts.auth);
+    await run(client, opts);
+}
+export async function withPublicClient(program, run) {
+    const opts = resolveOptions(program.opts(), { requireAuth: false });
+    const client = new DocmostClient(opts.apiUrl, opts.auth);
+    await run(client, opts);
+}