@cloudglab/confluence-cli 0.0.1

package/dist/tools/transfer.js

@@ -0,0 +1,407 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { z } from "zod";
+import { ConfluenceApi } from "../api/index.js";
+import { loadConfluenceConfig } from "../core/config.js";
+import { previewOrAssertWriteAllowed } from "../core/write-guard.js";
+import { markdownToStorage, markdownToWiki, parseMarkdown, postProcessStorageHtml } from "../utils/markdown.js";
+import { jsonResult } from "../utils/result.js";
+export function registerTransferTools(registry) {
+    registry.tool("uploadMarkdown", z.object({
+        file: z.string(),
+        id: z.coerce.string().optional(),
+        space: z.string().optional(),
+        title: z.string().optional(),
+        parentId: z.coerce.string().optional(),
+        representation: z.enum(["wiki", "storage"]).default("wiki"),
+        attachments: z.array(z.string()).optional(),
+        mermaid: z.enum(["png", "svg", "none"]).default("png"),
+        forceReupload: z.boolean().default(false),
+        confirm: z.boolean().default(false),
+        toc: z.boolean().default(false),
+        tocMaxLevel: z.coerce.number().min(1).max(7).optional(),
+    }), async (input) => {
+        const representation = input.representation ?? "wiki";
+        const raw = readFileSync(input.file, "utf8");
+        const parsed = parseMarkdown(raw, basename(input.file, extname(input.file)));
+        const title = input.title ?? parsed.title;
+        if (!title)
+            throw new Error("Missing page title. Provide --title or an H1/frontmatter title.");
+        const prepared = prepareMarkdownForUpload(parsed.body, title, input.file, representation, input.mermaid ?? "png");
+        const effectiveRepresentation = prepared.generatedFiles.length > 0 ? "storage" : representation;
+        const attachments = [...prepared.generatedFiles.map((item) => item.filePath), ...(input.attachments ?? [])];
+        const body = input.toc ? buildTocMacro(input.tocMaxLevel) + "\n" + prepared.body : prepared.body;
+        const action = input.id ? "updateMarkdownPage" : "createMarkdownPage";
+        const preview = previewOrAssertWriteAllowed({ action, confirm: input.confirm, payload: { title, space: input.space, parentId: input.parentId, representation: effectiveRepresentation, attachments, forceReupload: input.forceReupload ?? false, bodyPreview: body.slice(0, 1000), generatedFiles: prepared.generatedFiles.map((item) => item.filePath) } });
+        if (preview)
+            return jsonResult(preview);
+        const config = loadConfluenceConfig();
+        const api = new ConfluenceApi(config);
+        let page;
+        if (input.id) {
+            const current = await api.getContent(input.id, "version,title");
+            page = await api.updateContent({ id: input.id, title, body, representation: effectiveRepresentation, version: (current.version?.number ?? 0) + 1, parentId: input.parentId });
+        }
+        else {
+            if (!input.space)
+                throw new Error("Creating content requires --space.");
+            page = await api.createContent({ space: input.space, title, body, representation: effectiveRepresentation, parentId: input.parentId });
+        }
+        const uploadedAttachments = await uploadAttachmentFiles(api, page.id, attachments, input.forceReupload ?? false);
+        const finalBody = applyMermaidImageMacros(body, prepared.generatedFiles, uploadedAttachments);
+        if (finalBody !== body) {
+            const current = await api.getContent(page.id, "version,title");
+            page = await api.updateContent({ id: page.id, title, body: finalBody, representation: "storage", version: (current.version?.number ?? 0) + 1, parentId: input.parentId });
+        }
+        return jsonResult({ page, attachments: uploadedAttachments, generatedFiles: prepared.generatedFiles.map((item) => item.filePath) });
+    }, "Upload Markdown as Confluence page; writes require confirm=true");
+    registry.tool("uploadHtml", z.object({
+        file: z.string(),
+        id: z.coerce.string().optional(),
+        space: z.string().optional(),
+        title: z.string().optional(),
+        parentId: z.coerce.string().optional(),
+        attachments: z.array(z.string()).optional(),
+        mermaid: z.enum(["png", "svg", "none"]).default("png"),
+        forceReupload: z.boolean().default(false),
+        confirm: z.boolean().default(false),
+        toc: z.boolean().default(false),
+        tocMaxLevel: z.coerce.number().min(1).max(7).optional(),
+    }), async (input) => {
+        const raw = readFileSync(input.file, "utf8");
+        const title = input.title ?? extractTitleFromHtml(raw) ?? basename(input.file, extname(input.file));
+        const prepared = replaceMermaidInHtml(raw, title, input.file, input.mermaid ?? "png");
+        const bodyContent = extractBodyContent(prepared.html);
+        let body = postProcessStorageHtml(bodyContent);
+        if (input.toc)
+            body = buildTocMacro(input.tocMaxLevel) + "\n" + body;
+        const attachments = [...prepared.generatedFiles.map((item) => item.filePath), ...(input.attachments ?? [])];
+        const action = input.id ? "updateHtmlPage" : "createHtmlPage";
+        const preview = previewOrAssertWriteAllowed({ action, confirm: input.confirm, payload: { title, space: input.space, parentId: input.parentId, representation: "storage", attachments, forceReupload: input.forceReupload ?? false, bodyPreview: body.slice(0, 1000), generatedFiles: prepared.generatedFiles.map((item) => item.filePath) } });
+        if (preview)
+            return jsonResult(preview);
+        const config = loadConfluenceConfig();
+        const api = new ConfluenceApi(config);
+        let page;
+        if (input.id) {
+            const current = await api.getContent(input.id, "version,title");
+            page = await api.updateContent({ id: input.id, title, body, representation: "storage", version: (current.version?.number ?? 0) + 1, parentId: input.parentId });
+        }
+        else {
+            if (!input.space)
+                throw new Error("Creating content requires --space.");
+            page = await api.createContent({ space: input.space, title, body, representation: "storage", parentId: input.parentId });
+        }
+        const uploadedAttachments = await uploadAttachmentFiles(api, page.id, attachments, input.forceReupload ?? false);
+        const finalBody = applyMermaidImageMacros(body, prepared.generatedFiles, uploadedAttachments);
+        if (finalBody !== body) {
+            const current = await api.getContent(page.id, "version,title");
+            page = await api.updateContent({ id: page.id, title, body: finalBody, representation: "storage", version: (current.version?.number ?? 0) + 1, parentId: input.parentId });
+        }
+        return jsonResult({ page, attachments: uploadedAttachments, generatedFiles: prepared.generatedFiles.map((item) => item.filePath) });
+    }, "Upload HTML as Confluence page; writes require confirm=true");
+    registry.tool("downloadPage", z.object({
+        id: z.coerce.string(),
+        outputDir: z.string().default("."),
+        saveHtml: z.boolean().default(false),
+        downloadAttachments: z.boolean().default(false),
+        downloadChildren: z.boolean().default(false),
+    }), async ({ id, outputDir, saveHtml, downloadAttachments, downloadChildren }) => {
+        const targetDir = outputDir ?? ".";
+        const config = loadConfluenceConfig();
+        const api = new ConfluenceApi(config);
+        mkdirSync(targetDir, { recursive: true });
+        return jsonResult(await downloadPageToDir(api, config, id, targetDir, { saveHtml: saveHtml ?? false, downloadAttachments: downloadAttachments ?? false, downloadChildren: downloadChildren ?? false }));
+    }, "Download one page to Markdown with optional attachments and children");
+}
+function prepareMarkdownForUpload(markdown, pageTitle, sourceFile, representation, mermaidMode) {
+    const prepared = replaceMermaidFences(markdown, pageTitle, sourceFile, mermaidMode);
+    const body = prepared.generatedFiles.length > 0 || representation === "storage" ? markdownToStorage(prepared.markdown) : markdownToWiki(prepared.markdown);
+    return { body, generatedFiles: prepared.generatedFiles };
+}
+function replaceMermaidFences(markdown, pageTitle, sourceFile, mermaidMode) {
+    if (mermaidMode === "none")
+        return { markdown, generatedFiles: [] };
+    const lines = markdown.split(/\r?\n/);
+    const output = [];
+    const generatedFiles = [];
+    let inMermaid = false;
+    let buffer = [];
+    let index = 0;
+    for (const line of lines) {
+        const fence = line.match(/^```\s*mermaid\s*$/i);
+        if (fence) {
+            if (!inMermaid) {
+                inMermaid = true;
+                buffer = [];
+            }
+            else {
+                const mermaidSource = buffer.join("\n").trim();
+                const generated = createMermaidFile(mermaidSource, pageTitle, sourceFile, index, mermaidMode);
+                generatedFiles.push(generated);
+                output.push(generated.marker);
+                index += 1;
+                inMermaid = false;
+            }
+            continue;
+        }
+        if (inMermaid && /^```\s*$/.test(line)) {
+            const mermaidSource = buffer.join("\n").trim();
+            const generated = createMermaidFile(mermaidSource, pageTitle, sourceFile, index, mermaidMode);
+            generatedFiles.push(generated);
+            output.push(generated.marker);
+            index += 1;
+            inMermaid = false;
+            continue;
+        }
+        if (inMermaid) {
+            buffer.push(line);
+            continue;
+        }
+        output.push(line);
+    }
+    if (inMermaid)
+        throw new Error("Mermaid code fence is not closed.");
+    return { markdown: output.join("\n"), generatedFiles };
+}
+function applyMermaidImageMacros(body, generatedFiles, uploadedAttachments) {
+    let output = body;
+    for (let index = 0; index < generatedFiles.length; index += 1) {
+        const generated = generatedFiles[index];
+        const uploaded = uploadedAttachments[index];
+        const attachment = readUploadedAttachment(uploaded?.result);
+        if (!attachment)
+            continue;
+        const macro = buildImageMacro(attachment.title ?? generated.attachmentName);
+        output = output.replaceAll(`<p>${generated.marker}</p>`, macro).replaceAll(generated.marker, macro);
+    }
+    return output;
+}
+function buildImageMacro(filename) {
+    return `<ac:image><ri:attachment ri:filename="${escapeXml(filename)}" /></ac:image>`;
+}
+function readUploadedAttachment(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    if ("results" in value && Array.isArray(value.results)) {
+        return value.results?.[0];
+    }
+    if ("id" in value)
+        return value;
+    return undefined;
+}
+function buildTocMacro(maxLevel) {
+    const macros = ['<ac:structured-macro ac:name="toc" ac:schema-version="1">'];
+    if (maxLevel !== undefined && maxLevel >= 1 && maxLevel <= 7) {
+        macros.push(`<ac:parameter ac:name="maxLevel">${maxLevel}</ac:parameter>`);
+    }
+    macros.push("</ac:structured-macro>");
+    macros.push('<ac:structured-macro ac:name="easy-heading-free" ac:schema-version="1" />');
+    return macros.join("");
+}
+function escapeXml(value) {
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\"/g, "&quot;").replace(/'/g, "&apos;");
+}
+async function uploadAttachmentFiles(api, pageId, files, forceReupload) {
+    if (files.length === 0)
+        return [];
+    const existing = forceReupload ? await api.listAttachments(pageId, 100) : undefined;
+    const results = [];
+    for (const file of files) {
+        const filename = basename(file);
+        const matched = existing?.results.find((attachment) => attachment.title === filename);
+        const contentType = attachmentContentType(filename);
+        if (matched) {
+            results.push({ file, action: "updateAttachment", result: await api.updateAttachmentData({ pageId, attachmentId: matched.id, filename, data: readFileSync(file), minorEdit: true, contentType }) });
+        }
+        else {
+            results.push({ file, action: "uploadAttachment", result: await api.uploadAttachment({ pageId, filename, data: readFileSync(file), minorEdit: true, contentType }) });
+        }
+    }
+    return results;
+}
+function attachmentContentType(filename) {
+    const extension = extname(filename).toLowerCase();
+    if (extension === ".png")
+        return "image/png";
+    if (extension === ".svg")
+        return "image/svg+xml";
+    return undefined;
+}
+async function downloadPageToDir(api, config, id, targetDir, options) {
+    const page = await api.getContent(id, "body.storage,version,space,ancestors,metadata.labels");
+    const safeTitle = safeFileName(page.title);
+    const body = page.body?.storage?.value ?? "";
+    const markdownPath = join(targetDir, `${safeTitle}.md`);
+    const htmlPath = options.saveHtml ? join(targetDir, `${safeTitle}.html`) : undefined;
+    writeFileSync(markdownPath, markdownForPage(config, page, body));
+    if (htmlPath)
+        writeFileSync(htmlPath, body);
+    const attachmentPaths = options.downloadAttachments ? await downloadPageAttachments(api, page.id, join(targetDir, `${safeTitle}_attachments`)) : [];
+    const children = options.downloadChildren ? await downloadChildren(api, config, page.id, join(targetDir, `${safeTitle}_Children`), options) : [];
+    return { page: { id: page.id, title: page.title }, markdownPath, htmlPath, attachmentPaths, children };
+}
+async function downloadPageAttachments(api, pageId, targetDir) {
+    const attachments = await api.listAttachments(pageId, 100);
+    if (attachments.results.length === 0)
+        return [];
+    mkdirSync(targetDir, { recursive: true });
+    const paths = [];
+    for (const attachment of attachments.results) {
+        const outputPath = await downloadAttachment(api, attachment, targetDir);
+        if (outputPath)
+            paths.push(outputPath);
+    }
+    return paths;
+}
+async function downloadAttachment(api, attachment, targetDir) {
+    if (!attachment._links?.download)
+        return undefined;
+    const outputPath = join(targetDir, safeFileName(attachment.title));
+    const downloaded = await api.downloadAttachment(attachment._links.download);
+    writeFileSync(outputPath, downloaded.data);
+    return outputPath;
+}
+async function downloadChildren(api, config, pageId, targetDir, options) {
+    const children = await api.getChildren(pageId, "page", "body.storage,version,space", 100);
+    if (children.results.length === 0)
+        return [];
+    mkdirSync(targetDir, { recursive: true });
+    const childOptions = { ...options, downloadChildren: false };
+    const results = [];
+    for (const child of children.results) {
+        results.push(await downloadPageToDir(api, config, child.id, targetDir, childOptions));
+    }
+    return results;
+}
+function markdownForPage(config, page, body) {
+    return [
+        "---",
+        `title: ${JSON.stringify(page.title)}`,
+        `confluence_url: ${JSON.stringify(`${config.url}/pages/viewpage.action?pageId=${page.id}`)}`,
+        `id: ${page.id}`,
+        `space: ${page.space?.key ?? ""}`,
+        `version: ${page.version?.number ?? ""}`,
+        "---",
+        "",
+        htmlToPlainMarkdown(body),
+    ].join("\n");
+}
+function htmlToPlainMarkdown(html) {
+    return html
+        .replace(/<h([1-6])[^>]*>(.*?)<\/h\1>/gis, (_match, level, text) => `${"#".repeat(Number(level))} ${stripTags(text)}\n`)
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/p>/gi, "\n\n")
+        .replace(/<\/li>/gi, "\n")
+        .replace(/<li[^>]*>/gi, "- ")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&amp;/g, "&")
+        .trim();
+}
+function stripTags(value) {
+    return value.replace(/<[^>]+>/g, "").trim();
+}
+function extractBodyContent(html) {
+    const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+    return bodyMatch ? bodyMatch[1].trim() : html;
+}
+function extractTitleFromHtml(html) {
+    const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+    if (titleMatch)
+        return titleMatch[1].trim();
+    const h1Match = html.match(/<h1[^>]*>([^<]*)<\/h1>/i);
+    if (h1Match)
+        return h1Match[1].trim();
+    return undefined;
+}
+function replaceMermaidInHtml(html, pageTitle, sourceFile, mermaidMode) {
+    if (mermaidMode === "none")
+        return { html, generatedFiles: [] };
+    const generatedFiles = [];
+    let index = 0;
+    let output = html;
+    // 1) Handle HTML-style mermaid blocks: <pre><code class="language-mermaid">...</code></pre>
+    output = output.replace(/<pre><code\s+class="language-mermaid"[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_match, mermaidSource) => {
+        const source = mermaidSource.trim();
+        if (!source)
+            return _match;
+        const gf = createMermaidFile(source, pageTitle, sourceFile, index, mermaidMode);
+        generatedFiles.push(gf);
+        index += 1;
+        return gf.marker;
+    });
+    // 2) Handle markdown-style fences in HTML source: ```mermaid ... ```
+    const lines = output.split(/\r?\n/);
+    const outLines = [];
+    let inMermaid = false;
+    let buffer = [];
+    for (const line of lines) {
+        const fence = line.match(/^```\s*mermaid\s*$/i);
+        if (fence && !inMermaid) {
+            inMermaid = true;
+            buffer = [];
+            continue;
+        }
+        if (inMermaid && /^```\s*$/.test(line)) {
+            const source = buffer.join("\n").trim();
+            if (source) {
+                const gf = createMermaidFile(source, pageTitle, sourceFile, index, mermaidMode);
+                generatedFiles.push(gf);
+                index += 1;
+                outLines.push(gf.marker);
+            }
+            inMermaid = false;
+            continue;
+        }
+        if (inMermaid) {
+            buffer.push(line);
+            continue;
+        }
+        outLines.push(line);
+    }
+    return { html: outLines.join("\n"), generatedFiles };
+}
+function createMermaidFile(mermaidSource, pageTitle, sourceFile, idx, renderKind) {
+    const attachmentName = `${safeFileName(pageTitle || basename(sourceFile, extname(sourceFile)))}-mermaid-${idx + 1}.${renderKind}`;
+    const marker = `MERMAID_IMAGE_PLACEHOLDER_${idx}`;
+    const outputDir = join(tmpdir(), "confluence-cli");
+    mkdirSync(outputDir, { recursive: true });
+    const filePath = join(outputDir, attachmentName);
+    renderMermaidFile(mermaidSource, filePath, renderKind);
+    return { marker, filePath, attachmentName, renderKind };
+}
+function renderMermaidFile(mermaidSource, outputFile, renderKind) {
+    const inputFile = join(dirname(outputFile), `${basename(outputFile, extname(outputFile))}.mmd`);
+    writeFileSync(inputFile, mermaidSource, "utf8");
+    const mmdc = resolveMmdcBin();
+    const args = ["-i", inputFile, "-o", outputFile, "-b", "transparent"];
+    if (renderKind === "png") {
+        args.push("--scale", "3");
+    }
+    try {
+        execFileSync(mmdc, args, { stdio: "pipe" });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to render Mermaid as ${renderKind} with mermaid-cli: ${message}`);
+    }
+}
+function resolveMmdcBin() {
+    const extension = process.platform === "win32" ? ".cmd" : "";
+    const candidates = [
+        join(process.cwd(), "node_modules", ".bin", `mmdc${extension}`),
+        join(dirname(process.argv[1] ?? process.cwd()), "..", "node_modules", ".bin", `mmdc${extension}`),
+    ];
+    const found = candidates.find((candidate) => existsSync(candidate));
+    if (found)
+        return found;
+    return `mmdc${extension}`;
+}
+function safeFileName(value) {
+    return value.replace(/[\\/:*?"<>|]/g, "_");
+}
+//# sourceMappingURL=transfer.js.map

package/dist/types/common.d.ts

@@ -0,0 +1,17 @@
+export type Role = "full" | "reader" | "writer";
+export interface JsonContentResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}
+export interface ConfluenceConfig {
+    url: string;
+    apiBaseUrl: string;
+    authType: "pat" | "basic";
+    username?: string;
+    password?: string;
+    personalToken?: string;
+    source: string;
+}
+export type ToolHandler<TInput> = (input: TInput) => Promise<JsonContentResult> | JsonContentResult;

package/dist/types/common.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=common.js.map

package/dist/update-probe.d.ts

@@ -0,0 +1,2 @@
+export declare function runDailyUpdateProbe(commandName?: string): Promise<void>;
+export declare function writeUpdateCacheAfterInstall(version?: string): Promise<void>;

package/dist/update-probe.js

@@ -0,0 +1,142 @@
+import { spawn } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { isRecord } from "./core/value.js";
+import { VERSION } from "./version.js";
+const PACKAGE_NAME = "@cloudglab/confluence-cli";
+const CHECK_FILE = path.join(homedir(), ".confluence", "update-check.json");
+const SKIP_COMMANDS = new Set(["help", "list", "version", "install", "update", "upgrade", "uninstall", "remove", "--help", "-h", "--version", "-v"]);
+export async function runDailyUpdateProbe(commandName) {
+    if (!commandName || SKIP_COMMANDS.has(commandName))
+        return;
+    if (process.env.NODE_ENV === "test")
+        return;
+    if (process.env.CONFLUENCE_SKIP_UPDATE_CHECK === "true")
+        return;
+    try {
+        const today = new Date().toISOString().slice(0, 10);
+        const state = await readUpdateCheckState();
+        notifyIfUpdateAvailable(state.latestVersion);
+        if (state.lastCheckedDate === today)
+            return;
+        await writeUpdateCheckState({ ...state, lastCheckedDate: today, currentVersion: VERSION });
+        triggerBackgroundVersionCheck();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Confluence CLI 自动更新检查失败，已继续执行当前命令：${message}\n`);
+    }
+}
+export async function writeUpdateCacheAfterInstall(version) {
+    const today = new Date().toISOString().slice(0, 10);
+    await writeUpdateCheckState({
+        lastCheckedDate: today,
+        latestVersion: version ?? VERSION,
+        currentVersion: VERSION,
+    });
+}
+function notifyIfUpdateAvailable(latestVersion) {
+    if (!latestVersion || !isNewerVersion(latestVersion, VERSION))
+        return;
+    process.stderr.write([
+        `检测到 Confluence CLI 新版本 ${latestVersion}（当前 ${VERSION}）。`,
+        "建议执行以下命令完成更新：",
+        "  confluence update",
+        "如只更新工具且跳过配置校验，可执行：",
+        "  confluence update --skip-config-check",
+        "",
+    ].join("\n"));
+}
+async function readUpdateCheckState() {
+    try {
+        const parsed = JSON.parse(await readFile(CHECK_FILE, "utf8"));
+        if (!isRecord(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+async function writeUpdateCheckState(state) {
+    await mkdir(path.dirname(CHECK_FILE), { recursive: true, mode: 0o700 });
+    await writeFile(CHECK_FILE, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+}
+function triggerBackgroundVersionCheck() {
+    const script = `
+    const { spawn } = require('child_process');
+    const { mkdirSync, writeFileSync } = require('fs');
+    const { homedir } = require('os');
+    const path = require('path');
+
+    const packageName = ${JSON.stringify(PACKAGE_NAME)};
+    const cliVersion = ${JSON.stringify(VERSION)};
+    const shell = ${process.platform === "win32"};
+
+    const npm = spawn('npm', ['view', packageName, 'version', '--silent'], {
+      shell,
+      detached: true,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+
+    let stdout = '';
+    npm.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });
+
+    npm.on('close', (code) => {
+      if (code !== 0) return;
+      const latestVersion = stdout.trim();
+      if (!latestVersion) return;
+      const today = new Date().toISOString().slice(0, 10);
+      const checkFile = path.join(homedir(), '.confluence', 'update-check.json');
+      mkdirSync(path.dirname(checkFile), { recursive: true, mode: 0o700 });
+      writeFileSync(checkFile, JSON.stringify({ lastCheckedDate: today, latestVersion, currentVersion: cliVersion }, null, 2) + '\n', { mode: 0o600 });
+    });
+  `;
+    const child = spawn(process.execPath, ["-e", script], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+}
+async function getLatestPackageVersion() {
+    const stdout = await runCommandOutput("npm", ["view", PACKAGE_NAME, "version", "--silent"]);
+    const version = stdout.trim();
+    if (!version)
+        throw new Error("npm view 没有返回最新版本号");
+    return version;
+}
+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 isNewerVersion(latestVersion, currentVersion) {
+    const latest = parseVersion(latestVersion);
+    const current = parseVersion(currentVersion);
+    for (let index = 0; index < Math.max(latest.length, current.length); index += 1) {
+        const latestPart = latest[index] ?? 0;
+        const currentPart = current[index] ?? 0;
+        if (latestPart > currentPart)
+            return true;
+        if (latestPart < currentPart)
+            return false;
+    }
+    return false;
+}
+function parseVersion(version) {
+    return version.replace(/^v/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10)).map((part) => (Number.isFinite(part) ? part : 0));
+}
+//# sourceMappingURL=update-probe.js.map

package/dist/utils/mark-metadata.d.ts

@@ -0,0 +1,9 @@
+export interface MarkMetadataInput {
+    space: string;
+    title?: string;
+    parents?: string[];
+    labels?: string[];
+    attachments?: string[];
+}
+export declare function createMarkMetadata(input: MarkMetadataInput): string;
+export declare function removeMarkMetadata(content: string): string;

package/dist/utils/mark-metadata.js

@@ -0,0 +1,16 @@
+export function createMarkMetadata(input) {
+    const lines = [`<!-- Space: ${input.space} -->`];
+    if (input.title)
+        lines.push(`<!-- Title: ${input.title} -->`);
+    for (const parent of input.parents ?? [])
+        lines.push(`<!-- Parent: ${parent} -->`);
+    for (const label of input.labels ?? [])
+        lines.push(`<!-- Label: ${label} -->`);
+    for (const attachment of input.attachments ?? [])
+        lines.push(`<!-- Attachment: ${attachment} -->`);
+    return lines.join("\n");
+}
+export function removeMarkMetadata(content) {
+    return content.replace(/^<!--\s*(Space|Title|Parent|Label|Attachment):.*?-->\s*\r?\n/gim, "");
+}
+//# sourceMappingURL=mark-metadata.js.map

package/dist/utils/markdown.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedMarkdown {
+    frontmatter: Record<string, unknown>;
+    body: string;
+    title?: string;
+}
+export declare function parseMarkdown(content: string, fallbackTitle?: string): ParsedMarkdown;
+export declare function markdownToWiki(markdown: string): string;
+export declare function markdownToStorage(markdown: string): string;
+export declare function postProcessStorageHtml(html: string): string;