finch-markdown-editor 0.1.0

package/dist/index.js

@@ -0,0 +1,750 @@
+// src/index.ts
+import { createHash } from "node:crypto";
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import { watch } from "node:fs";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import os from "node:os";
+var PASTE_IMAGE_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/svg+xml": "svg",
+  "image/bmp": "bmp"
+};
+var IMAGE_MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp"
+};
+var MAX_CLIPBOARD_INLINE_IMAGE_BYTES = 20 * 1024 * 1024;
+async function readClipboardImageDataUrls(ctx, urls) {
+  const result2 = {};
+  const assetsRoot = await realpath(path.join(ctx.storagePath, "assets"));
+  for (const originalUrl of urls.slice(0, 30)) {
+    try {
+      const parsed = new URL(originalUrl);
+      const requested = parsed.protocol === "finch-file:" && parsed.hostname === "local" ? parsed.searchParams.get("path") : null;
+      if (!requested) continue;
+      const target = await realpath(requested);
+      const relative = path.relative(assetsRoot, target);
+      const mimeType = IMAGE_MIME_BY_EXT[path.extname(target).toLowerCase()];
+      if ((!relative || !relative.startsWith(".." + path.sep) && relative !== "..") && mimeType) {
+        const info = await stat(target);
+        if (info.size > MAX_CLIPBOARD_INLINE_IMAGE_BYTES) continue;
+        result2[originalUrl] = `data:${mimeType};base64,${(await readFile(target)).toString("base64")}`;
+      }
+    } catch {
+    }
+  }
+  return result2;
+}
+async function openLocalImagePreview(ctx, filePath) {
+  if (!path.isAbsolute(filePath) || !IMAGE_MIME_BY_EXT[path.extname(filePath).toLowerCase()]) {
+    throw new Error("Unsupported local image file.");
+  }
+  await ctx.ui.openFilePreview(filePath);
+}
+async function openMarkdownImagePreview(ctx, rawUrl) {
+  const url = new URL(rawUrl);
+  if (url.protocol === "http:" || url.protocol === "https:") {
+    await ctx.browser.open(url.href);
+    return;
+  }
+  throw new Error(`Unsupported image URL: ${url.protocol}`);
+}
+var STYLE_SLOT_COUNT = 3;
+function result(message, isError = false) {
+  return { content: [{ type: "text", text: message }], isError };
+}
+function documentTitle(markdown, filePath) {
+  const heading = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim();
+  return heading || (filePath ? path.basename(filePath, path.extname(filePath)) : "Untitled article");
+}
+function stateFile(ctx) {
+  return path.join(ctx.storagePath, "state.json");
+}
+function styleSlotsFile(ctx) {
+  return path.join(ctx.storagePath, "style-slots.json");
+}
+function normalizeStyleSlots(raw) {
+  const arr = Array.isArray(raw) ? raw : [];
+  const slots = [];
+  for (let i = 0; i < STYLE_SLOT_COUNT; i++) {
+    const item = arr[i];
+    if (item && typeof item === "object" && typeof item.css === "string") {
+      slots.push({ css: item.css, label: String(item.label ?? "\u81EA\u5B9A\u4E49\u98CE\u683C") });
+    } else {
+      slots.push(null);
+    }
+  }
+  return slots;
+}
+async function readStyleSlots(ctx) {
+  try {
+    const raw = await readFile(styleSlotsFile(ctx), "utf8");
+    return normalizeStyleSlots(JSON.parse(raw));
+  } catch {
+    return normalizeStyleSlots([]);
+  }
+}
+async function writeStyleSlot(ctx, slot, value) {
+  const slots = await readStyleSlots(ctx);
+  slots[slot] = value;
+  await mkdir(ctx.storagePath, { recursive: true });
+  await writeFile(styleSlotsFile(ctx), JSON.stringify(slots), "utf8");
+  return slots;
+}
+function sessionBucketKey(panel) {
+  return panel.sessionId || "__global__";
+}
+async function readLastPathState(ctx) {
+  try {
+    const raw = await readFile(stateFile(ctx), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function rememberLastPath(ctx, panel, sourcePath) {
+  try {
+    await mkdir(ctx.storagePath, { recursive: true });
+    const state = await readLastPathState(ctx);
+    const legacyPaths = [...Object.values(state.panels ?? {}), ...Object.values(state.sessions ?? {})];
+    state.recentPaths = [sourcePath, ...state.recentPaths ?? [], ...legacyPaths].filter((value, index, values) => path.isAbsolute(value) && values.indexOf(value) === index).slice(0, 50);
+    state.panels = { ...state.panels, [panel.id]: sourcePath };
+    state.sessions = { ...state.sessions, [sessionBucketKey(panel)]: sourcePath };
+    await writeFile(stateFile(ctx), JSON.stringify(state), "utf8");
+  } catch (error) {
+    ctx.logger.warn(`Could not persist last-opened path: ${String(error)}`);
+  }
+}
+async function readLastPath(ctx, panel) {
+  const state = await readLastPathState(ctx);
+  const perPanel = state.panels?.[panel.id];
+  if (typeof perPanel === "string") return perPanel;
+  const key = sessionBucketKey(panel);
+  const perSession = state.sessions?.[key];
+  if (typeof perSession === "string") return perSession;
+  if (key === "__global__" && typeof state.lastPath === "string") return state.lastPath;
+  return void 0;
+}
+var RECENT_LIMIT = 50;
+var RECENT_PREVIEW_CHARS = 220;
+function isMarkdownPath(filePath) {
+  return /\.(md|markdown|mdown|mkd)$/i.test(filePath);
+}
+function isInsideDirectory(filePath, directory) {
+  const relative = path.relative(directory, filePath);
+  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function deriveTitle(markdown, fallback) {
+  for (const line of markdown.split("\n", 60)) {
+    const heading = line.match(/^\s{0,3}#{1,6}\s+(.*\S)\s*$/);
+    if (heading) return heading[1].slice(0, 80);
+  }
+  for (const line of markdown.split("\n", 60)) {
+    const text = line.trim();
+    if (text) return text.replace(/^[>*\-+\s]+/, "").slice(0, 80) || fallback;
+  }
+  return fallback;
+}
+function derivePreview(markdown) {
+  return markdown.replace(/^---\n[\s\S]*?\n---\n/, "").replace(/```[\s\S]*?```/g, " ").replace(/!\[[^\]]*\]\([^)]*\)/g, " ").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/[*_`>~]/g, "").replace(/\s+/g, " ").trim().slice(0, RECENT_PREVIEW_CHARS);
+}
+async function collectRecentDocuments(ctx, cwd) {
+  if (!cwd || !path.isAbsolute(cwd)) return [];
+  const state = await readLastPathState(ctx);
+  const candidates = [
+    ...state.recentPaths ?? [],
+    ...Object.values(state.panels ?? {}),
+    ...Object.values(state.sessions ?? {})
+  ].filter(
+    (value, index, values) => typeof value === "string" && path.isAbsolute(value) && isMarkdownPath(value) && isInsideDirectory(value, cwd) && values.indexOf(value) === index
+  );
+  const documents = await Promise.all(
+    candidates.map(async (filePath) => {
+      try {
+        const info = await stat(filePath);
+        if (!info.isFile()) return void 0;
+        const markdown = await readFile(filePath, "utf8");
+        const fileName = path.basename(filePath);
+        return {
+          path: filePath,
+          relativePath: path.relative(cwd, filePath),
+          fileName,
+          title: deriveTitle(markdown, fileName.replace(/\.[^.]+$/, "")),
+          preview: derivePreview(markdown),
+          modifiedAt: info.mtimeMs
+        };
+      } catch {
+        return void 0;
+      }
+    })
+  );
+  return documents.filter((entry) => Boolean(entry)).sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, RECENT_LIMIT);
+}
+var livePanelDocuments = /* @__PURE__ */ new Map();
+async function sendDocument(panel, state) {
+  livePanelDocuments.set(panel.id, state);
+  await panel.postMessage({ type: "document", ...state });
+}
+function payloadPath(panel) {
+  const payload = panel.payload;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return void 0;
+  const value = payload.path;
+  return typeof value === "string" && path.isAbsolute(value) ? value : void 0;
+}
+async function restoreDocument(ctx, panel) {
+  if (!panel.sessionId) return false;
+  const sourcePath = await readLastPath(ctx, panel) ?? payloadPath(panel);
+  if (!sourcePath) return false;
+  try {
+    const markdown = await readFile(sourcePath, "utf8");
+    watchSource(ctx, panel, sourcePath);
+    await rememberLastPath(ctx, panel, sourcePath);
+    await sendDocument(panel, { path: sourcePath, markdown, title: documentTitle(markdown, sourcePath) });
+    return true;
+  } catch (error) {
+    ctx.logger.warn(`Could not restore ${sourcePath}: ${String(error)}`);
+    return false;
+  }
+}
+var bmmdBinPromise;
+async function ensureBmmdBin(ctx, onInstalling) {
+  if (!bmmdBinPromise) {
+    bmmdBinPromise = (async () => {
+      const installDir = path.join(ctx.storagePath, "bmmd");
+      const binPath = path.join(installDir, "node_modules", "bmmd", "bin", "bmmd.mjs");
+      try {
+        await stat(binPath);
+        return binPath;
+      } catch {
+      }
+      onInstalling?.();
+      await mkdir(installDir, { recursive: true });
+      await new Promise((resolve, reject) => {
+        const child = spawn("npm", [
+          "install",
+          "--no-save",
+          "--no-audit",
+          "--no-fund",
+          "--silent",
+          "--prefix",
+          installDir,
+          "bmmd@latest"
+        ], { stdio: "ignore" });
+        child.on("error", reject);
+        child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`npm install bmmd exited with code ${code}`)));
+      });
+      await stat(binPath);
+      return binPath;
+    })();
+  }
+  try {
+    return await bmmdBinPromise;
+  } catch (error) {
+    bmmdBinPromise = void 0;
+    throw error;
+  }
+}
+async function runBmmd(ctx, args, input, onInstalling) {
+  const binPath = await ensureBmmdBin(ctx, onInstalling);
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [binPath, ...args], { stdio: ["pipe", "pipe", "pipe"] });
+    let output = "";
+    let errors = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      errors += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve(output);
+      else reject(new Error(errors.trim() || `bmmd exited with code ${code}`));
+    });
+    child.stdin.end(input, "utf8");
+  });
+}
+var FINCH_FILE_IMAGE_RE = /finch-file:\/\/local\?path=[^\s)"']+/g;
+var FINCH_IMAGE_PLACEHOLDER_ORIGIN = "https://finch-local.invalid/markdown-image/";
+function substituteFinchFileImagesForBm(markdown) {
+  const urls = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const substituted = markdown.replace(FINCH_FILE_IMAGE_RE, (originalUrl) => {
+    const placeholder = `${FINCH_IMAGE_PLACEHOLDER_ORIGIN}${createHash("sha256").update(`${originalUrl}:${sequence++}`).digest("hex")}`;
+    urls.set(placeholder, originalUrl);
+    return placeholder;
+  });
+  return { markdown: substituted, urls };
+}
+async function renderWithBm(ctx, markdown, markdownStyle, customCss, onInstalling) {
+  const args = ["render", "--platform", "wechat", "--markdown-style", markdownStyle || "kami"];
+  if (customCss && customCss.trim()) args.push("--custom-css", customCss);
+  const prepared = substituteFinchFileImagesForBm(markdown);
+  let html = await runBmmd(ctx, args, prepared.markdown, onInstalling);
+  for (const [placeholder, originalUrl] of prepared.urls) html = html.split(placeholder).join(originalUrl);
+  return html;
+}
+var panelWatchers = /* @__PURE__ */ new Map();
+var lastPanel;
+function stopWatching(panelId) {
+  const entry = panelWatchers.get(panelId);
+  if (entry) {
+    entry.watcher.close();
+    if (entry.timer) clearTimeout(entry.timer);
+  }
+  panelWatchers.delete(panelId);
+}
+function watchSource(ctx, panel, sourcePath) {
+  stopWatching(panel.id);
+  try {
+    const entry = { watcher: void 0 };
+    entry.watcher = watch(sourcePath, () => {
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.timer = setTimeout(async () => {
+        try {
+          const markdown = await readFile(sourcePath, "utf8");
+          await sendDocument(panel, { path: sourcePath, markdown, title: documentTitle(markdown, sourcePath) });
+        } catch (error) {
+          ctx.logger.warn(`Source refresh failed: ${String(error)}`);
+        }
+      }, 150);
+    });
+    panelWatchers.set(panel.id, entry);
+  } catch (error) {
+    ctx.logger.warn(`Could not watch ${sourcePath}: ${String(error)}`);
+  }
+}
+var cachedAssistantName;
+async function getAssistantName(ctx) {
+  if (cachedAssistantName) return cachedAssistantName;
+  try {
+    cachedAssistantName = (await ctx.app.getInfo()).assistantName || "Finch";
+  } catch (error) {
+    ctx.logger.warn(`Failed to resolve assistant name: ${String(error)}`);
+    cachedAssistantName = "Finch";
+  }
+  return cachedAssistantName;
+}
+async function sendReady(ctx, panel) {
+  const pickFileSupported = ctx.api.supports("ui.pickFile");
+  const styleSlots = await readStyleSlots(ctx);
+  const assistantName = await getAssistantName(ctx);
+  ctx.logger.info(`sending ready to panel; pickFileSupported = ${pickFileSupported}`);
+  await panel.postMessage({
+    type: "ready",
+    locale: ctx.i18n.locale,
+    pickFileSupported,
+    styleSlots,
+    assistantName,
+    // So the page can render `cwd` the OS-friendly way (`~/…`) without a
+    // round trip — it never needs the raw value for anything but display.
+    homeDir: os.homedir()
+  });
+}
+function revealInFileManager(ctx, directory) {
+  try {
+    if (process.platform === "darwin") spawn("open", [directory], { stdio: "ignore", detached: true }).unref();
+    else if (process.platform === "win32") spawn("explorer", [directory], { stdio: "ignore", detached: true }).unref();
+    else spawn("xdg-open", [directory], { stdio: "ignore", detached: true }).unref();
+  } catch (error) {
+    ctx.logger.warn(`Could not open file manager for ${directory}: ${String(error)}`);
+  }
+}
+async function handleMessage(ctx, panel, raw) {
+  const message = raw;
+  switch (message.type) {
+    case "clientLog": {
+      ctx.logger.info(`[panel] ${String(message.message ?? "")}`);
+      return;
+    }
+    case "panelReady": {
+      await sendReady(ctx, panel);
+      const liveDocument = livePanelDocuments.get(panel.id);
+      if (liveDocument) {
+        await sendDocument(panel, liveDocument);
+      } else if (!await restoreDocument(ctx, panel)) {
+        await panel.postMessage({ type: "lastFileUnavailable" });
+      }
+      return;
+    }
+    case "openImage": {
+      const filePath = String(message.path ?? "").trim();
+      const rawUrl = String(message.url ?? "").trim();
+      try {
+        if (filePath) await openLocalImagePreview(ctx, filePath);
+        else await openMarkdownImagePreview(ctx, rawUrl);
+      } catch (error) {
+        ctx.logger.warn(`Ignored Markdown image preview: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      return;
+    }
+    case "openLink": {
+      const rawUrl = String(message.url ?? "").trim();
+      let target;
+      try {
+        target = new URL(rawUrl);
+      } catch {
+        ctx.logger.warn(`Ignored invalid Markdown link: ${rawUrl}`);
+        return;
+      }
+      if (target.protocol !== "http:" && target.protocol !== "https:") {
+        ctx.logger.warn(`Ignored unsupported Markdown link protocol: ${target.protocol}`);
+        return;
+      }
+      await ctx.browser.open(target.href);
+      return;
+    }
+    case "requestOpen": {
+      ctx.logger.info("requestOpen received; calling ctx.ui.pickFile()");
+      try {
+        const handle = ctx.ui.pickFile({
+          title: "\u9009\u62E9Markdown\u6587\u4EF6",
+          filter: { extensions: [".md", ".markdown"] }
+        });
+        ctx.logger.info("ctx.ui.pickFile() call returned a handle, awaiting resolution\u2026");
+        const picked = await handle;
+        ctx.logger.info(`pickFile() resolved: action=${picked.action}, files=${picked.files.length}`);
+        if (picked.action !== "select" || picked.files.length === 0) {
+          await panel.postMessage({ type: "pickCancelled" });
+          return;
+        }
+        const sourcePath = picked.files[0].path;
+        const markdown = await readFile(sourcePath, "utf8");
+        watchSource(ctx, panel, sourcePath);
+        await rememberLastPath(ctx, panel, sourcePath);
+        await sendDocument(panel, { path: sourcePath, markdown, title: documentTitle(markdown, sourcePath) });
+      } catch (error) {
+        ctx.logger.error(`pickFile() threw: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+        await panel.postMessage({
+          type: "error",
+          fallback: true,
+          message: `Native file picker failed, falling back to the browser dialog: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+      return;
+    }
+    case "loadPath": {
+      const sourcePath = String(message.path ?? "").trim();
+      if (!path.isAbsolute(sourcePath)) {
+        await panel.postMessage({ type: "error", message: "Please provide an absolute Markdown path." });
+        return;
+      }
+      try {
+        const markdown = await readFile(sourcePath, "utf8");
+        watchSource(ctx, panel, sourcePath);
+        await rememberLastPath(ctx, panel, sourcePath);
+        await sendDocument(panel, { path: sourcePath, markdown, title: documentTitle(markdown, sourcePath) });
+      } catch (error) {
+        await panel.postMessage({ type: "error", message: `Cannot read file: ${error instanceof Error ? error.message : String(error)}` });
+      }
+      return;
+    }
+    case "watchPath": {
+      const sourcePath = String(message.path ?? "").trim();
+      if (!path.isAbsolute(sourcePath)) return;
+      watchSource(ctx, panel, sourcePath);
+      await rememberLastPath(ctx, panel, sourcePath);
+      await panel.postMessage({ type: "watchStarted", path: sourcePath });
+      return;
+    }
+    case "requestLastFile": {
+      const liveDocument = livePanelDocuments.get(panel.id);
+      if (liveDocument) {
+        await sendDocument(panel, liveDocument);
+      } else if (!await restoreDocument(ctx, panel)) {
+        await panel.postMessage({ type: "lastFileUnavailable" });
+      }
+      return;
+    }
+    case "openPath": {
+      const targetPath = String(message.path ?? "").trim();
+      if (targetPath && path.isAbsolute(targetPath)) revealInFileManager(ctx, targetPath);
+      return;
+    }
+    case "goHome": {
+      stopWatching(panel.id);
+      livePanelDocuments.delete(panel.id);
+      return;
+    }
+    case "requestRecentDocuments": {
+      const cwd = String(message.cwd ?? "").trim();
+      try {
+        await panel.postMessage({ type: "recentDocuments", cwd, documents: await collectRecentDocuments(ctx, cwd) });
+      } catch (error) {
+        ctx.logger.warn(`Could not collect recent documents: ${String(error)}`);
+        await panel.postMessage({ type: "recentDocuments", cwd, documents: [] });
+      }
+      return;
+    }
+    case "saveMarkdown": {
+      const sourcePath = String(message.path ?? "").trim();
+      if (!path.isAbsolute(sourcePath)) return;
+      try {
+        await writeFile(sourcePath, String(message.markdown ?? ""), "utf8");
+        await panel.postMessage({ type: "savedMarkdown", path: sourcePath, requestId: message.requestId });
+      } catch (error) {
+        await panel.postMessage({ type: "error", message: `Could not save Markdown: ${error instanceof Error ? error.message : String(error)}` });
+      }
+      return;
+    }
+    case "renderBm": {
+      try {
+        const html = await renderWithBm(ctx, String(message.markdown ?? ""), String(message.markdownStyle ?? "kami"), message.customCss, () => {
+          panel.postMessage({ type: "status", message: "\u9996\u6B21\u6E32\u67D3\uFF1A\u6B63\u5728\u672C\u673A\u5B89\u88C5 bmmd \u6E32\u67D3\u5F15\u64CE\uFF08\u7EA6\u51E0\u79D2\uFF0C\u4EC5\u4E00\u6B21\uFF09\u2026" }).catch(() => {
+          });
+        });
+        await panel.postMessage({ type: "bmRendered", html, requestId: message.requestId });
+      } catch (error) {
+        await panel.postMessage({ type: "error", message: `bm.md rendering failed: ${error instanceof Error ? error.message : String(error)}` });
+      }
+      return;
+    }
+    case "updateToolbar": {
+      const itemId = String(message.itemId ?? "").trim();
+      if (!itemId || !message.patch) return;
+      try {
+        await panel.updateToolbarItem(itemId, message.patch);
+      } catch (error) {
+        ctx.logger.warn(`Could not update toolbar item ${itemId}: ${String(error)}`);
+      }
+      return;
+    }
+    case "setToolbar": {
+      if (!Array.isArray(message.toolbar)) return;
+      try {
+        await panel.setToolbar(message.toolbar);
+      } catch (error) {
+        ctx.logger.warn(`Could not replace toolbar: ${String(error)}`);
+      }
+      return;
+    }
+    case "applyReplacement": {
+      const sourcePath = String(message.path ?? "").trim();
+      const markdown = String(message.markdown ?? "");
+      if (!sourcePath || !path.isAbsolute(sourcePath)) {
+        await panel.postMessage({ type: "error", message: "Pasted documents can be revised in the editor, but source-file apply needs an absolute path." });
+        return;
+      }
+      try {
+        await writeFile(sourcePath, markdown, "utf8");
+        await panel.postMessage({ type: "applied", path: sourcePath, title: documentTitle(markdown, sourcePath) });
+      } catch (error) {
+        await panel.postMessage({ type: "error", message: `Could not apply revision: ${error instanceof Error ? error.message : String(error)}` });
+      }
+      return;
+    }
+    case "readClipboardImages": {
+      try {
+        const images = await readClipboardImageDataUrls(ctx, Array.isArray(message.urls) ? message.urls.filter((url) => typeof url === "string") : []);
+        await panel.postMessage({ type: "clipboardImages", requestId: message.requestId, images });
+      } catch (error) {
+        await panel.postMessage({ type: "clipboardImagesError", requestId: message.requestId, message: error instanceof Error ? error.message : String(error) });
+      }
+      return;
+    }
+    case "pasteImage": {
+      const dataBase64 = String(message.data ?? "");
+      if (!dataBase64) {
+        await panel.postMessage({ type: "pasteImageError", requestId: message.requestId, message: "Empty image data." });
+        return;
+      }
+      try {
+        const ext = PASTE_IMAGE_EXT[String(message.mimeType ?? "").toLowerCase()] ?? "png";
+        const buffer = Buffer.from(dataBase64, "base64");
+        const digest = createHash("sha256").update(buffer).digest("hex").slice(0, 20);
+        const dir = path.join(ctx.storagePath, "assets");
+        await mkdir(dir, { recursive: true });
+        const targetPath = path.join(dir, `${digest}.${ext}`);
+        const alreadyExists = await stat(targetPath).then(() => true).catch(() => false);
+        if (!alreadyExists) await writeFile(targetPath, buffer);
+        const url = `finch-file://local?path=${encodeURIComponent(targetPath)}`;
+        await panel.postMessage({ type: "pastedImage", requestId: message.requestId, url, path: targetPath });
+      } catch (error) {
+        await panel.postMessage({ type: "pasteImageError", requestId: message.requestId, message: error instanceof Error ? error.message : String(error) });
+      }
+      return;
+    }
+    case "saveStyleSlot": {
+      const slot = Number(message.slot);
+      if (!Number.isInteger(slot) || slot < 0 || slot >= STYLE_SLOT_COUNT) return;
+      const css = String(message.css ?? "").trim();
+      if (!css) {
+        await panel.postMessage({ type: "error", message: "Nothing to save: the active style has no custom CSS." });
+        return;
+      }
+      try {
+        const slots = await writeStyleSlot(ctx, slot, { css, label: String(message.label ?? "").trim() || "\u81EA\u5B9A\u4E49\u98CE\u683C" });
+        await panel.postMessage({ type: "styleSlots", styleSlots: slots, savedSlot: slot });
+      } catch (error) {
+        await panel.postMessage({ type: "error", message: `Could not save style slot: ${error instanceof Error ? error.message : String(error)}` });
+      }
+      return;
+    }
+    case "exportFile": {
+      const dataBase64 = String(message.data ?? "");
+      const ext = String(message.ext ?? "bin").replace(/[^a-z0-9]/gi, "") || "bin";
+      if (!dataBase64) {
+        await panel.postMessage({ type: "error", message: "Nothing to export." });
+        return;
+      }
+      try {
+        const sourcePath = String(message.path ?? "").trim();
+        let dir = path.isAbsolute(sourcePath) ? path.dirname(sourcePath) : "";
+        if (!dir) {
+          const downloads = path.join(os.homedir(), "Downloads");
+          dir = await stat(downloads).then((s) => s.isDirectory()).catch(() => false) ? downloads : ctx.storagePath;
+        }
+        const rawName = String(message.fileName ?? "").trim() || documentTitle(String(message.markdown ?? ""), sourcePath || void 0);
+        const safeName = rawName.replace(/[\\/:*?"<>|]/g, " ").trim().slice(0, 120) || "article";
+        const targetPath = path.join(dir, `${safeName}.${ext}`);
+        await writeFile(targetPath, Buffer.from(dataBase64, "base64"));
+        await panel.postMessage({ type: "exported", path: targetPath, requestId: message.requestId });
+      } catch (error) {
+        await panel.postMessage({ type: "error", message: `Could not export file: ${error instanceof Error ? error.message : String(error)}` });
+      }
+      return;
+    }
+  }
+}
+function activate(ctx) {
+  ctx.subscriptions.push(ctx.icons.register("markdown-editor-icons", {
+    "folder-open": {
+      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"/></svg>'
+    },
+    save: {
+      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M15.2 3a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2z"/><path d="M17 21v-7a1 1 0 0 0-1-1H8a1 1 0 0 0-1 1v7"/><path d="M7 3v4a1 1 0 0 0 1 1h7"/></svg>'
+    },
+    "save-check": {
+      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12.5 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h10.2a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4v4.35"/><path d="m16 19 2 2 4-4"/><path d="M17 15.13V14a1 1 0 0 0-1-1H8a1 1 0 0 0-1 1v7"/><path d="M7 3v4a1 1 0 0 0 1 1h7"/></svg>'
+    },
+    "file-pen-line": {
+      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14.364 13.634a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506l4.013-4.009a1 1 0 0 0-3.004-3.004z"/><path d="M14.487 7.858A1 1 0 0 1 14 7V2"/><path d="M20 19.645V20a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l2.516 2.516"/><path d="M8 18h1"/></svg>'
+    },
+    type: {
+      svg: '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-type-icon lucide-type"><path d="M12 4v16"/><path d="M4 7V5a1 1 0 0 1 1-1h14a1 1 0 0 1 1 1v2"/><path d="M9 20h6"/></svg>'
+    },
+    "wechat-copy": {
+      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linejoin="round"><path stroke-linecap="round" stroke-width="2" d="M7 7h.009m5.982 0H13m4.991 7.5H18m-4 0h.009"></path><path stroke-width="2" d="M10 16c0 2.761 2.686 5 6 5c.907 0 1.767-.168 2.538-.468c.189-.073.393-.1.592-.063L22 21l-.652-2.03a1.13 1.13 0 0 1 .11-.89A4.3 4.3 0 0 0 22 16c0-2.761-2.686-5-6-5s-6 2.239-6 5Z"></path><path stroke-width="2" d="M17.873 11.249Q18 10.639 18 10c0-3.866-3.582-7-8-7s-8 3.134-8 7c0 1.112.297 2.164.824 3.098c.147.26.196.567.108.853L2 17l3.914-.76c.208-.041.422-.013.617.07a9 9 0 0 0 3.589.69"></path></svg>'
+    }
+  }));
+  ctx.subscriptions.push(ctx.ui.onDidOpenPanel((panel) => {
+    if (panel.visible) lastPanel = panel;
+    ctx.subscriptions.push(panel.onDidReceiveMessage((message) => {
+      handleMessage(ctx, panel, message).catch((error) => {
+        ctx.logger.warn(`handleMessage failed for '${message?.type}': ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+      });
+    }));
+    ctx.subscriptions.push(panel.onDidChangeVisibility((visible) => {
+      if (visible) lastPanel = panel;
+      else if (lastPanel === panel) lastPanel = void 0;
+    }));
+    ctx.subscriptions.push(panel.onDidDispose(() => {
+      stopWatching(panel.id);
+      livePanelDocuments.delete(panel.id);
+      if (lastPanel === panel) lastPanel = void 0;
+    }));
+    void sendReady(ctx, panel).catch((error) => ctx.logger.warn(String(error)));
+  }));
+  ctx.subscriptions.push(ctx.tools.register({
+    name: "markdown_editor_document",
+    title: "Markdown \u7F16\u8F91",
+    description: `Open, create, revise, or restyle a Markdown document in Markdown Editor.
+action:
+  open \u2014 read an absolute local Markdown path and open it as an editable WeChat article preview
+  create \u2014 write brand-new Markdown content to an absolute path that does not exist yet, then open it in Markdown Editor. Use this whenever the user asks to create/draft a new Markdown file (Markdown Editor's own UI has no "new file" button on purpose \u2014 this tool action is the intended way to start a new document)
+  apply \u2014 replace a source document with reviewed Markdown (requires path and markdown); the open panel refreshes in place, no Diff window
+  set_style \u2014 apply an AI-designed custom CSS layout to the currently open Markdown Editor preview (requires css). Write plain CSS scoped under #bm-md using tag/id selectors (no classes), use !important where needed to override the base style, and take inspiration from bm.md's built-in styles: kami (warm paper), bauhaus (geometric primary colors), blueprint (technical grid), botanical (soft green), newsprint (editorial serif), retro (nostalgic), sketch (hand-drawn), terminal (monospace dark).`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["open", "create", "apply", "set_style"], description: "Operation to perform." },
+        path: { type: "string", description: "Absolute path to the Markdown file. Required for open, create, and apply. For create, the file must not already exist." },
+        markdown: { type: "string", description: "Full Markdown content, required for create and apply." },
+        css: { type: "string", description: "Custom CSS to layer on top of the current base style, required for set_style." },
+        label: { type: "string", description: "Short label describing the custom style, optional for set_style." },
+        slot: { type: "number", enum: [1, 2, 3], description: "Required for AI-designed styles: user-selected reusable custom style slot to overwrite." }
+      },
+      required: ["action"]
+    },
+    risk: "medium",
+    async execute(input) {
+      const action = String(input.action ?? "");
+      if (action === "open" || action === "create" || action === "apply") {
+        const sourcePath = String(input.path ?? "").trim();
+        if (!path.isAbsolute(sourcePath)) return result("`path` must be an absolute local path.", true);
+        if (action === "open") {
+          try {
+            const markdown2 = await readFile(sourcePath, "utf8");
+            const panel = ctx.ui.createPanel({ instanceMode: "single", payload: { path: sourcePath } });
+            await panel.reveal();
+            watchSource(ctx, panel, sourcePath);
+            await rememberLastPath(ctx, panel, sourcePath);
+            await sendDocument(panel, { path: sourcePath, markdown: markdown2, title: documentTitle(markdown2, sourcePath) });
+            return result(`Opened Markdown Editor for ${path.basename(sourcePath)}.`);
+          } catch (error) {
+            return result(`Could not read ${sourcePath}: ${error instanceof Error ? error.message : String(error)}`, true);
+          }
+        }
+        if (action === "create") {
+          const markdown2 = String(input.markdown ?? "");
+          try {
+            const alreadyExists = await stat(sourcePath).then(() => true).catch(() => false);
+            if (alreadyExists) return result(`${sourcePath} already exists. Use action 'open' to view it or 'apply' to revise it instead.`, true);
+            await mkdir(path.dirname(sourcePath), { recursive: true });
+            await writeFile(sourcePath, markdown2, "utf8");
+            const panel = ctx.ui.createPanel({ instanceMode: "single", payload: { path: sourcePath } });
+            await panel.reveal();
+            watchSource(ctx, panel, sourcePath);
+            await rememberLastPath(ctx, panel, sourcePath);
+            await sendDocument(panel, { path: sourcePath, markdown: markdown2, title: documentTitle(markdown2, sourcePath) });
+            return result(`Created ${path.basename(sourcePath)} and opened it in Markdown Editor.`);
+          } catch (error) {
+            return result(`Could not create ${sourcePath}: ${error instanceof Error ? error.message : String(error)}`, true);
+          }
+        }
+        const markdown = String(input.markdown ?? "");
+        if (!markdown) return result("`apply` requires non-empty `markdown`.", true);
+        try {
+          await writeFile(sourcePath, markdown, "utf8");
+          return result(`Applied reviewed Markdown to ${path.basename(sourcePath)}.`);
+        } catch (error) {
+          return result(`Could not apply revision: ${error instanceof Error ? error.message : String(error)}`, true);
+        }
+      }
+      if (action === "set_style") {
+        const css = String(input.css ?? "").trim();
+        if (!css) return result("`set_style` requires non-empty `css`.", true);
+        if (!lastPanel) return result("No Markdown Editor panel is open. Ask the user to open a document first.", true);
+        try {
+          const label = String(input.label ?? "") || "AI style";
+          const slot = Number(input.slot);
+          if (!Number.isInteger(slot) || slot < 1 || slot > STYLE_SLOT_COUNT) {
+            return result("Ask the user which reusable custom style slot (1, 2, or 3) to overwrite, then call `set_style` again with that `slot`.", true);
+          }
+          const slots = await writeStyleSlot(ctx, slot - 1, { css, label });
+          await lastPanel.postMessage({ type: "customStyleSet", css, label, styleSlots: slots, savedSlot: slot - 1 });
+          return result(`Custom style saved to slot ${slot} and applied to the open Markdown Editor panel.`);
+        } catch (error) {
+          return result(`Could not apply custom style: ${error instanceof Error ? error.message : String(error)}`, true);
+        }
+      }
+      return result(`Unknown action: ${action}`, true);
+    }
+  }));
+  ctx.logger.info("finch-markdown-editor activated");
+}
+export {
+  activate
+};