@cloudglab/confluence-cli 0.0.1

package/dist/core/value.js

@@ -0,0 +1,19 @@
+export function firstString(...values) {
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const trimmed = value.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    for (const value of values) {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            continue;
+        return String(value);
+    }
+    return undefined;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=value.js.map

package/dist/core/write-guard.d.ts

@@ -0,0 +1,25 @@
+export interface WriteGuardInput {
+    action: string;
+    confirm?: boolean;
+    payload: unknown;
+}
+export interface WritePreview {
+    ok: false;
+    preview: true;
+    reason: string;
+    action: string;
+    payload: unknown;
+}
+export interface UnsupportedWriteDiagnostic {
+    ok: false;
+    supported: false;
+    error: string;
+    action: string;
+    diagnostic: string;
+    payload: unknown;
+}
+export declare function isWriteEnabled(): boolean;
+export declare function getWritePreview(input: WriteGuardInput, reason: string): WritePreview;
+export declare function getUnsupportedWriteDiagnostic(input: WriteGuardInput, diagnostic: string): UnsupportedWriteDiagnostic;
+export declare function assertWriteAllowed(input: WriteGuardInput): void;
+export declare function previewOrAssertWriteAllowed(input: WriteGuardInput): WritePreview | UnsupportedWriteDiagnostic | null;

package/dist/core/write-guard.js

@@ -0,0 +1,49 @@
+const UNSUPPORTED_WRITE_ACTIONS = {};
+export function isWriteEnabled() {
+    return process.env.CONFLUENCE_DISABLE_WRITE !== "true";
+}
+export function getWritePreview(input, reason) {
+    return {
+        ok: false,
+        preview: true,
+        reason,
+        action: input.action,
+        payload: input.payload,
+    };
+}
+export function getUnsupportedWriteDiagnostic(input, diagnostic) {
+    return {
+        ok: false,
+        supported: false,
+        error: `写操作 ${input.action} 当前不能真实执行`,
+        action: input.action,
+        diagnostic,
+        payload: input.payload,
+    };
+}
+export function assertWriteAllowed(input) {
+    const unsupportedReason = UNSUPPORTED_WRITE_ACTIONS[input.action];
+    if (unsupportedReason) {
+        throw new Error(`写操作 ${input.action} 当前不支持真实执行：${unsupportedReason}`);
+    }
+    if (!isWriteEnabled()) {
+        throw new Error(`写操作已禁用。若要执行 ${input.action}，需要移除 CONFLUENCE_DISABLE_WRITE=true。`);
+    }
+    if (input.confirm !== true) {
+        throw new Error(`写操作缺少确认。若要执行 ${input.action}，需要传入 confirm: true。`);
+    }
+}
+export function previewOrAssertWriteAllowed(input) {
+    const unsupportedReason = UNSUPPORTED_WRITE_ACTIONS[input.action];
+    if (unsupportedReason) {
+        return getUnsupportedWriteDiagnostic(input, unsupportedReason);
+    }
+    if (!isWriteEnabled()) {
+        return getWritePreview(input, `写操作已禁用。若要执行 ${input.action}，需要移除 CONFLUENCE_DISABLE_WRITE=true。`);
+    }
+    if (input.confirm !== true) {
+        return getWritePreview(input, `写操作缺少确认。若要执行 ${input.action}，需要传入 confirm: true。`);
+    }
+    return null;
+}
+//# sourceMappingURL=write-guard.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ConfluenceApi } from "./api/index.js";
+export { runCli } from "./cli.js";
+export type { ConfluenceConfig, JsonContentResult, Role } from "./types/common.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { ConfluenceApi } from "./api/index.js";
+export { runCli } from "./cli.js";
+//# sourceMappingURL=index.js.map

package/dist/install.d.ts

@@ -0,0 +1,3 @@
+export declare function runInstallCommand(args?: string[]): Promise<void>;
+export declare function runUpdateCommand(args?: string[]): Promise<void>;
+export declare function runUninstallCommand(args?: string[]): Promise<void>;

package/dist/install.js

@@ -0,0 +1,407 @@
+import { spawn } from "node:child_process";
+import { access, mkdtemp, readdir, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { ConfluenceApi } from "./api/index.js";
+import { loadConfluenceConfig, normalizeConfig, saveConfig } from "./core/config.js";
+import { writeUpdateCacheAfterInstall } from "./update-probe.js";
+const PACKAGE_NAME = "@cloudglab/confluence-cli";
+const GIT_SKILL_SOURCE = "cloudglab/confluence-cli";
+export async function runInstallCommand(args = []) {
+    const options = parseInstallOptions(args);
+    await installPackageAndSkill("安装", options);
+    if (options.skipConfigCheck) {
+        printSuccessGuide("安装", "已跳过 Confluence 配置校验。");
+        return;
+    }
+    await ensureValidConfluenceConfig();
+    printSuccessGuide("安装", "Confluence 配置校验通过。");
+}
+export async function runUpdateCommand(args = []) {
+    const options = parseInstallOptions(args);
+    await installPackageAndSkill("更新", options);
+    if (options.skipConfigCheck) {
+        printSuccessGuide("更新", "已跳过 Confluence 配置校验。");
+        return;
+    }
+    await ensureValidConfluenceConfig();
+    printSuccessGuide("更新", "Confluence 配置校验通过。");
+}
+export async function runUninstallCommand(args = []) {
+    const options = parseUninstallOptions(args);
+    if (!options.confirm) {
+        printUninstallPreview(options);
+        return;
+    }
+    if (!options.cliOnly) {
+        await uninstallSkill();
+    }
+    if (!options.skillOnly) {
+        await uninstallPackage();
+    }
+    if (shouldRemoveConfig(options)) {
+        await removeConfigFile();
+    }
+    process.stdout.write("\n卸载完成。\n");
+}
+function printSuccessGuide(action, status) {
+    process.stdout.write(`\n${action}完成，${status}\n\n${renderBanner()}\n\n`);
+    process.stdout.write(`快速开始：
+  confluence help                         查看帮助
+  confluence list                         查看可用命令
+  confluence searchContent --limit 10     查询页面
+  confluence listRestApis --limit 20      查看 REST API 模板
+
+常用配置：
+  confluence update                       更新 CLI 和 Skill
+  confluence install --skip-config-check  仅安装，跳过配置校验
+  CONFLUENCE_DISABLE_WRITE=true           禁用真实写操作
+
+写操作提示：真实写入仍需显式传 confirm=true。
+`);
+}
+function parseInstallOptions(args) {
+    let skillSource = "local";
+    let skillLocalPath;
+    let skipConfigCheck = false;
+    let cliOnly = false;
+    let skillOnly = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--skill-source" || arg.startsWith("--skill-source=")) {
+            const value = readRequiredOptionValue(args, index, "--skill-source");
+            if (value !== "local" && value !== "git" && value !== "npm") {
+                throw new Error("--skill-source 只支持 local、git 或 npm");
+            }
+            skillSource = value;
+            if (arg === "--skill-source")
+                index += 1;
+            continue;
+        }
+        if (arg === "--skill-local-path" || arg.startsWith("--skill-local-path=")) {
+            skillLocalPath = readRequiredOptionValue(args, index, "--skill-local-path");
+            if (arg === "--skill-local-path")
+                index += 1;
+            continue;
+        }
+        if (arg === "--skip-config-check" || arg.startsWith("--skip-config-check=")) {
+            const parsed = readBooleanFlag(args, index, "--skip-config-check");
+            skipConfigCheck = parsed.value;
+            index += parsed.consumedArgs;
+            continue;
+        }
+        if (arg === "--cli-only" || arg.startsWith("--cli-only=")) {
+            const parsed = readBooleanFlag(args, index, "--cli-only");
+            cliOnly = parsed.value;
+            index += parsed.consumedArgs;
+            continue;
+        }
+        if (arg === "--skill-only" || arg.startsWith("--skill-only=")) {
+            const parsed = readBooleanFlag(args, index, "--skill-only");
+            skillOnly = parsed.value;
+            index += parsed.consumedArgs;
+            continue;
+        }
+        throw new Error(`未知安装参数: ${arg}`);
+    }
+    if (cliOnly && skillOnly) {
+        throw new Error("--cli-only 和 --skill-only 不能同时使用");
+    }
+    return { skillSource, skillLocalPath, skipConfigCheck, cliOnly, skillOnly };
+}
+function parseUninstallOptions(args) {
+    let confirm = false;
+    let keepConfig = false;
+    let cliOnly = false;
+    let skillOnly = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--confirm" || arg.startsWith("--confirm=")) {
+            const parsed = readBooleanFlag(args, index, "--confirm");
+            confirm = parsed.value;
+            index += parsed.consumedArgs;
+            continue;
+        }
+        if (arg === "--keep-config" || arg.startsWith("--keep-config=")) {
+            const parsed = readBooleanFlag(args, index, "--keep-config");
+            keepConfig = parsed.value;
+            index += parsed.consumedArgs;
+            continue;
+        }
+        if (arg === "--cli-only" || arg.startsWith("--cli-only=")) {
+            const parsed = readBooleanFlag(args, index, "--cli-only");
+            cliOnly = parsed.value;
+            index += parsed.consumedArgs;
+            continue;
+        }
+        if (arg === "--skill-only" || arg.startsWith("--skill-only=")) {
+            const parsed = readBooleanFlag(args, index, "--skill-only");
+            skillOnly = parsed.value;
+            index += parsed.consumedArgs;
+            continue;
+        }
+        throw new Error(`未知卸载参数: ${arg}`);
+    }
+    if (cliOnly && skillOnly) {
+        throw new Error("--cli-only 和 --skill-only 不能同时使用");
+    }
+    return { confirm, keepConfig, cliOnly, skillOnly };
+}
+function printUninstallPreview(options) {
+    const steps = [
+        ...(!options.cliOnly ? ["卸载 confluence skill（项目级和全局级）"] : []),
+        ...(!options.skillOnly ? ["卸载全局 CLI 包并清理 npm 残留目录"] : []),
+        ...(shouldRemoveConfig(options) ? ["删除 ~/.confluence/config.json"] : ["保留 ~/.confluence/config.json"]),
+    ];
+    process.stdout.write(`卸载预览：\n${steps.map((step) => `  - ${step}`).join("\n")}\n\n真实执行请运行：\n  confluence uninstall --confirm true\n  npx -y ${PACKAGE_NAME}@latest uninstall --confirm true\n\n可选参数：\n  --keep-config true   保留 Confluence 配置\n  --cli-only true      只卸载 CLI\n  --skill-only true    只卸载 skill\n`);
+}
+function shouldRemoveConfig(options) {
+    return !options.keepConfig && !options.cliOnly && !options.skillOnly;
+}
+function createSkillAddArgs(source) {
+    return ["-y", "skills", "add", source, "--yes"];
+}
+function createSkillRemoveArgs(global = false) {
+    return ["-y", "skills", "remove", "confluence-cli", "--yes", ...(global ? ["--global"] : [])];
+}
+function readOptionValue(arg, optionName) {
+    const prefix = `${optionName}=`;
+    return arg.startsWith(prefix) ? arg.slice(prefix.length) : undefined;
+}
+function readRequiredOptionValue(args, index, optionName) {
+    const arg = args[index];
+    const inlineValue = readOptionValue(arg, optionName);
+    if (inlineValue !== undefined) {
+        if (inlineValue.trim() === "") {
+            throw createMissingOptionValueError(optionName);
+        }
+        return inlineValue;
+    }
+    const next = args[index + 1];
+    if (typeof next !== "string" || next.startsWith("--")) {
+        throw createMissingOptionValueError(optionName);
+    }
+    return next;
+}
+function createMissingOptionValueError(optionName) {
+    if (optionName === "--skill-local-path") {
+        return new Error("--skill-local-path 需要传入本地目录路径");
+    }
+    return new Error(`${optionName} 需要传入参数值`);
+}
+function readBooleanFlag(args, index, optionName) {
+    const inlineValue = readOptionValue(args[index], optionName);
+    if (inlineValue !== undefined)
+        return { value: parseBooleanValue(inlineValue, optionName), consumedArgs: 0 };
+    const next = args[index + 1];
+    if (typeof next === "string" && !next.startsWith("--")) {
+        return { value: parseBooleanValue(next, optionName), consumedArgs: 1 };
+    }
+    return { value: true, consumedArgs: 0 };
+}
+function parseBooleanValue(value, optionName) {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes", "y", "on"].includes(normalized))
+        return true;
+    if (["false", "0", "no", "n", "off"].includes(normalized))
+        return false;
+    throw new Error(`${optionName} 只支持 true 或 false`);
+}
+async function installPackageAndSkill(action, options) {
+    if (!options.skillOnly) {
+        await cleanupGlobalPackageResidues();
+        await installGlobalCli(action);
+    }
+    if (!options.cliOnly) {
+        await installSkill(action, options);
+    }
+    await writeUpdateCacheAfterInstall();
+}
+async function installGlobalCli(action) {
+    const args = ["install", "-g", `${PACKAGE_NAME}@latest`];
+    try {
+        await runStep(`${action} Confluence CLI`, "npm", args);
+    }
+    catch (error) {
+        if (!isNpmDirectoryNotEmptyError(error)) {
+            throw error;
+        }
+        process.stdout.write("\n检测到 npm 全局安装目录残留，正在清理后重试...\n");
+        await cleanupGlobalPackageResidues();
+        await runStep(`${action} Confluence CLI`, "npm", args);
+    }
+}
+function isNpmDirectoryNotEmptyError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("ENOTEMPTY") || message.toLowerCase().includes("directory not empty");
+}
+async function runNpxStepWithRetry(title, args) {
+    try {
+        await runStep(title, "npx", args);
+    }
+    catch (error) {
+        if (!isNpmDirectoryNotEmptyError(error)) {
+            throw error;
+        }
+        process.stdout.write(`\n检测到 npx 缓存目录残留，正在清理后重试 ${title}...\n`);
+        await cleanupNpxResidues();
+        await runStep(title, "npx", args);
+    }
+}
+async function installSkill(action, options) {
+    if (options.skillLocalPath) {
+        await runNpxStepWithRetry(`${action} Confluence skill`, createSkillAddArgs(path.resolve(options.skillLocalPath)));
+        return;
+    }
+    if (options.skillSource === "local") {
+        await installSkillFromInstalledPackage(action);
+        return;
+    }
+    if (options.skillSource === "git") {
+        await runNpxStepWithRetry(`${action} Confluence skill`, createSkillAddArgs(GIT_SKILL_SOURCE));
+        return;
+    }
+    await installSkillFromNpmPackage(action);
+}
+async function installSkillFromInstalledPackage(action) {
+    const skillPath = await getInstalledPackageSkillPath();
+    try {
+        await access(skillPath);
+    }
+    catch {
+        throw new Error(`未找到已安装包内的 Confluence skill：${skillPath}。可重试 --skill-source npm 或 --skill-source git。`);
+    }
+    await runNpxStepWithRetry(`${action} Confluence skill`, createSkillAddArgs(skillPath));
+}
+async function getInstalledPackageSkillPath() {
+    const globalNodeModules = (await runCommandOutput("npm", ["root", "-g"])).trim();
+    if (!globalNodeModules)
+        throw new Error("npm root -g 没有返回全局 node_modules 路径");
+    return path.join(globalNodeModules, PACKAGE_NAME, "skills", "confluence-cli");
+}
+async function installSkillFromNpmPackage(action) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "confluence-cli-skill-"));
+    try {
+        const stdout = await runCommandOutput("npm", ["pack", `${PACKAGE_NAME}@latest`, "--pack-destination", tempDir, "--silent"]);
+        const tarballName = stdout.trim().split("\n").filter(Boolean).at(-1);
+        if (!tarballName)
+            throw new Error("npm pack 没有返回包文件名");
+        await runStep("解压 Confluence npm 包", "tar", ["-xzf", path.join(tempDir, tarballName), "-C", tempDir]);
+        await runNpxStepWithRetry(`${action} Confluence skill`, createSkillAddArgs(path.join(tempDir, "package")));
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+async function uninstallSkill() {
+    await runNpxStepWithRetry("卸载项目级 Confluence skill", createSkillRemoveArgs(false));
+    await runNpxStepWithRetry("卸载全局级 Confluence skill", createSkillRemoveArgs(true));
+}
+async function uninstallPackage() {
+    await runStep("卸载 Confluence CLI", "npm", ["uninstall", "-g", PACKAGE_NAME]);
+    await cleanupGlobalPackageResidues();
+}
+async function cleanupGlobalPackageResidues() {
+    const globalNodeModules = (await runCommandOutput("npm", ["root", "-g"])).trim();
+    if (globalNodeModules) {
+        await rm(path.join(globalNodeModules, PACKAGE_NAME), { recursive: true, force: true });
+        const scopeDir = path.join(globalNodeModules, "@cloudglab");
+        let entries = [];
+        try {
+            entries = await readdir(scopeDir);
+        }
+        catch {
+            entries = [];
+        }
+        await Promise.all(entries
+            .filter((entry) => entry.startsWith(".confluence-cli-"))
+            .map((entry) => rm(path.join(scopeDir, entry), { recursive: true, force: true })));
+    }
+    await cleanupNpxResidues();
+}
+async function cleanupNpxResidues() {
+    const npxCacheDir = path.join(os.homedir(), ".npm", "_npx");
+    let entries = [];
+    try {
+        entries = await readdir(npxCacheDir);
+    }
+    catch {
+        return;
+    }
+    await Promise.all(entries.map(async (entry) => {
+        const hashDir = path.join(npxCacheDir, entry);
+        const cloudglabDir = path.join(hashDir, "node_modules", "@cloudglab");
+        let cloudglabEntries = [];
+        try {
+            cloudglabEntries = await readdir(cloudglabDir);
+        }
+        catch {
+            return;
+        }
+        const hasConfluenceCli = cloudglabEntries.some((item) => item === "confluence-cli" || item.startsWith(".confluence-cli-"));
+        if (hasConfluenceCli) {
+            await rm(hashDir, { recursive: true, force: true });
+        }
+    }));
+}
+async function removeConfigFile() {
+    await rm(path.join(os.homedir(), ".confluence", "config.json"), { force: true });
+}
+async function ensureValidConfluenceConfig() {
+    const config = loadConfluenceConfig();
+    const api = new ConfluenceApi(config);
+    await api.getCurrentUser();
+    saveConfig(normalizeConfig(config));
+}
+async function runStep(title, command, args) {
+    process.stdout.write(`\n${title}...\n`);
+    await runCommand(command, args);
+}
+function runCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { shell: process.platform === "win32" });
+        let stderr = "";
+        child.stdout?.pipe(process.stdout);
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+            process.stderr.write(chunk);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${command} ${args.join(" ")} 执行失败，退出码 ${String(code)}${stderr ? `：${stderr.trim()}` : ""}`));
+        });
+    });
+}
+function runCommandOutput(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { shell: process.platform === "win32" });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => { stdout += chunk.toString("utf8"); });
+        child.stderr?.on("data", (chunk) => { stderr += chunk.toString("utf8"); });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve(stdout);
+                return;
+            }
+            reject(new Error(`${command} ${args.join(" ")} 执行失败，退出码 ${String(code)}${stderr ? `：${stderr.trim()}` : ""}`));
+        });
+    });
+}
+function renderBanner() {
+    return [
+        "   ___       ___       ___       ___       ___       ___       ___       ___       ___       ___   ",
+        "  /\\  \\     /\\  \\     /\\__\\     /\\  \\     /\\__\\     /\\__\\     /\\  \\     /\\__\\     /\\  \\     /\\  \\  ",
+        " /::\\  \\   /::\\  \\   /:| _|_   /::\\  \\   /:/  /    /:/ _/_   /::\\  \\   /:| _|_   /::\\  \\   /::\\  \\ ",
+        "/:/\\:\\__\\ /:/\\:\\__\\ /::|/\\__\\ /::\\:\\__\\ /:/__/    /:/_/\\__\\ /::\\:\\__\\ /::|/\\__\\ /:/\\:\\__\\ /::\\:\\__\\",
+        "\\:\\ \/__/ \\:\\/:/  / \\/|::/  / \\/\\:\\/__/ \\:\\  \\    \\:\\/:/  / \\:\\:\\/  / \\/|::/  / \\:\\ \/__/ \\:\\:\\/  /",
+        " \\:\\__\\    \\::/  /    |:/  /     \/__/   \\:\\__\\    \\::/  /   \\:\\/  /    |:/  /   \\:\\__\\    \\:\\/  / ",
+        "  \/__/     \/__/     \/__/               \/__/     \/__/     \/__/     \/__/     \/__/     \/__/ ",
+    ].join("\n");
+}
+//# sourceMappingURL=install.js.map

package/dist/manifest.json

@@ -0,0 +1,122 @@
+{
+  "version": "0.0.1",
+  "commands": [
+    "addComment",
+    "addLabels",
+    "callRestApi",
+    "convertContentBody",
+    "convertMarkdownToWiki",
+    "convertMermaidToDrawio",
+    "deleteContent",
+    "deleteLabel",
+    "downloadAttachment",
+    "downloadPage",
+    "findContent",
+    "generateMarkMetadata",
+    "getComments",
+    "getContent",
+    "getCurrentUser",
+    "getLabels",
+    "getPageChildren",
+    "getSpace",
+    "initConfluence",
+    "install",
+    "listAttachments",
+    "listRestApis",
+    "listSpaces",
+    "remove",
+    "searchContent",
+    "uninstall",
+    "update",
+    "updateAttachment",
+    "uploadAttachment",
+    "uploadHtml",
+    "uploadMarkdown"
+  ],
+  "groups": {
+    "init": [
+      "initConfluence"
+    ],
+    "install": [
+      "install",
+      "remove",
+      "uninstall",
+      "update"
+    ],
+    "convert": [
+      "convertMarkdownToWiki",
+      "convertMermaidToDrawio"
+    ],
+    "metadata": [
+      "generateMarkMetadata"
+    ],
+    "rest": [
+      "callRestApi",
+      "listRestApis"
+    ],
+    "space": [
+      "convertContentBody",
+      "getCurrentUser",
+      "getSpace",
+      "listSpaces"
+    ],
+    "content": [
+      "addComment",
+      "deleteContent",
+      "findContent",
+      "getComments",
+      "getContent",
+      "getPageChildren",
+      "searchContent"
+    ],
+    "labels": [
+      "addLabels",
+      "deleteLabel",
+      "getLabels"
+    ],
+    "attachments": [
+      "downloadAttachment",
+      "listAttachments",
+      "updateAttachment",
+      "uploadAttachment"
+    ],
+    "transfer": [
+      "downloadPage",
+      "uploadHtml",
+      "uploadMarkdown"
+    ]
+  },
+  "commandToGroup": {
+    "initConfluence": "init",
+    "install": "install",
+    "remove": "install",
+    "uninstall": "install",
+    "update": "install",
+    "convertMarkdownToWiki": "convert",
+    "convertMermaidToDrawio": "convert",
+    "generateMarkMetadata": "metadata",
+    "callRestApi": "rest",
+    "listRestApis": "rest",
+    "convertContentBody": "space",
+    "getCurrentUser": "space",
+    "getSpace": "space",
+    "listSpaces": "space",
+    "addComment": "content",
+    "deleteContent": "content",
+    "findContent": "content",
+    "getComments": "content",
+    "getContent": "content",
+    "getPageChildren": "content",
+    "searchContent": "content",
+    "addLabels": "labels",
+    "deleteLabel": "labels",
+    "getLabels": "labels",
+    "downloadAttachment": "attachments",
+    "listAttachments": "attachments",
+    "updateAttachment": "attachments",
+    "uploadAttachment": "attachments",
+    "downloadPage": "transfer",
+    "uploadHtml": "transfer",
+    "uploadMarkdown": "transfer"
+  }
+}

package/dist/tools/attachments.d.ts

@@ -0,0 +1,2 @@
+import type { CliRegistry } from "../core/cli-registry.js";
+export declare function registerAttachmentTools(registry: CliRegistry): void;