@cloudglab/confluence-cli 0.0.1

package/dist/tools/attachments.js

@@ -0,0 +1,46 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { z } from "zod";
+import { getApi } from "../core/api-provider.js";
+import { previewOrAssertWriteAllowed } from "../core/write-guard.js";
+import { jsonResult, textResult } from "../utils/result.js";
+export function registerAttachmentTools(registry) {
+    registry.tool("listAttachments", z.object({ id: z.coerce.string(), limit: z.number().int().positive().max(100).default(100) }), async ({ id, limit }) => {
+        return jsonResult(await getApi().listAttachments(id, limit));
+    }, "List page attachments");
+    registry.tool("uploadAttachment", z.object({ id: z.coerce.string(), file: z.string(), comment: z.string().optional(), minorEdit: z.boolean().default(true), confirm: z.boolean().default(false) }), async ({ id, file, comment, minorEdit, confirm }) => {
+        const preview = previewOrAssertWriteAllowed({ action: "uploadAttachment", confirm, payload: { id, file, comment, minorEdit } });
+        if (preview)
+            return jsonResult(preview);
+        return jsonResult(await getApi().uploadAttachment({ pageId: id, filename: basename(file), data: readFileSync(file), comment, minorEdit }));
+    }, "Upload an attachment to a page; requires confirm=true");
+    registry.tool("updateAttachment", z.object({ id: z.coerce.string(), attachmentId: z.coerce.string(), file: z.string(), comment: z.string().optional(), minorEdit: z.boolean().default(true), confirm: z.boolean().default(false) }), async ({ id, attachmentId, file, comment, minorEdit, confirm }) => {
+        const preview = previewOrAssertWriteAllowed({ action: "updateAttachment", confirm, payload: { id, attachmentId, file, comment, minorEdit } });
+        if (preview)
+            return jsonResult(preview);
+        return jsonResult(await getApi().updateAttachmentData({ pageId: id, attachmentId, filename: basename(file), data: readFileSync(file), comment, minorEdit }));
+    }, "Update attachment data; requires confirm=true");
+    registry.tool("downloadAttachment", z.object({ id: z.coerce.string(), attachmentId: z.coerce.string().optional(), title: z.string().optional(), outputDir: z.string().default(".") }).refine((input) => input.attachmentId || input.title, "Provide attachmentId or title"), async ({ id, attachmentId, title, outputDir }) => {
+        const targetDir = outputDir ?? ".";
+        const api = getApi();
+        const attachments = await api.listAttachments(id, 100);
+        const attachment = attachments.results.find((item) => matchesAttachment(item, attachmentId, title));
+        if (!attachment)
+            throw new Error("Attachment not found.");
+        const downloadPath = attachment._links?.download;
+        if (!downloadPath)
+            throw new Error("Attachment has no download link.");
+        mkdirSync(targetDir, { recursive: true });
+        const outputPath = join(targetDir, safeFileName(attachment.title));
+        const downloaded = await api.downloadAttachment(downloadPath);
+        writeFileSync(outputPath, downloaded.data);
+        return textResult(outputPath);
+    }, "Download one page attachment by id or title");
+}
+function matchesAttachment(attachment, attachmentId, title) {
+    return (attachmentId !== undefined && attachment.id === attachmentId) || (title !== undefined && attachment.title === title);
+}
+function safeFileName(value) {
+    return value.replace(/[\\/:*?"<>|]/g, "_");
+}
+//# sourceMappingURL=attachments.js.map

package/dist/tools/content.d.ts

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

package/dist/tools/content.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { getApi } from "../core/api-provider.js";
+import { previewOrAssertWriteAllowed } from "../core/write-guard.js";
+import { jsonResult } from "../utils/result.js";
+export function registerContentTools(registry) {
+    registry.tool("searchContent", z.object({ cql: z.string(), limit: z.number().int().positive().max(100).default(25) }), async ({ cql, limit }) => {
+        return jsonResult(await getApi().search(cql, limit));
+    }, "Search Confluence content with CQL");
+    registry.tool("getContent", z.object({ id: z.coerce.string(), expand: z.string().optional() }), async ({ id, expand }) => {
+        return jsonResult(await getApi().getContent(id, expand));
+    }, "Get one Confluence page/content by id");
+    registry.tool("findContent", z.object({ space: z.string().optional(), title: z.string().optional(), type: z.string().default("page"), limit: z.number().int().positive().max(100).default(25), expand: z.string().optional() }), async ({ space, title, type, limit, expand }) => {
+        return jsonResult(await getApi().findContent({ space, title, type, limit, expand }));
+    }, "Find content by title, space or type");
+    registry.tool("deleteContent", z.object({ id: z.coerce.string(), confirm: z.boolean().default(false) }), async ({ id, confirm }) => {
+        const preview = previewOrAssertWriteAllowed({ action: "deleteContent", confirm, payload: { id } });
+        if (preview)
+            return jsonResult(preview);
+        return jsonResult(await getApi().deleteContent(id));
+    }, "Delete Confluence content; requires confirm=true");
+    registry.tool("getPageChildren", z.object({ id: z.coerce.string(), type: z.string().optional(), expand: z.string().default("space,version"), limit: z.number().int().positive().max(100).default(25) }), async ({ id, type, expand, limit }) => {
+        return jsonResult(await getApi().getChildren(id, type, expand, limit));
+    }, "Get page children, optionally filtered by child type");
+    registry.tool("getComments", z.object({ id: z.coerce.string(), expand: z.string().default("body.storage,version"), limit: z.number().int().positive().max(100).default(25) }), async ({ id, expand, limit }) => {
+        return jsonResult(await getApi().getComments(id, expand, limit));
+    }, "Get page comments");
+    registry.tool("addComment", z.object({
+        id: z.coerce.string(),
+        body: z.string(),
+        inline: z.string().optional().describe("Selected text on the page to annotate (inline comment)"),
+        representation: z.enum(["wiki", "storage"]).default("wiki"),
+        confirm: z.boolean().default(false),
+    }), async ({ id, body, inline, representation, confirm }) => {
+        const bodyRepresentation = representation ?? "wiki";
+        const action = inline ? "addInlineComment" : "addComment";
+        const preview = previewOrAssertWriteAllowed({ action, confirm, payload: { id, inline: inline ?? undefined, representation: bodyRepresentation, bodyPreview: body.slice(0, 500) } });
+        if (preview)
+            return jsonResult(preview);
+        if (inline) {
+            return jsonResult(await getApi().addInlineComment({ pageId: id, selection: inline, body, representation: bodyRepresentation }));
+        }
+        return jsonResult(await getApi().addComment({ pageId: id, body, representation: bodyRepresentation }));
+    }, "Add a comment to a page; use --inline to annotate selected text; requires confirm=true");
+}
+//# sourceMappingURL=content.js.map

package/dist/tools/convert.d.ts

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

package/dist/tools/convert.js

@@ -0,0 +1,63 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
+import { z } from "zod";
+import { convert as convertDiagram } from "@whitebite/diagram-converter";
+import { markdownToWiki } from "../utils/markdown.js";
+import { jsonResult, textResult } from "../utils/result.js";
+export function registerConvertTools(registry) {
+    registry.tool("convertMarkdownToWiki", z.object({ file: z.string().optional(), text: z.string().optional() }).refine((input) => input.file || input.text, "Provide file or text"), ({ file, text }) => textResult(markdownToWiki(text ?? readFileSync(file, "utf8"))), "Convert Markdown to Confluence Wiki Markup");
+    registry.tool("convertMermaidToDrawio", z
+        .object({
+        file: z.string().optional(),
+        text: z.string().optional(),
+        output: z.string().optional(),
+        mode: z.enum(["auto", "mermaid", "markdown"]).default("auto"),
+    })
+        .refine((input) => input.file || input.text, "Provide file or text"), (input) => {
+        const sourceText = input.text ?? readFileSync(input.file, "utf8");
+        const mermaid = extractMermaidSource(sourceText, input.mode ?? "auto", input.file);
+        const converted = convertDiagram(mermaid, { from: "mermaid", to: "drawio", layout: { algorithm: "dagre" } });
+        const drawioXml = converted.output;
+        const outputPath = resolveOutputPath(input.output, input.file);
+        if (outputPath) {
+            mkdirSync(dirname(outputPath), { recursive: true });
+            writeFileSync(outputPath, drawioXml, "utf8");
+        }
+        return jsonResult({
+            outputPath,
+            bytes: Buffer.byteLength(drawioXml, "utf8"),
+            preview: outputPath ? undefined : drawioXml.slice(0, 2000),
+            warnings: converted.warnings ?? [],
+        });
+    }, "Convert Mermaid to draw.io .drawio file");
+}
+function extractMermaidSource(content, mode, file) {
+    if (mode === "mermaid")
+        return content.trim();
+    if (mode === "markdown" || isMarkdownFile(file) || /```\s*mermaid\b/i.test(content)) {
+        const block = findFirstMermaidBlock(content);
+        if (!block)
+            throw new Error("No mermaid fenced block found in markdown content.");
+        return block.trim();
+    }
+    return content.trim();
+}
+function findFirstMermaidBlock(content) {
+    const match = content.match(/```\s*mermaid\s*\n([\s\S]*?)```/i);
+    return match?.[1];
+}
+function isMarkdownFile(file) {
+    if (!file)
+        return false;
+    const suffix = extname(file).toLowerCase();
+    return suffix === ".md" || suffix === ".markdown" || suffix === ".mdown";
+}
+function resolveOutputPath(output, file) {
+    if (output)
+        return output;
+    if (!file)
+        return undefined;
+    const fileName = basename(file, extname(file));
+    return join(dirname(file), `${fileName}.drawio`);
+}
+//# sourceMappingURL=convert.js.map

package/dist/tools/init.d.ts

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

package/dist/tools/init.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { ConfluenceApi } from "../api/index.js";
+import { loadConfluenceConfig, maskConfig, normalizeConfig, saveConfig } from "../core/config.js";
+import { jsonResult } from "../utils/result.js";
+export function registerInitTools(registry) {
+    registry.tool("initConfluence", z.object({
+        url: z.string().optional().describe("Confluence 根域名，如 https://cf.cloudglab.cn"),
+        pat: z.string().optional().describe("Personal Access Token (Confluence 7.13.7 推荐)"),
+        username: z.string().optional().describe("用户名（Basic Auth 兼容）"),
+        password: z.string().optional().describe("密码（Basic Auth 兼容）"),
+        save: z.boolean().optional().default(false).describe("是否写入 ~/.confluence/config.json"),
+    }), async (input) => {
+        const config = input.url || input.pat || input.username
+            ? normalizeConfig({ url: input.url, personalToken: input.pat, username: input.username, password: input.password })
+            : loadConfluenceConfig();
+        if (input.save)
+            saveConfig(config);
+        // 验证连接有效
+        const api = new ConfluenceApi(config);
+        await api.getCurrentUser();
+        return jsonResult({ ok: true, saved: Boolean(input.save), config: maskConfig(config) });
+    });
+}
+//# sourceMappingURL=init.js.map

package/dist/tools/install.d.ts

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

package/dist/tools/install.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { runInstallCommand, runUninstallCommand, runUpdateCommand } from "../install.js";
+import { jsonResult } from "../utils/result.js";
+const installSchema = z.object({
+    "skill-source": z.enum(["local", "git", "npm"]).optional().default("local").describe("技能来源"),
+    "skill-local-path": z.string().optional().describe("本地 skill 目录"),
+    "skip-config-check": z.boolean().optional().default(false).describe("跳过配置校验"),
+    "cli-only": z.boolean().optional().default(false).describe("只安装 CLI"),
+    "skill-only": z.boolean().optional().default(false).describe("只安装 skill"),
+});
+const uninstallSchema = z.object({
+    confirm: z.boolean().optional().default(false).describe("确认真实卸载"),
+    "keep-config": z.boolean().optional().default(false).describe("保留本地配置"),
+    "cli-only": z.boolean().optional().default(false).describe("只卸载 CLI"),
+    "skill-only": z.boolean().optional().default(false).describe("只卸载 skill"),
+});
+export function registerInstallTools(registry) {
+    registry.tool("install", installSchema, async (input) => {
+        const args = toInstallArgs(input);
+        await runInstallCommand(args);
+        return jsonResult({ ok: true, command: "install", args });
+    }, "Install CLI and skill");
+    registry.tool("update", installSchema, async (input) => {
+        const args = toInstallArgs(input);
+        await runUpdateCommand(args);
+        return jsonResult({ ok: true, command: "update", args });
+    }, "Update CLI and skill");
+    registry.tool("uninstall", uninstallSchema, async (input) => {
+        const args = toInstallArgs(input);
+        await runUninstallCommand(args);
+        return jsonResult({ ok: true, command: "uninstall", args });
+    }, "Uninstall CLI and skill");
+    registry.tool("remove", uninstallSchema, async (input) => {
+        const args = toInstallArgs(input);
+        await runUninstallCommand(args);
+        return jsonResult({ ok: true, command: "remove", args });
+    }, "Remove CLI and skill");
+}
+function toInstallArgs(input) {
+    const args = [];
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value === "undefined")
+            continue;
+        if (typeof value === "boolean") {
+            args.push(`--${key}`, value ? "true" : "false");
+            continue;
+        }
+        args.push(`--${key}`, String(value));
+    }
+    return args;
+}
+//# sourceMappingURL=install.js.map

package/dist/tools/labels.d.ts

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

package/dist/tools/labels.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { getApi } from "../core/api-provider.js";
+import { previewOrAssertWriteAllowed } from "../core/write-guard.js";
+import { jsonResult } from "../utils/result.js";
+export function registerLabelTools(registry) {
+    registry.tool("getLabels", z.object({ id: z.coerce.string(), limit: z.number().int().positive().max(100).default(100) }), async ({ id, limit }) => {
+        return jsonResult(await getApi().getLabels(id, limit));
+    }, "Get labels for one page/content");
+    registry.tool("addLabels", z.object({ id: z.coerce.string(), labels: z.array(z.string()).min(1), confirm: z.boolean().default(false) }), async ({ id, labels, confirm }) => {
+        const preview = previewOrAssertWriteAllowed({ action: "addLabels", confirm, payload: { id, labels } });
+        if (preview)
+            return jsonResult(preview);
+        return jsonResult(await getApi().addLabels(id, labels));
+    }, "Add labels to one page/content; requires confirm=true");
+    registry.tool("deleteLabel", z.object({ id: z.coerce.string(), label: z.string(), confirm: z.boolean().default(false) }), async ({ id, label, confirm }) => {
+        const preview = previewOrAssertWriteAllowed({ action: "deleteLabel", confirm, payload: { id, label } });
+        if (preview)
+            return jsonResult(preview);
+        return jsonResult(await getApi().deleteLabel(id, label));
+    }, "Delete one label from page/content; requires confirm=true");
+}
+//# sourceMappingURL=labels.js.map

package/dist/tools/metadata.d.ts

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

package/dist/tools/metadata.js

@@ -0,0 +1,26 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { z } from "zod";
+import { parseMarkdown } from "../utils/markdown.js";
+import { createMarkMetadata, removeMarkMetadata } from "../utils/mark-metadata.js";
+import { textResult } from "../utils/result.js";
+export function registerMetadataTools(registry) {
+    registry.tool("generateMarkMetadata", z.object({
+        file: z.string(),
+        space: z.string(),
+        title: z.string().optional(),
+        parents: z.array(z.string()).optional(),
+        labels: z.array(z.string()).optional(),
+        attachments: z.array(z.string()).optional(),
+        write: z.boolean().default(false),
+    }), ({ file, space, title, parents, labels, attachments, write }) => {
+        const content = readFileSync(file, "utf8");
+        const parsed = parseMarkdown(content, basename(file, extname(file)));
+        const header = createMarkMetadata({ space, title: title ?? parsed.title, parents, labels, attachments });
+        if (!write)
+            return textResult(header);
+        writeFileSync(file, `${header}\n\n${removeMarkMetadata(content)}`);
+        return textResult(`Updated ${file}`);
+    }, "Generate or write mark-compatible metadata comments");
+}
+//# sourceMappingURL=metadata.js.map

package/dist/tools/rest.d.ts

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

package/dist/tools/rest.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { CONFLUENCE_7_13_7_ENDPOINTS, findEndpoint } from "../api/endpoints.js";
+import { getApi } from "../core/api-provider.js";
+import { previewOrAssertWriteAllowed } from "../core/write-guard.js";
+import { jsonResult } from "../utils/result.js";
+const jsonRecordSchema = z.record(z.unknown());
+export function registerRestTools(registry) {
+    registry.tool("listRestApis", z.object({ method: z.enum(["GET", "POST", "PUT", "DELETE"]).optional(), group: z.string().optional(), write: z.boolean().optional(), limit: z.number().int().positive().max(500).optional() }), ({ method, group, write, limit }) => {
+        const endpoints = CONFLUENCE_7_13_7_ENDPOINTS.filter((endpoint) => {
+            if (method && endpoint.method !== method)
+                return false;
+            if (group && endpoint.group !== group)
+                return false;
+            if (write !== undefined && endpoint.write !== write)
+                return false;
+            return true;
+        });
+        return jsonResult({ version: "7.13.7", total: endpoints.length, endpoints: limit ? endpoints.slice(0, limit) : endpoints });
+    }, "List Confluence 7.13.7 REST API endpoints");
+    registry.tool("callRestApi", z.object({
+        method: z.enum(["GET", "POST", "PUT", "DELETE"]),
+        path: z.string(),
+        pathParams: jsonRecordSchema.default({}),
+        query: jsonRecordSchema.default({}),
+        body: z.unknown().optional(),
+        confirm: z.boolean().default(false),
+    }), async (input) => {
+        const method = input.method;
+        const endpoint = findEndpoint(method, input.path);
+        if (!endpoint) {
+            throw new Error(`Unsupported Confluence 7.13.7 endpoint: ${method} ${input.path}. Use listRestApis to inspect supported templates.`);
+        }
+        const pathParams = input.pathParams ?? {};
+        const query = input.query ?? {};
+        const resolvedPath = applyPathParams(endpoint.path, pathParams);
+        if (endpoint.write) {
+            const preview = previewOrAssertWriteAllowed({ action: `callRestApi:${method} ${endpoint.path}`, confirm: input.confirm, payload: { method, path: endpoint.path, resolvedPath, query, body: input.body } });
+            if (preview)
+                return jsonResult(preview);
+        }
+        return jsonResult(await getApi().request(method, resolvedPath, query, input.body));
+    }, "Call any listed Confluence 7.13.7 REST API endpoint; writes require confirm=true");
+}
+function applyPathParams(path, params) {
+    return path.replace(/\{([^}]+)\}/g, (_match, key) => {
+        const value = params[key];
+        if (value === undefined || value === null || value === "")
+            throw new Error(`Missing path parameter: ${key}`);
+        return encodeURIComponent(String(value));
+    });
+}
+//# sourceMappingURL=rest.js.map

package/dist/tools/spaces.d.ts

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

package/dist/tools/spaces.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { getApi } from "../core/api-provider.js";
+import { jsonResult } from "../utils/result.js";
+export function registerSpaceTools(registry) {
+    registry.tool("listSpaces", z.object({ limit: z.number().int().positive().max(100).default(25) }), async ({ limit }) => {
+        return jsonResult(await getApi().listSpaces(limit));
+    }, "List Confluence spaces");
+    registry.tool("getSpace", z.object({ spaceKey: z.string() }), async ({ spaceKey }) => {
+        return jsonResult(await getApi().getSpace(spaceKey));
+    }, "Get one Confluence space by key");
+    registry.tool("getCurrentUser", z.object({}), async () => {
+        return jsonResult(await getApi().getCurrentUser());
+    }, "Get current authenticated Confluence user");
+    registry.tool("convertContentBody", z.object({ to: z.enum(["storage", "view", "export_view", "styled_view"]), value: z.string(), representation: z.enum(["wiki", "storage", "view"]).default("wiki") }), async ({ to, value, representation }) => {
+        return jsonResult(await getApi().convertBody(to, { value, representation: representation ?? "wiki" }));
+    }, "Convert Confluence content body representation");
+}
+//# sourceMappingURL=spaces.js.map

package/dist/tools/transfer.d.ts

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