fantsec-docmost-cli 2.2.0

package/build/__tests__/filters.test.js

@@ -0,0 +1,235 @@
+import { describe, it, expect } from "vitest";
+import { filterWorkspace, filterSpace, filterGroup, filterPage, filterSearchResult, filterHistoryEntry, filterMember, filterInvite, filterUser, filterComment, filterShare, filterHistoryDetail, } from "../lib/filters.js";
+const extra = { __v: 9, internalField: "secret", _meta: { x: 1 } };
+describe("filterWorkspace", () => {
+    it("keeps expected fields and strips extras", () => {
+        const input = {
+            id: "w1", name: "My WS", description: "desc",
+            defaultSpaceId: "s1", createdAt: "2024-01-01", updatedAt: "2024-02-01", deletedAt: null,
+            ...extra,
+        };
+        const result = filterWorkspace(input);
+        expect(result).toEqual({
+            id: "w1", name: "My WS", description: "desc",
+            defaultSpaceId: "s1", createdAt: "2024-01-01", updatedAt: "2024-02-01", deletedAt: null,
+        });
+        expect(result).not.toHaveProperty("__v");
+        expect(result).not.toHaveProperty("internalField");
+    });
+});
+describe("filterSpace", () => {
+    it("keeps expected fields and strips extras", () => {
+        const input = {
+            id: "s1", name: "Space", description: "d", slug: "space",
+            visibility: "public", createdAt: "2024-01-01", updatedAt: "2024-02-01", deletedAt: null,
+            ...extra,
+        };
+        const result = filterSpace(input);
+        expect(result).toEqual({
+            id: "s1", name: "Space", description: "d", slug: "space",
+            visibility: "public", createdAt: "2024-01-01", updatedAt: "2024-02-01", deletedAt: null,
+        });
+        expect(result).not.toHaveProperty("__v");
+    });
+});
+describe("filterGroup", () => {
+    it("keeps expected fields and strips extras", () => {
+        const input = {
+            id: "g1", name: "Group", description: "gd", workspaceId: "w1",
+            createdAt: "2024-01-01", updatedAt: "2024-02-01", deletedAt: null,
+            ...extra,
+        };
+        const result = filterGroup(input);
+        expect(result).toEqual({
+            id: "g1", name: "Group", description: "gd", workspaceId: "w1",
+            createdAt: "2024-01-01", updatedAt: "2024-02-01", deletedAt: null,
+        });
+        expect(result).not.toHaveProperty("_meta");
+    });
+});
+describe("filterPage", () => {
+    const page = {
+        id: "p1", title: "Page", parentPageId: null, spaceId: "s1",
+        isLocked: false, createdAt: "2024-01-01", updatedAt: "2024-02-01", deletedAt: null,
+        ...extra,
+    };
+    it("keeps page fields and strips extras", () => {
+        const result = filterPage(page);
+        expect(result).not.toHaveProperty("__v");
+        expect(result.id).toBe("p1");
+    });
+    it("includes content when string provided", () => {
+        const result = filterPage(page, "# Hello");
+        expect(result.content).toBe("# Hello");
+    });
+    it("includes content when empty string provided", () => {
+        const result = filterPage(page, "");
+        expect(result.content).toBe("");
+    });
+    it("excludes content when undefined", () => {
+        const result = filterPage(page);
+        expect(result).not.toHaveProperty("content");
+    });
+    it("includes subpages when non-empty", () => {
+        const subs = [{ id: "sp1", title: "Sub1", extra: "x" }, { id: "sp2", title: "Sub2" }];
+        const result = filterPage(page, undefined, subs);
+        expect(result.subpages).toEqual([{ id: "sp1", title: "Sub1" }, { id: "sp2", title: "Sub2" }]);
+    });
+    it("excludes subpages when empty array", () => {
+        const result = filterPage(page, undefined, []);
+        expect(result).not.toHaveProperty("subpages");
+    });
+    it("excludes subpages when undefined", () => {
+        const result = filterPage(page);
+        expect(result).not.toHaveProperty("subpages");
+    });
+});
+describe("filterSearchResult", () => {
+    it("maps space.id→spaceId and space.name→spaceName, keeps rank and highlight", () => {
+        const input = {
+            id: "p1", title: "Found", parentPageId: null,
+            createdAt: "2024-01-01", updatedAt: "2024-02-01",
+            rank: 0.95, highlight: "<b>found</b>",
+            space: { id: "s1", name: "Main", slug: "main" },
+            ...extra,
+        };
+        const result = filterSearchResult(input);
+        expect(result.spaceId).toBe("s1");
+        expect(result.spaceName).toBe("Main");
+        expect(result.rank).toBe(0.95);
+        expect(result.highlight).toBe("<b>found</b>");
+        expect(result).not.toHaveProperty("space");
+        expect(result).not.toHaveProperty("__v");
+    });
+});
+describe("filterHistoryEntry", () => {
+    it("maps lastUpdatedBy.name", () => {
+        const input = {
+            id: "h1", pageId: "p1", title: "V2", version: 2,
+            createdAt: "2024-01-01",
+            lastUpdatedBy: { id: "u1", name: "Alice" },
+            lastUpdatedById: "u1",
+            contributors: [{ name: "Alice" }, { name: "Bob" }],
+            ...extra,
+        };
+        const result = filterHistoryEntry(input);
+        expect(result.lastUpdatedBy).toBe("Alice");
+        expect(result.contributors).toEqual(["Alice", "Bob"]);
+        expect(result).not.toHaveProperty("__v");
+    });
+    it("falls back to lastUpdatedById when lastUpdatedBy is missing", () => {
+        const input = {
+            id: "h2", pageId: "p1", title: "V1", version: 1,
+            createdAt: "2024-01-01",
+            lastUpdatedById: "u99",
+            contributors: [],
+        };
+        const result = filterHistoryEntry(input);
+        expect(result.lastUpdatedBy).toBe("u99");
+    });
+    it("returns empty array when contributors missing", () => {
+        const input = {
+            id: "h3", pageId: "p1", title: "V0", version: 0,
+            createdAt: "2024-01-01",
+            lastUpdatedById: "u1",
+        };
+        const result = filterHistoryEntry(input);
+        expect(result.contributors).toEqual([]);
+    });
+});
+describe("filterMember", () => {
+    it("keeps expected fields and strips extras", () => {
+        const input = {
+            id: "m1", name: "Alice", email: "a@b.com", role: "admin",
+            createdAt: "2024-01-01", ...extra,
+        };
+        const result = filterMember(input);
+        expect(result).toEqual({
+            id: "m1", name: "Alice", email: "a@b.com", role: "admin", createdAt: "2024-01-01",
+        });
+        expect(result).not.toHaveProperty("internalField");
+    });
+});
+describe("filterInvite", () => {
+    it("keeps expected fields and strips extras", () => {
+        const input = {
+            id: "i1", email: "x@y.com", role: "editor", status: "pending",
+            invitedById: "u1", createdAt: "2024-01-01", ...extra,
+        };
+        const result = filterInvite(input);
+        expect(result).toEqual({
+            id: "i1", email: "x@y.com", role: "editor", status: "pending",
+            invitedById: "u1", createdAt: "2024-01-01",
+        });
+        expect(result).not.toHaveProperty("__v");
+    });
+});
+describe("filterUser", () => {
+    it("keeps expected fields and strips extras", () => {
+        const input = {
+            id: "u1", name: "Bob", email: "b@b.com", role: "owner",
+            locale: "en", createdAt: "2024-01-01", ...extra,
+        };
+        const result = filterUser(input);
+        expect(result).toEqual({
+            id: "u1", name: "Bob", email: "b@b.com", role: "owner",
+            locale: "en", createdAt: "2024-01-01",
+        });
+        expect(result).not.toHaveProperty("_meta");
+    });
+});
+describe("filterComment", () => {
+    it("keeps all comment fields and strips extras", () => {
+        const input = {
+            id: "c1", pageId: "p1", content: "Nice!", selection: "text",
+            parentCommentId: null, creatorId: "u1",
+            createdAt: "2024-01-01", updatedAt: "2024-02-01",
+            ...extra,
+        };
+        const result = filterComment(input);
+        expect(result).toEqual({
+            id: "c1", pageId: "p1", content: "Nice!", selection: "text",
+            parentCommentId: null, creatorId: "u1",
+            createdAt: "2024-01-01", updatedAt: "2024-02-01",
+        });
+        expect(result).not.toHaveProperty("__v");
+    });
+});
+describe("filterShare", () => {
+    it("keeps expected fields and strips extras", () => {
+        const input = {
+            id: "sh1", pageId: "p1", includeSubPages: true,
+            searchIndexing: false, createdAt: "2024-01-01", ...extra,
+        };
+        const result = filterShare(input);
+        expect(result).toEqual({
+            id: "sh1", pageId: "p1", includeSubPages: true,
+            searchIndexing: false, createdAt: "2024-01-01",
+        });
+        expect(result).not.toHaveProperty("internalField");
+    });
+});
+describe("filterHistoryDetail", () => {
+    const entry = {
+        id: "h1", pageId: "p1", title: "V3", version: 3,
+        createdAt: "2024-01-01",
+        lastUpdatedBy: { name: "Carol" },
+        contributors: [{ name: "Carol" }],
+        ...extra,
+    };
+    it("extends filterHistoryEntry with content", () => {
+        const result = filterHistoryDetail(entry, "# Content");
+        expect(result.content).toBe("# Content");
+        expect(result.id).toBe("h1");
+        expect(result.lastUpdatedBy).toBe("Carol");
+        expect(result).not.toHaveProperty("__v");
+    });
+    it("includes content when empty string", () => {
+        const result = filterHistoryDetail(entry, "");
+        expect(result.content).toBe("");
+    });
+    it("excludes content when undefined", () => {
+        const result = filterHistoryDetail(entry);
+        expect(result).not.toHaveProperty("content");
+    });
+});

package/build/__tests__/integration/comment.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runCli, parseEnvelope, testEnv } from "./helpers/run-cli.js";
+const env = testEnv();
+describe("comment commands", () => {
+    let spaceId;
+    let pageId;
+    let commentId;
+    beforeAll(async () => {
+        const spaceResult = await runCli(["space-create", "--name", `commentspace${Date.now()}`, "--slug", `cs${Date.now()}`], env);
+        spaceId = parseEnvelope(spaceResult).data.id;
+        const pageResult = await runCli(["page-create", "--space-id", spaceId, "--title", "Comment Test Page"], env);
+        pageId = parseEnvelope(pageResult).data.id;
+    });
+    it("comment-create creates a comment", async () => {
+        const result = await runCli(["comment-create", "--page-id", pageId, "--content", "Test comment"], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+        // createComment returns raw response.data; actual comment may be nested in .data
+        const comment = envelope.data.data ?? envelope.data;
+        expect(comment).toHaveProperty("id");
+        commentId = comment.id;
+    });
+    it("comment-list returns comments for page", async () => {
+        const result = await runCli(["comment-list", "--page-id", pageId], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+        expect(Array.isArray(envelope.data)).toBe(true);
+        expect(envelope.data.length).toBeGreaterThanOrEqual(1);
+    });
+    it("comment-info returns comment details", async () => {
+        const result = await runCli(["comment-info", "--comment-id", commentId], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+        expect(envelope.data.id).toBe(commentId);
+    });
+    it("comment-delete deletes the comment", async () => {
+        const result = await runCli(["comment-delete", "--comment-id", commentId], env);
+        expect(result.exitCode).toBe(0);
+    });
+    afterAll(async () => {
+        if (spaceId) {
+            await runCli(["space-delete", "--space-id", spaceId], env);
+        }
+    });
+});

package/build/__tests__/integration/discovery.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { runCli, parseEnvelope } from "./helpers/run-cli.js";
+describe("commands discovery", () => {
+    it("returns envelope with all commands", async () => {
+        // Discovery doesn't need auth
+        const result = await runCli(["commands"], {});
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+        expect(Array.isArray(envelope.data)).toBe(true);
+        expect(envelope.data.length).toBeGreaterThan(50);
+        expect(envelope.meta).toEqual({ count: envelope.data.length, hasMore: false });
+    });
+    it("each command has name, description, options", async () => {
+        const result = await runCli(["commands"], {});
+        const envelope = parseEnvelope(result);
+        for (const cmd of envelope.data) {
+            expect(cmd).toHaveProperty("name");
+            expect(cmd).toHaveProperty("description");
+            expect(cmd).toHaveProperty("options");
+            expect(Array.isArray(cmd.options)).toBe(true);
+        }
+    });
+});

package/build/__tests__/integration/file.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { writeFileSync, mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { runCli, parseEnvelope, testEnv } from "./helpers/run-cli.js";
+const env = testEnv();
+describe("file commands", () => {
+    let spaceId;
+    let pageId;
+    let tmpDir;
+    beforeAll(async () => {
+        const spaceResult = await runCli(["space-create", "--name", `filespace${Date.now()}`, "--slug", `fs${Date.now()}`], env);
+        spaceId = parseEnvelope(spaceResult).data.id;
+        const pageResult = await runCli(["page-create", "--space-id", spaceId, "--title", "File Test Page"], env);
+        pageId = parseEnvelope(pageResult).data.id;
+        // Create a temp file for upload
+        tmpDir = mkdtempSync(join(tmpdir(), "docmost-test-"));
+        writeFileSync(join(tmpDir, "test.txt"), "Hello from integration test");
+    });
+    it("file-upload uploads a file", async () => {
+        const result = await runCli(["file-upload", "--page-id", pageId, "--file", join(tmpDir, "test.txt")], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+    });
+    afterAll(async () => {
+        if (tmpDir)
+            rmSync(tmpDir, { recursive: true, force: true });
+        if (spaceId) {
+            await runCli(["space-delete", "--space-id", spaceId], env);
+        }
+    });
+});

package/build/__tests__/integration/group.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { runCli, parseEnvelope, testEnv } from "./helpers/run-cli.js";
+const env = testEnv();
+describe("group commands", () => {
+    let groupId;
+    const groupName = `testgroup${Date.now()}`;
+    it("group-create creates a group", async () => {
+        const result = await runCli(["group-create", "--name", groupName], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+        expect(envelope.data).toHaveProperty("id");
+        groupId = envelope.data.id;
+    });
+    it("group-list includes created group", async () => {
+        const result = await runCli(["group-list"], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+        const names = envelope.data.map((g) => g.name);
+        expect(names).toContain(groupName);
+    });
+    it("group-info returns group details", async () => {
+        const result = await runCli(["group-info", "--group-id", groupId], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+        expect(envelope.data.id).toBe(groupId);
+    });
+    it("group-update changes name", async () => {
+        const newName = `${groupName}-updated`;
+        const result = await runCli(["group-update", "--group-id", groupId, "--name", newName], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+    });
+    it("group-member-list returns members", async () => {
+        const result = await runCli(["group-member-list", "--group-id", groupId], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+    });
+    afterAll(async () => {
+        if (groupId) {
+            await runCli(["group-delete", "--group-id", groupId], env);
+        }
+    });
+});

package/build/__tests__/integration/helpers/global-setup.js

@@ -0,0 +1,80 @@
+import { writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import axios from "axios";
+/** DOCMOST_TEST_URL should include /api suffix (e.g. http://localhost:4010/api)
+ *  because that's what the CLI client expects. We strip it for direct API calls. */
+const API_URL = process.env.DOCMOST_TEST_URL || "http://localhost:4010/api";
+const ROOT_URL = API_URL.replace(/\/api\/?$/, "");
+const EMAIL = process.env.DOCMOST_TEST_EMAIL || "test@example.com";
+const PASSWORD = process.env.DOCMOST_TEST_PASSWORD || "TestPassword123!";
+const WORKSPACE_NAME = "CLI Integration Tests";
+/** Shared file path for token — globalSetup runs in a separate process,
+ *  so process.env changes are NOT visible in test workers.
+ *  We write the token to a file and read it in testEnv(). */
+export const TOKEN_FILE = join(tmpdir(), "docmost-test-token");
+export async function setup() {
+    // Check if Docmost is reachable
+    try {
+        const health = await axios.get(`${ROOT_URL}/api/health`);
+        if (health.status !== 200) {
+            throw new Error(`Docmost health check failed: ${health.status}`);
+        }
+    }
+    catch (err) {
+        throw new Error(`Cannot reach Docmost at ${ROOT_URL}. Is docker-compose running?\n` +
+            `Run: docker compose -f docker-compose.test.yml up -d\n` +
+            `Original error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+    // Try to setup workspace (first-run) or skip if already done
+    try {
+        await axios.post(`${ROOT_URL}/api/auth/setup`, {
+            workspaceName: WORKSPACE_NAME,
+            name: "Test User",
+            email: EMAIL,
+            password: PASSWORD,
+        });
+        console.log("[global-setup] Created workspace and admin user");
+    }
+    catch (err) {
+        const status = axios.isAxiosError(err) ? err.response?.status : null;
+        if (status === 400 || status === 403) {
+            const msg = axios.isAxiosError(err) ? err.response?.data?.message : "";
+            console.log(`[global-setup] Setup skipped (${status}): ${msg || "workspace likely already exists"}`);
+        }
+        else {
+            throw err;
+        }
+    }
+    // Login to get token — Docmost returns token in Set-Cookie header, not body
+    let loginResp;
+    try {
+        loginResp = await axios.post(`${ROOT_URL}/api/auth/login`, {
+            email: EMAIL,
+            password: PASSWORD,
+        });
+    }
+    catch (err) {
+        throw new Error(`Login failed for ${EMAIL} at ${ROOT_URL}: ${err instanceof Error ? err.message : err}`, { cause: err });
+    }
+    const cookies = loginResp.headers["set-cookie"];
+    const authCookie = cookies?.find((c) => c.startsWith("authToken="));
+    const token = authCookie?.split(";")[0].split("=")[1];
+    if (!token) {
+        throw new Error("Failed to obtain auth token from login response. " +
+            `Cookies: ${JSON.stringify(cookies)}`);
+    }
+    // Write token to shared file so test workers can read it
+    writeFileSync(TOKEN_FILE, token, "utf-8");
+    console.log("[global-setup] Obtained auth token, wrote to", TOKEN_FILE);
+}
+export async function teardown() {
+    try {
+        rmSync(TOKEN_FILE);
+    }
+    catch (err) {
+        if (err?.code !== "ENOENT") {
+            console.warn("[global-setup] Failed to remove token file:", err.message);
+        }
+    }
+}

package/build/__tests__/integration/helpers/run-cli.js

@@ -0,0 +1,163 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { Command } from "commander";
+import { normalizeError, printError, isCommanderHelpExit, } from "../../../lib/cli-utils.js";
+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";
+function buildProgram(stdout, stderr) {
+    const program = new Command()
+        .name("docmost")
+        .exitOverride()
+        .configureOutput({
+        writeOut: (str) => stdout.push(str),
+        writeErr: (str) => stderr.push(str),
+    });
+    // Global options matching src/index.ts
+    program
+        .option("-u, --api-url <url>", "Docmost API URL")
+        .option("-e, --email <email>", "Docmost account email")
+        .option("--password <password>", "Docmost account password")
+        .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");
+    registerPageCommands(program);
+    registerWorkspaceCommands(program);
+    registerInviteCommands(program);
+    registerUserCommands(program);
+    registerSpaceCommands(program);
+    registerGroupCommands(program);
+    registerCommentCommands(program);
+    registerShareCommands(program);
+    registerFileCommands(program);
+    registerSearchCommands(program);
+    registerDiscoveryCommands(program);
+    return program;
+}
+/**
+ * Run a CLI command programmatically and capture output.
+ * NOTE: Mutates process.env and monkey-patches console/stdout — not concurrency-safe.
+ * Requires vitest config: fileParallelism: false, sequence.concurrent: false.
+ *
+ * @param args - CLI arguments (e.g., ["page-list", "--space-id", "abc"])
+ * @param env  - Extra env vars for this invocation
+ */
+export async function runCli(args, env = {}) {
+    const stdout = [];
+    const stderr = [];
+    // Save and override env
+    const savedEnv = {};
+    for (const [k, v] of Object.entries(env)) {
+        savedEnv[k] = process.env[k];
+        process.env[k] = v;
+    }
+    // Intercept console
+    const origLog = console.log;
+    const origError = console.error;
+    const origTable = console.table;
+    const origStdoutWrite = process.stdout.write;
+    const origStderrWrite = process.stderr.write;
+    console.log = (...a) => stdout.push(a.map(String).join(" "));
+    console.error = (...a) => stderr.push(a.map(String).join(" "));
+    console.table = (...a) => stdout.push(JSON.stringify(a));
+    process.stdout.write = ((chunk) => {
+        stdout.push(chunk);
+        return true;
+    });
+    process.stderr.write = ((chunk) => {
+        stderr.push(chunk);
+        return true;
+    });
+    let exitCode = 0;
+    try {
+        const program = buildProgram(stdout, stderr);
+        await program.parseAsync(["node", "docmost", ...args]);
+    }
+    catch (error) {
+        if (isCommanderHelpExit(error)) {
+            exitCode = 0;
+        }
+        else {
+            // Simplified error handling (always JSON — tests use default format)
+            const normalized = normalizeError(error);
+            printError(normalized, "json");
+            exitCode = normalized.exitCode;
+        }
+    }
+    finally {
+        // Restore
+        console.log = origLog;
+        console.error = origError;
+        console.table = origTable;
+        process.stdout.write = origStdoutWrite;
+        process.stderr.write = origStderrWrite;
+        for (const [k, v] of Object.entries(savedEnv)) {
+            if (v === undefined)
+                delete process.env[k];
+            else
+                process.env[k] = v;
+        }
+    }
+    return {
+        stdout: stdout.join("\n"),
+        stderr: stderr.join("\n"),
+        exitCode,
+    };
+}
+/** Parse JSON envelope from CLI output (tries stdout first, then stderr) */
+export function parseEnvelope(result) {
+    const source = result.stdout.trim() || result.stderr.trim();
+    if (!source) {
+        throw new Error(`Empty CLI output (exitCode=${result.exitCode}). ` +
+            `stdout=${JSON.stringify(result.stdout)}, stderr=${JSON.stringify(result.stderr)}`);
+    }
+    try {
+        return JSON.parse(source);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse CLI output as JSON (exitCode=${result.exitCode}): ${source.slice(0, 500)}`, { cause: err });
+    }
+}
+/** Get test server URL from env */
+export function testUrl() {
+    return process.env.DOCMOST_TEST_URL || "http://localhost:4010/api";
+}
+/** Must match TOKEN_FILE in global-setup.ts (duplicated to avoid ESM import issues) */
+const TOKEN_FILE = join(tmpdir(), "docmost-test-token");
+/** Read token written by global-setup (runs in a separate process) */
+function readTestToken() {
+    try {
+        return readFileSync(TOKEN_FILE, "utf-8").trim();
+    }
+    catch (err) {
+        if (err?.code !== "ENOENT") {
+            throw new Error(`Failed to read test token from ${TOKEN_FILE}: ${err.message}`);
+        }
+        const envToken = process.env.DOCMOST_TEST_TOKEN;
+        if (!envToken) {
+            throw new Error("No test token available. Global setup may have failed. " +
+                `Check that global-setup.ts ran successfully or set DOCMOST_TEST_TOKEN.`);
+        }
+        return envToken;
+    }
+}
+/** Get test credentials env vars for runCli */
+export function testEnv() {
+    return {
+        DOCMOST_API_URL: testUrl(),
+        DOCMOST_TOKEN: readTestToken(),
+        DOCMOST_EMAIL: process.env.DOCMOST_TEST_EMAIL || "",
+        DOCMOST_PASSWORD: process.env.DOCMOST_TEST_PASSWORD || "",
+    };
+}

package/build/__tests__/integration/invite.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { runCli, parseEnvelope, testEnv } from "./helpers/run-cli.js";
+const env = testEnv();
+describe("invite commands", () => {
+    let inviteId;
+    const inviteEmail = `invite-${Date.now()}@example.com`;
+    it("invite-create sends an invite", async () => {
+        const result = await runCli(["invite-create", "--emails", inviteEmail, "--role", "member"], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+    });
+    it("invite-list includes the invite", async () => {
+        const result = await runCli(["invite-list"], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+        expect(Array.isArray(envelope.data)).toBe(true);
+        const invite = envelope.data.find((i) => i.email === inviteEmail);
+        expect(invite).toBeDefined();
+        inviteId = invite.id;
+    });
+    it("invite-info returns invite details", async () => {
+        const result = await runCli(["invite-info", "--invitation-id", inviteId], env);
+        expect(result.exitCode).toBe(0);
+        const envelope = parseEnvelope(result);
+        expect(envelope.ok).toBe(true);
+        expect(envelope.data.email).toBe(inviteEmail);
+    });
+    it("invite-revoke revokes the invite", async () => {
+        const result = await runCli(["invite-revoke", "--invitation-id", inviteId], env);
+        expect(result.exitCode).toBe(0);
+    });
+});