@bytechain.cn/colamd 1.5.0

package/dist/main/index.js

@@ -0,0 +1,735 @@
+"use strict";
+const electron = require("electron");
+const path = require("path");
+const promises = require("fs/promises");
+const fs = require("fs");
+const http = require("http");
+const themesDir = path.join(electron.app.getPath("home"), ".colamd", "themes");
+function ensureThemesDir() {
+  if (!fs.existsSync(themesDir)) {
+    promises.mkdir(themesDir, { recursive: true }).catch(() => {
+    });
+  }
+}
+const windowStates = /* @__PURE__ */ new Map();
+let pendingFilePaths = [];
+let pluginMenuItems = [];
+function getState(win) {
+  let state = windowStates.get(win.id);
+  if (!state) {
+    state = { filePath: null, watcher: null, isInternalSave: false, debounceTimer: null, agentState: "idle", lastExternalChange: 0, agentCooldownTimer: null };
+    windowStates.set(win.id, state);
+  }
+  return state;
+}
+function getWinFromEvent(event) {
+  return electron.BrowserWindow.fromWebContents(event.sender);
+}
+function createWindow(filePath) {
+  const win = new electron.BrowserWindow({
+    width: 960,
+    height: 720,
+    minWidth: 600,
+    minHeight: 400,
+    titleBarStyle: "hiddenInset",
+    trafficLightPosition: { x: 16, y: 16 },
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false
+    }
+  });
+  const state = getState(win);
+  if (process.env.ELECTRON_RENDERER_URL) {
+    win.loadURL(process.env.ELECTRON_RENDERER_URL);
+  } else {
+    win.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+  win.webContents.on("did-finish-load", () => {
+    if (filePath) {
+      loadFileInWindow(win, filePath);
+    }
+  });
+  win.on("closed", () => {
+    stopWatching(state);
+    windowStates.delete(win.id);
+  });
+  updateTitle(win);
+  return win;
+}
+function updateTitle(win) {
+  const state = getState(win);
+  const fileName = state.filePath ? path.basename(state.filePath) : "Untitled";
+  win.setTitle(`${fileName} — ColaMD`);
+}
+function suggestFileName(win, content) {
+  const state = getState(win);
+  if (state.filePath) return path.basename(state.filePath, ".md");
+  if (!content) return void 0;
+  const match = content.match(/^#\s+(.+)/m) || content.match(/^(.+)/m);
+  if (!match) return void 0;
+  return match[1].trim().replace(/[/\\:*?"<>|]/g, "").slice(0, 60) || void 0;
+}
+function stopWatching(state) {
+  if (state.watcher) {
+    state.watcher.close();
+    state.watcher = null;
+  }
+  if (state.agentCooldownTimer) {
+    clearTimeout(state.agentCooldownTimer);
+    state.agentCooldownTimer = null;
+  }
+  state.agentState = "idle";
+  state.lastExternalChange = 0;
+}
+function transitionAgentState(win, state, newState) {
+  if (state.agentCooldownTimer) {
+    clearTimeout(state.agentCooldownTimer);
+    state.agentCooldownTimer = null;
+  }
+  if (newState === "active") {
+    if (state.agentState !== "active") {
+      state.agentState = "active";
+      if (!win.isDestroyed()) win.webContents.send("agent-activity", "active");
+    }
+    state.agentCooldownTimer = setTimeout(() => {
+      transitionAgentState(win, state, "cooldown");
+    }, 3e3);
+  } else if (newState === "cooldown") {
+    state.agentState = "cooldown";
+    if (!win.isDestroyed()) win.webContents.send("agent-activity", "cooldown");
+    state.agentCooldownTimer = setTimeout(() => {
+      transitionAgentState(win, state, "idle");
+    }, 2e3);
+  } else {
+    state.agentState = "idle";
+    if (!win.isDestroyed()) win.webContents.send("agent-activity", "idle");
+  }
+}
+function watchFile(win, state) {
+  if (!state.filePath) return;
+  stopWatching(state);
+  const filePath = state.filePath;
+  state.watcher = fs.watch(filePath, (eventType) => {
+    if (eventType !== "change" || state.isInternalSave) return;
+    const now = Date.now();
+    const gap = now - state.lastExternalChange;
+    state.lastExternalChange = now;
+    if (gap > 0 && gap < 2e3) {
+      transitionAgentState(win, state, "active");
+    } else if (state.agentState === "active") {
+      transitionAgentState(win, state, "active");
+    }
+    if (state.debounceTimer) clearTimeout(state.debounceTimer);
+    state.debounceTimer = setTimeout(() => {
+      promises.readFile(filePath, "utf-8").then((data) => {
+        if (!win.isDestroyed()) win.webContents.send("file-changed", resolveImagePaths(data, filePath));
+      }).catch(() => {
+      });
+    }, 100);
+  });
+}
+function resolveImagePaths(content, filePath) {
+  const dir = path.dirname(filePath);
+  return content.replace(/!\[([^\]]*)\]\((?!https?:\/\/|file:\/\/|data:)([^)]+)\)/g, (_match, alt, src) => {
+    const abs = path.join(dir, src);
+    return `![${alt}](file://${abs})`;
+  });
+}
+function loadFileInWindow(win, filePath) {
+  promises.readFile(filePath, "utf-8").then((data) => {
+    const state = getState(win);
+    state.filePath = filePath;
+    watchFile(win, state);
+    updateTitle(win);
+    win.webContents.send("file-opened", { path: filePath, content: resolveImagePaths(data, filePath) });
+  }).catch(() => {
+  });
+}
+function findWindowForFile(filePath) {
+  for (const [id, state] of windowStates) {
+    if (state.filePath === filePath) {
+      return electron.BrowserWindow.fromId(id) || null;
+    }
+  }
+  return null;
+}
+function openFile(filePath) {
+  const existing = findWindowForFile(filePath);
+  if (existing) {
+    existing.focus();
+    return;
+  }
+  const emptyWin = findEmptyWindow();
+  if (emptyWin) {
+    loadFileInWindow(emptyWin, filePath);
+    emptyWin.focus();
+    return;
+  }
+  const win = createWindow(filePath);
+  win.focus();
+}
+function findEmptyWindow() {
+  for (const [id, state] of windowStates) {
+    if (!state.filePath) {
+      return electron.BrowserWindow.fromId(id) || null;
+    }
+  }
+  return null;
+}
+async function saveToPath(win, filePath, content) {
+  const state = getState(win);
+  try {
+    state.isInternalSave = true;
+    await promises.writeFile(filePath, content, "utf-8");
+    state.filePath = filePath;
+    watchFile(win, state);
+    updateTitle(win);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    setTimeout(() => {
+      state.isInternalSave = false;
+    }, 100);
+  }
+}
+electron.ipcMain.on("open-external", (_event, url) => {
+  if (typeof url === "string" && (url.startsWith("https://") || url.startsWith("http://"))) {
+    electron.shell.openExternal(url);
+  }
+});
+electron.ipcMain.handle("open-file", async (event) => {
+  const win = getWinFromEvent(event);
+  if (!win) return null;
+  const result = await electron.dialog.showOpenDialog(win, {
+    filters: [
+      { name: "Markdown", extensions: ["md", "markdown", "mdown", "mkd"] },
+      { name: "Text", extensions: ["txt"] },
+      { name: "All Files", extensions: ["*"] }
+    ],
+    properties: ["openFile"]
+  });
+  if (result.canceled || result.filePaths.length === 0) return null;
+  const filePath = result.filePaths[0];
+  const state = getState(win);
+  if (!state.filePath) {
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      state.filePath = filePath;
+      watchFile(win, state);
+      updateTitle(win);
+      return { path: filePath, content };
+    } catch {
+      return null;
+    }
+  } else {
+    openFile(filePath);
+    return null;
+  }
+});
+electron.ipcMain.handle("open-file-path", async (event, filePath) => {
+  const win = getWinFromEvent(event);
+  if (!win) return null;
+  const state = getState(win);
+  if (!state.filePath) {
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      state.filePath = filePath;
+      watchFile(win, state);
+      updateTitle(win);
+      return { path: filePath, content };
+    } catch {
+      return null;
+    }
+  } else {
+    openFile(filePath);
+    return null;
+  }
+});
+electron.ipcMain.handle("save-file", async (event, content) => {
+  const win = getWinFromEvent(event);
+  if (!win) return false;
+  const state = getState(win);
+  if (!state.filePath) {
+    const result = await electron.dialog.showSaveDialog(win, {
+      defaultPath: suggestFileName(win, content),
+      filters: [
+        { name: "Markdown", extensions: ["md"] },
+        { name: "All Files", extensions: ["*"] }
+      ]
+    });
+    if (result.canceled || !result.filePath) return false;
+    state.filePath = result.filePath;
+    if (content.includes("kicker:") || content.includes("chip:")) {
+      const destDir = path.dirname(state.filePath);
+      try {
+        const files = await promises.readdir(slidesTemplateDir);
+        await Promise.all(files.filter((f) => f !== "slides-template.md").map(async (f) => {
+          const dest = path.join(destDir, f);
+          if (!fs.existsSync(dest)) await promises.copyFile(path.join(slidesTemplateDir, f), dest);
+        }));
+      } catch {
+      }
+    }
+  }
+  return saveToPath(win, state.filePath, content);
+});
+electron.ipcMain.handle("save-file-as", async (event, content) => {
+  const win = getWinFromEvent(event);
+  if (!win) return false;
+  const result = await electron.dialog.showSaveDialog(win, {
+    defaultPath: suggestFileName(win, content),
+    filters: [
+      { name: "Markdown", extensions: ["md"] },
+      { name: "All Files", extensions: ["*"] }
+    ]
+  });
+  if (result.canceled || !result.filePath) return false;
+  return saveToPath(win, result.filePath, content);
+});
+electron.ipcMain.handle("save-export-file", async (event, dataUrl, defaultName) => {
+  const win = getWinFromEvent(event);
+  if (!win) return false;
+  const ext = (defaultName.match(/\.(\w+)$/)?.[1] || "png").toLowerCase();
+  const result = await electron.dialog.showSaveDialog(win, {
+    defaultPath: defaultName,
+    filters: [{ name: `${ext.toUpperCase()} File`, extensions: [ext] }]
+  });
+  if (result.canceled || !result.filePath) return false;
+  try {
+    const base64 = dataUrl.replace(/^data:[^;]+;base64,/, "");
+    await promises.writeFile(result.filePath, Buffer.from(base64, "base64"));
+    return true;
+  } catch {
+    return false;
+  }
+});
+electron.ipcMain.handle("export-pdf", async (event) => {
+  const win = getWinFromEvent(event);
+  if (!win) return false;
+  const result = await electron.dialog.showSaveDialog(win, {
+    defaultPath: suggestFileName(win),
+    filters: [{ name: "PDF", extensions: ["pdf"] }]
+  });
+  if (result.canceled || !result.filePath) return false;
+  try {
+    const cssKey = await win.webContents.insertCSS(
+      "html, body { height: auto !important; overflow: visible !important; } #titlebar { display: none !important; } #editor { height: auto !important; overflow: visible !important; } #editor .ProseMirror { min-height: auto !important; } .mermaid-error { display: none !important; } .mermaid-loading { display: none !important; } svg .error-icon, svg .error-text { display: none !important; } .math-inline-raw, .math-block-raw, textarea.mermaid-source { display: none !important; }"
+    );
+    const pdfData = await win.webContents.printToPDF({
+      marginType: 0,
+      printBackground: true,
+      pageSize: "A4"
+    });
+    await win.webContents.removeInsertedCSS(cssKey);
+    await promises.writeFile(result.filePath, pdfData);
+    return true;
+  } catch {
+    return false;
+  }
+});
+electron.ipcMain.handle("export-html", async (event, htmlContent) => {
+  const win = getWinFromEvent(event);
+  if (!win) return false;
+  const result = await electron.dialog.showSaveDialog(win, {
+    defaultPath: suggestFileName(win),
+    filters: [{ name: "HTML", extensions: ["html"] }]
+  });
+  if (result.canceled || !result.filePath) return false;
+  try {
+    await promises.writeFile(result.filePath, htmlContent, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+});
+const slidesTemplateDir = electron.app.isPackaged ? path.join(process.resourcesPath, "templates", "slides") : path.join(__dirname, "../../resources/templates/slides");
+const slidesServers = /* @__PURE__ */ new Map();
+const MIME = {
+  ".html": "text/html",
+  ".md": "text/plain",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon"
+};
+function getOrCreateSlidesServer(dir) {
+  const existing = slidesServers.get(dir);
+  if (existing) return Promise.resolve(existing.port);
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = req.url === "/" ? "/template.html" : req.url || "/";
+      const filePath = path.join(dir, url.split("?")[0]);
+      const ext = path.extname(filePath).toLowerCase();
+      const mime = MIME[ext] || "application/octet-stream";
+      try {
+        const data = fs.readFileSync(filePath);
+        res.writeHead(200, { "Content-Type": mime });
+        res.end(data);
+      } catch {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("no port"));
+        return;
+      }
+      slidesServers.set(dir, { port: addr.port, server });
+      resolve(addr.port);
+    });
+    server.on("error", reject);
+  });
+}
+electron.ipcMain.handle("new-slides", async (event) => {
+  const win = getWinFromEvent(event);
+  if (!win) return null;
+  try {
+    const content = await promises.readFile(path.join(slidesTemplateDir, "slides-template.md"), "utf-8");
+    win.webContents.send("new-slides-content", content);
+    return true;
+  } catch {
+    return null;
+  }
+});
+electron.ipcMain.handle("open-as-slides", async (event, content) => {
+  const win = getWinFromEvent(event);
+  if (!win) return false;
+  const state = getState(win);
+  if (!state.filePath) {
+    const result = await electron.dialog.showSaveDialog(win, {
+      title: "Create New Slides",
+      defaultPath: "slides.md",
+      filters: [{ name: "Markdown", extensions: ["md"] }]
+    });
+    if (result.canceled || !result.filePath) return false;
+    try {
+      await promises.copyFile(path.join(slidesTemplateDir, "slides-template.md"), result.filePath);
+      loadFileInWindow(win, result.filePath);
+      state.filePath = result.filePath;
+    } catch {
+      return false;
+    }
+  }
+  if (content !== void 0 && state.filePath) {
+    try {
+      await promises.writeFile(state.filePath, content, "utf-8");
+    } catch {
+    }
+  }
+  const dir = path.dirname(state.filePath);
+  const mdName = path.basename(state.filePath);
+  const templateDest = path.join(dir, "template.html");
+  try {
+    await promises.copyFile(path.join(slidesTemplateDir, "template.html"), templateDest);
+  } catch {
+    return false;
+  }
+  if (mdName !== "slides.md") {
+    try {
+      let html = await promises.readFile(templateDest, "utf-8");
+      html = html.replace(/fetch\('slides\.md'\)/, `fetch('${mdName}')`);
+      await promises.writeFile(templateDest, html, "utf-8");
+    } catch {
+    }
+  }
+  try {
+    const port = await getOrCreateSlidesServer(dir);
+    electron.shell.openExternal(`http://127.0.0.1:${port}/template.html`);
+    return true;
+  } catch {
+    return false;
+  }
+});
+electron.ipcMain.handle("export-slides", async (event, content) => {
+  const win = getWinFromEvent(event);
+  if (!win) return false;
+  const state = getState(win);
+  if (!state.filePath) return false;
+  const srcDir = path.dirname(state.filePath);
+  const videoRefs = [...content.matchAll(/<!--\s*type:\s*video[^>]*src:\s*([^\s,>]+)/g)].map((m) => m[1].trim()).filter(Boolean);
+  const hasVideo = videoRefs.length > 0;
+  let destDir;
+  let destHtml;
+  if (hasVideo) {
+    const result = await electron.dialog.showSaveDialog(win, {
+      title: "Export Slides Folder",
+      defaultPath: path.join(srcDir, "slides-export"),
+      buttonLabel: "Export"
+    });
+    if (result.canceled || !result.filePath) return false;
+    destDir = result.filePath;
+    destHtml = path.join(destDir, "index.html");
+    await promises.mkdir(destDir, { recursive: true });
+  } else {
+    const result = await electron.dialog.showSaveDialog(win, {
+      title: "Export Slides",
+      defaultPath: path.join(srcDir, "slides.html"),
+      filters: [{ name: "HTML", extensions: ["html"] }]
+    });
+    if (result.canceled || !result.filePath) return false;
+    destDir = path.dirname(result.filePath);
+    destHtml = result.filePath;
+  }
+  let html = await promises.readFile(path.join(srcDir, "template.html"), "utf-8");
+  const escaped = content.replace(/`/g, "\\`").replace(/\$/g, "\\$");
+  html = html.replace(
+    /fetch\('[^']+'\)\s*\n?\s*\.then\(r => r\.text\(\)\)/,
+    `Promise.resolve(\`${escaped}\`)`
+  );
+  const imgMatches = [...content.matchAll(/!\[[^\]]*\]\((?!https?:\/\/|data:)([^)]+)\)/g)];
+  const inlinedImages = /* @__PURE__ */ new Map();
+  for (const m of imgMatches) {
+    const imgPath = m[1].trim();
+    if (inlinedImages.has(imgPath)) continue;
+    try {
+      const abs = path.join(srcDir, imgPath);
+      const buf = await promises.readFile(abs);
+      const ext = path.extname(imgPath).slice(1).toLowerCase();
+      const mime = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "png" ? "image/png" : ext === "gif" ? "image/gif" : ext === "webp" ? "image/webp" : ext === "svg" ? "image/svg+xml" : "image/png";
+      inlinedImages.set(imgPath, `data:${mime};base64,${buf.toString("base64")}`);
+    } catch {
+    }
+  }
+  for (const [src, dataUrl] of inlinedImages) {
+    html = html.replaceAll(`src="${src}"`, `src="${dataUrl}"`);
+    html = html.replaceAll(`src='${src}'`, `src='${dataUrl}'`);
+  }
+  if (hasVideo) {
+    for (const videoSrc of videoRefs) {
+      try {
+        await promises.copyFile(path.join(srcDir, videoSrc), path.join(destDir, videoSrc));
+      } catch {
+      }
+    }
+  }
+  await promises.writeFile(destHtml, html, "utf-8");
+  electron.shell.showItemInFolder(destHtml);
+  return true;
+});
+electron.ipcMain.handle("load-custom-theme", async (event) => {
+  const win = getWinFromEvent(event);
+  if (!win) return null;
+  const result = await electron.dialog.showOpenDialog(win, {
+    filters: [{ name: "CSS", extensions: ["css"] }],
+    properties: ["openFile"]
+  });
+  if (result.canceled || result.filePaths.length === 0) return null;
+  try {
+    const srcPath = result.filePaths[0];
+    const fileName = path.basename(srcPath);
+    const destPath = path.join(themesDir, fileName);
+    await promises.copyFile(srcPath, destPath);
+    const css = await promises.readFile(destPath, "utf-8");
+    buildMenu();
+    return { name: fileName, css };
+  } catch {
+    return null;
+  }
+});
+electron.ipcMain.handle("load-theme-css", async (_event, fileName) => {
+  try {
+    return await promises.readFile(path.join(themesDir, fileName), "utf-8");
+  } catch {
+    return null;
+  }
+});
+electron.ipcMain.handle("register-plugins", (_event, plugins) => {
+  pluginMenuItems = plugins.map((p) => ({
+    id: p.id,
+    label: p.name,
+    type: "checkbox",
+    checked: p.enabled,
+    click: () => sendToFocused("menu-toggle-plugin", p.id)
+  }));
+  buildMenu();
+  return true;
+});
+electron.ipcMain.handle("sync-plugin-state", (_event, id, enabled) => {
+  const item = pluginMenuItems.find((p) => p.id === id);
+  if (item) item.checked = enabled;
+  buildMenu();
+});
+function getFocusedWindow() {
+  return electron.BrowserWindow.getFocusedWindow();
+}
+function sendToFocused(channel, ...args) {
+  const win = getFocusedWindow();
+  if (win) win.webContents.send(channel, ...args);
+}
+function buildMenu() {
+  const isMac = process.platform === "darwin";
+  const customThemeItems = [];
+  try {
+    const files = fs.readdirSync(themesDir).filter((f) => f.endsWith(".css")).sort();
+    for (const file of files) {
+      customThemeItems.push({
+        label: file.replace(/\.css$/, ""),
+        click: async () => {
+          try {
+            const css = await promises.readFile(path.join(themesDir, file), "utf-8");
+            sendToFocused("set-theme", `custom:${file}`);
+            sendToFocused("set-custom-css", css);
+          } catch {
+          }
+        }
+      });
+    }
+  } catch {
+  }
+  const themeSubmenu = [
+    { label: "Light", click: () => sendToFocused("set-theme", "light") },
+    { label: "Dark", click: () => sendToFocused("set-theme", "dark") },
+    { label: "Elegant", click: () => sendToFocused("set-theme", "elegant") },
+    { label: "Newsprint", click: () => sendToFocused("set-theme", "newsprint") }
+  ];
+  if (customThemeItems.length > 0) {
+    themeSubmenu.push({ type: "separator" }, ...customThemeItems);
+  }
+  themeSubmenu.push({ type: "separator" }, {
+    label: "Import Theme...",
+    click: () => sendToFocused("menu-import-theme")
+  });
+  const template = [
+    ...isMac ? [{
+      label: "ColaMD",
+      submenu: [
+        { role: "about" },
+        { type: "separator" },
+        { role: "hide" },
+        { role: "hideOthers" },
+        { role: "unhide" },
+        { type: "separator" },
+        { role: "quit" }
+      ]
+    }] : [],
+    {
+      label: "File",
+      submenu: [
+        {
+          label: "New",
+          accelerator: "CmdOrCtrl+N",
+          click: () => createWindow()
+        },
+        {
+          label: "New Slides...",
+          accelerator: "CmdOrCtrl+Shift+N",
+          click: () => sendToFocused("menu-new-slides")
+        },
+        {
+          label: "Open...",
+          accelerator: "CmdOrCtrl+O",
+          click: () => sendToFocused("menu-open")
+        },
+        { type: "separator" },
+        {
+          label: "Save",
+          accelerator: "CmdOrCtrl+S",
+          click: () => sendToFocused("menu-save")
+        },
+        {
+          label: "Save As...",
+          accelerator: "CmdOrCtrl+Shift+S",
+          click: () => sendToFocused("menu-save-as")
+        },
+        { type: "separator" },
+        {
+          label: "Export PDF...",
+          click: () => sendToFocused("menu-export-pdf")
+        },
+        {
+          label: "Export HTML...",
+          click: () => sendToFocused("menu-export-html")
+        },
+        {
+          label: "Export Slides...",
+          click: () => sendToFocused("menu-export-slides")
+        },
+        {
+          label: "Open as Slides",
+          accelerator: "CmdOrCtrl+Shift+P",
+          click: () => sendToFocused("menu-open-as-slides")
+        },
+        { type: "separator" },
+        isMac ? { role: "close" } : { role: "quit" }
+      ]
+    },
+    {
+      label: "Edit",
+      submenu: [
+        { role: "undo" },
+        { role: "redo" },
+        { type: "separator" },
+        { role: "cut" },
+        { role: "copy" },
+        { role: "paste" },
+        { role: "selectAll" }
+      ]
+    },
+    {
+      label: "View",
+      submenu: [
+        { role: "resetZoom" },
+        { role: "zoomIn" },
+        { role: "zoomOut" },
+        { type: "separator" },
+        { role: "togglefullscreen" },
+        ...pluginMenuItems.length > 0 ? [{ type: "separator" }, { label: "Plugins", submenu: pluginMenuItems }] : []
+      ]
+    },
+    {
+      label: "Theme",
+      submenu: themeSubmenu
+    },
+    {
+      label: "Help",
+      submenu: [
+        {
+          label: "About ColaMD",
+          click: () => electron.shell.openExternal("https://github.com/marswaveai/colamd")
+        }
+      ]
+    }
+  ];
+  electron.Menu.setApplicationMenu(electron.Menu.buildFromTemplate(template));
+}
+electron.app.whenReady().then(() => {
+  ensureThemesDir();
+  buildMenu();
+  const args = process.argv.slice(electron.app.isPackaged ? 1 : 2);
+  const fileArgs = args.filter((arg) => !arg.startsWith("-"));
+  if (fileArgs.length > 0) {
+    pendingFilePaths = fileArgs;
+  }
+  if (pendingFilePaths.length > 0) {
+    for (const fp of pendingFilePaths) {
+      createWindow(fp);
+    }
+    pendingFilePaths = [];
+  } else {
+    createWindow();
+  }
+  electron.app.on("activate", () => {
+    if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+});
+electron.app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") electron.app.quit();
+});
+electron.app.on("open-file", (event, filePath) => {
+  event.preventDefault();
+  if (electron.app.isReady()) {
+    openFile(filePath);
+  } else {
+    pendingFilePaths.push(filePath);
+  }
+});