550 lines
22 KiB
JavaScript
550 lines
22 KiB
JavaScript
const { app, BrowserWindow, dialog } = require("electron");
|
||
const path = require("path");
|
||
const fs = require("fs");
|
||
const net = require("net");
|
||
|
||
/**
|
||
* 桌面端目标（M0）：让你回来后可直接安装并运行（不依赖 pnpm / 不要求客户端 Docker）。
|
||
*
|
||
* 说明：
|
||
* - 这里采用“内置 Next standalone 服务 + Electron 壳”的方式。
|
||
* - Next 的 standalone 产物由 `pnpm run build:desktop:next` 生成，并在打包时放入
|
||
* `process.resourcesPath\\desktop-next`。
|
||
* - 运行期数据放在安装目录下的 `data\\`（满足“非 C 盘且可读写”要求）。
|
||
*/
|
||
|
||
function isPackaged() {
|
||
return app.isPackaged;
|
||
}
|
||
|
||
function ensureDir(dir) {
|
||
fs.mkdirSync(dir, { recursive: true });
|
||
}
|
||
|
||
function readJson(filePath) {
|
||
try {
|
||
const raw = fs.readFileSync(filePath, { encoding: "utf8" });
|
||
return JSON.parse(raw);
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function writeJson(filePath, value) {
|
||
fs.writeFileSync(filePath, JSON.stringify(value, null, 2), { encoding: "utf8" });
|
||
}
|
||
|
||
function normalizeSecret(raw) {
|
||
const trimmed = String(raw || "").trim();
|
||
if (!trimmed) return "";
|
||
if (
|
||
(trimmed.startsWith("\"") && trimmed.endsWith("\"") && trimmed.length >= 2) ||
|
||
(trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2)
|
||
) {
|
||
return trimmed.slice(1, -1).trim();
|
||
}
|
||
return trimmed;
|
||
}
|
||
|
||
function getDefaultDataDir() {
|
||
// 安装后：<安装目录>\MNOTE.exe -> <安装目录>\data
|
||
if (isPackaged()) {
|
||
return path.join(path.dirname(process.execPath), "data");
|
||
}
|
||
// 开发态：仓库根目录\data-local
|
||
return path.join(process.cwd(), "data-local");
|
||
}
|
||
|
||
function getDesktopNextDir() {
|
||
if (isPackaged()) {
|
||
return path.join(process.resourcesPath, "desktop-next");
|
||
}
|
||
// 开发态：仓库内的准备产物目录
|
||
return path.join(process.cwd(), "desktop-electron", "desktop-next");
|
||
}
|
||
|
||
function normalizeHttpUrl(input) {
|
||
const raw = String(input || "").trim();
|
||
if (!raw) return "";
|
||
return raw.replace(/\/+$/, "");
|
||
}
|
||
|
||
function getTcpTargetFromUrl(urlString) {
|
||
try {
|
||
const u = new URL(urlString);
|
||
if (u.protocol !== "http:" && u.protocol !== "https:") return null;
|
||
const port = Number(u.port) || (u.protocol === "https:" ? 443 : 80);
|
||
return { host: u.hostname, port };
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
async function checkTcpOpen(host, port, timeoutMs = 900) {
|
||
return await new Promise((resolve) => {
|
||
const socket = net.createConnection({ host, port });
|
||
const timer = setTimeout(() => {
|
||
socket.destroy();
|
||
resolve(false);
|
||
}, timeoutMs);
|
||
socket.once("connect", () => {
|
||
clearTimeout(timer);
|
||
socket.end();
|
||
resolve(true);
|
||
});
|
||
socket.once("error", () => {
|
||
clearTimeout(timer);
|
||
resolve(false);
|
||
});
|
||
});
|
||
}
|
||
|
||
async function checkUrlReachable(urlString, timeoutMs = 900) {
|
||
const target = getTcpTargetFromUrl(urlString);
|
||
if (!target) return false;
|
||
return await checkTcpOpen(target.host, target.port, timeoutMs);
|
||
}
|
||
|
||
async function applyDesktopEnvFromConfig(dataDir, logger) {
|
||
const cfgDir = path.join(dataDir, "electron");
|
||
ensureDir(cfgDir);
|
||
|
||
const cfgPath = path.join(cfgDir, "config.json");
|
||
|
||
// 兼容：用户可能会误以为配置在“安装目录/electron/config.json”或“安装目录/config.json”。
|
||
// 为了让配置更“可发现”，这里按“最近修改的文件优先”来选择配置来源。
|
||
const installDir = isPackaged()
|
||
? path.dirname(process.execPath)
|
||
: process.cwd();
|
||
const altCfgPaths = [
|
||
path.join(installDir, "electron", "config.json"),
|
||
path.join(installDir, "config.json"),
|
||
];
|
||
const candidateCfgPaths = [cfgPath, ...altCfgPaths];
|
||
|
||
const pickLatestExistingConfigPath = () => {
|
||
const existingPaths = candidateCfgPaths.filter((p) => fs.existsSync(p));
|
||
if (existingPaths.length === 0) return cfgPath;
|
||
const withMtime = existingPaths.map((p) => {
|
||
try {
|
||
return { p, mtimeMs: fs.statSync(p).mtimeMs };
|
||
} catch {
|
||
return { p, mtimeMs: 0 };
|
||
}
|
||
});
|
||
withMtime.sort((a, b) => b.mtimeMs - a.mtimeMs);
|
||
return withMtime[0]?.p ?? cfgPath;
|
||
};
|
||
|
||
const effectiveCfgPath = pickLatestExistingConfigPath();
|
||
const JWT_SECRET_PLACEHOLDER = "change-me-to-strong-secret";
|
||
|
||
// 公共环境文件（桌面端与网页端共用）：wolai-frontend/public/mnote-env.json
|
||
// 说明：打包后该文件会被复制到 resources/desktop-next/public/mnote-env.json
|
||
const publicEnvCandidates = [
|
||
path.join(getDesktopNextDir(), "public", "mnote-env.json"),
|
||
path.join(process.cwd(), "wolai-frontend", "public", "mnote-env.json"),
|
||
];
|
||
const publicEnvPath = publicEnvCandidates.find((p) => fs.existsSync(p));
|
||
const publicEnv = publicEnvPath ? readJson(publicEnvPath) : null;
|
||
if (publicEnvPath) {
|
||
logger.info(`公共环境文件：${publicEnvPath}`);
|
||
}
|
||
const defaults = {
|
||
// networkMode: "remote-client" | "auto" | "local" | "tunnel"
|
||
// remote-client：桌面端默认按“远程客户端”行为：Supabase/Backend 强制走 Tunnel；OnlyOffice 优先本地，没有再走 Tunnel。
|
||
networkMode: "remote-client",
|
||
// 说明：当需要走 Tunnel（例如远程测试机器上没有本地服务）时使用。
|
||
cloudflareAppOrigin:
|
||
normalizeHttpUrl(publicEnv?.cloudflareAppOrigin) || "https://frp-dry.com:16630",
|
||
// 说明：桌面端默认强制走 Tunnel（远程客户端），避免使用 127.0.0.1 等本机地址导致远程不可达。
|
||
supabaseUrl: normalizeHttpUrl(publicEnv?.supabaseUrl) || "https://frp-dry.com:38877",
|
||
supabaseUrlTunnel: normalizeHttpUrl(publicEnv?.supabaseUrl) || "https://frp-dry.com:38877",
|
||
// 注意：anon key 是公开的（浏览器端也会用），这里存储是为了桌面端可改成其它服务端地址。
|
||
supabaseAnonKey:
|
||
String(publicEnv?.supabaseAnonKey || "").trim() ||
|
||
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYW5vbiIsImlzcyI6InN1cGFiYXNlLWRldiIsImlhdCI6MTc2NDExNTA0OSwiZXhwIjoyMDc5NDc1MDQ5fQ.18ohcQZXVkoR1TIF56QWJxHyoVnA9aarH-XfTyBJn1Y",
|
||
backendUrl: normalizeHttpUrl(publicEnv?.backendUrl) || "https://frp-dry.com:44399",
|
||
backendUrlTunnel: normalizeHttpUrl(publicEnv?.backendUrl) || "https://frp-dry.com:44399",
|
||
onlyofficeBaseUrl: normalizeHttpUrl(publicEnv?.onlyofficeBaseUrlDesktop) || "http://localhost:8081",
|
||
onlyofficeBaseUrlTunnel:
|
||
normalizeHttpUrl(publicEnv?.onlyofficeBaseUrlWeb) || "https://frp-dry.com:54284",
|
||
onlyofficeStorageHostOverride: String(publicEnv?.onlyofficeStorageHostOverrideDesktop || "").trim(),
|
||
onlyofficeStorageHostOverrideTunnel: String(publicEnv?.onlyofficeStorageHostOverrideWeb || "").trim(),
|
||
onlyofficeProxyOriginTunnel:
|
||
normalizeHttpUrl(publicEnv?.onlyofficeProxyOriginWeb) ||
|
||
normalizeHttpUrl(publicEnv?.cloudflareAppOrigin) ||
|
||
"https://frp-dry.com:16630",
|
||
// 说明：如果你的 ONLYOFFICE 容器开启了 JWT，这里必须与容器里一致。
|
||
// 默认不启用（当前 onlyoffice-dev 容器通常是 JWT_ENABLED=false）
|
||
onlyofficeJwtSecret: "",
|
||
|
||
// 可选：AI 工具相关的内部服务（本地优先，失败走 Tunnel）
|
||
lightragUrl: "http://127.0.0.1:7777",
|
||
// 说明：当前默认不提供公网 LightRAG 隧道，避免误用旧域名导致不可用
|
||
lightragUrlTunnel: "",
|
||
mineruEndpoint: "http://127.0.0.1:18888",
|
||
// 说明：当前默认不提供公网 MinerU 隧道，避免误用旧域名导致不可用
|
||
mineruEndpointTunnel: "",
|
||
searxngBaseUrl: "http://127.0.0.1:8889",
|
||
searxngBaseUrlTunnel: "",
|
||
// 说明：如果你对公网 searxng 开了 token，可在这里填；不填则按公开实例访问
|
||
searxngApiToken: "",
|
||
};
|
||
|
||
logger.info(`桌面端配置候选：${candidateCfgPaths.join(" | ")}`);
|
||
logger.info(`桌面端配置来源：${effectiveCfgPath}`);
|
||
|
||
const existing = fs.existsSync(effectiveCfgPath) ? readJson(effectiveCfgPath) : null;
|
||
const cfg = { ...defaults, ...(existing && typeof existing === "object" ? existing : {}) };
|
||
// 兼容旧配置：如果用户 config.json 里把 key 置空，会导致 Supabase 返回 “No API key found in request”
|
||
if (!String(cfg.supabaseAnonKey || "").trim()) {
|
||
cfg.supabaseAnonKey = defaults.supabaseAnonKey;
|
||
}
|
||
if (!String(cfg.supabaseUrl || "").trim()) {
|
||
cfg.supabaseUrl = defaults.supabaseUrl;
|
||
}
|
||
if (!String(cfg.supabaseUrlTunnel || "").trim()) {
|
||
cfg.supabaseUrlTunnel = defaults.supabaseUrlTunnel;
|
||
}
|
||
if (!existing) {
|
||
// 仅在不存在任何可用配置时，才写入默认配置到标准路径（data/electron/config.json）
|
||
writeJson(cfgPath, cfg);
|
||
}
|
||
|
||
logger.info(`加载桌面端配置：${existing ? effectiveCfgPath : cfgPath}`);
|
||
|
||
const modeRaw = String(cfg.networkMode || "").toLowerCase();
|
||
const mode = modeRaw && modeRaw !== "auto" ? modeRaw : "remote-client";
|
||
const localSupabaseUrl = normalizeHttpUrl(cfg.supabaseUrl);
|
||
const tunnelSupabaseUrl = normalizeHttpUrl(cfg.supabaseUrlTunnel);
|
||
const localOnlyofficeBaseUrl = normalizeHttpUrl(cfg.onlyofficeBaseUrl);
|
||
const tunnelOnlyofficeBaseUrl = normalizeHttpUrl(cfg.onlyofficeBaseUrlTunnel);
|
||
const localOnlyofficeStorageHostOverride = String(cfg.onlyofficeStorageHostOverride || "").trim();
|
||
const tunnelOnlyofficeStorageHostOverride = String(cfg.onlyofficeStorageHostOverrideTunnel || "").trim();
|
||
const localBackendUrl = normalizeHttpUrl(cfg.backendUrl);
|
||
const tunnelBackendUrl = normalizeHttpUrl(cfg.backendUrlTunnel);
|
||
const localLightragUrl = normalizeHttpUrl(cfg.lightragUrl);
|
||
const tunnelLightragUrl = normalizeHttpUrl(cfg.lightragUrlTunnel);
|
||
const localMineruEndpoint = normalizeHttpUrl(cfg.mineruEndpoint);
|
||
const tunnelMineruEndpoint = normalizeHttpUrl(cfg.mineruEndpointTunnel);
|
||
const localSearxngBaseUrl = normalizeHttpUrl(cfg.searxngBaseUrl);
|
||
const tunnelSearxngBaseUrl = normalizeHttpUrl(cfg.searxngBaseUrlTunnel);
|
||
|
||
let effectiveSupabaseUrl = localSupabaseUrl;
|
||
let effectiveBackendUrl = localBackendUrl;
|
||
let effectiveOnlyofficeBaseUrl = localOnlyofficeBaseUrl;
|
||
let effectiveOnlyofficeStorageHostOverride = localOnlyofficeStorageHostOverride;
|
||
let effectiveOnlyofficeProxyOrigin = "";
|
||
let onlyofficeModeLabel = "local";
|
||
|
||
if (mode === "remote-client") {
|
||
// 远程客户端默认：Supabase/Backend 强制走 Tunnel。
|
||
effectiveSupabaseUrl = tunnelSupabaseUrl || localSupabaseUrl;
|
||
effectiveBackendUrl = tunnelBackendUrl || localBackendUrl;
|
||
|
||
// OnlyOffice：优先本地，本地不可达再用 Tunnel。
|
||
const localOnlyofficeOk = await checkUrlReachable(localOnlyofficeBaseUrl);
|
||
const useTunnelForOnlyoffice = !localOnlyofficeOk && !!tunnelOnlyofficeBaseUrl;
|
||
onlyofficeModeLabel = useTunnelForOnlyoffice ? "tunnel" : "local";
|
||
effectiveOnlyofficeBaseUrl = useTunnelForOnlyoffice ? tunnelOnlyofficeBaseUrl : localOnlyofficeBaseUrl;
|
||
|
||
// 关键：在“远程客户端 + 本地 OnlyOffice”的组合里，必须禁用 storageHostOverride，
|
||
// 否则会把 https://supabase.<域名> 的地址强行改写成 host.docker.internal，导致拉取失败。
|
||
effectiveOnlyofficeStorageHostOverride = useTunnelForOnlyoffice ? tunnelOnlyofficeStorageHostOverride : "";
|
||
|
||
effectiveOnlyofficeProxyOrigin = useTunnelForOnlyoffice
|
||
? normalizeHttpUrl(cfg.onlyofficeProxyOriginTunnel || cfg.cloudflareAppOrigin)
|
||
: "";
|
||
} else {
|
||
// 兼容旧模式：auto/local/tunnel
|
||
// 关键一致性：ONLYOFFICE 与 Supabase 必须处于同一“可达网络域”，否则文档服务器无法拉取文件。
|
||
const localSupabaseOk = await checkUrlReachable(localSupabaseUrl);
|
||
const localOnlyofficeOk = await checkUrlReachable(localOnlyofficeBaseUrl);
|
||
const useTunnelForDoc =
|
||
mode === "tunnel" || (mode !== "local" && !(localSupabaseOk && localOnlyofficeOk));
|
||
|
||
effectiveSupabaseUrl = useTunnelForDoc && tunnelSupabaseUrl ? tunnelSupabaseUrl : localSupabaseUrl;
|
||
effectiveOnlyofficeBaseUrl =
|
||
useTunnelForDoc && tunnelOnlyofficeBaseUrl ? tunnelOnlyofficeBaseUrl : localOnlyofficeBaseUrl;
|
||
effectiveOnlyofficeStorageHostOverride = useTunnelForDoc
|
||
? tunnelOnlyofficeStorageHostOverride
|
||
: localOnlyofficeStorageHostOverride;
|
||
onlyofficeModeLabel = useTunnelForDoc ? "tunnel" : "local";
|
||
|
||
const localBackendOk = await checkUrlReachable(localBackendUrl);
|
||
const useTunnelForBackend = mode === "tunnel" || (mode !== "local" && !localBackendOk);
|
||
effectiveBackendUrl =
|
||
useTunnelForBackend && tunnelBackendUrl ? tunnelBackendUrl : localBackendUrl;
|
||
|
||
effectiveOnlyofficeProxyOrigin = useTunnelForDoc
|
||
? normalizeHttpUrl(cfg.onlyofficeProxyOriginTunnel || cfg.cloudflareAppOrigin)
|
||
: "";
|
||
}
|
||
|
||
const localLightragOk = await checkUrlReachable(localLightragUrl);
|
||
const useTunnelForLightrag = mode === "tunnel" || (mode !== "local" && !localLightragOk);
|
||
const effectiveLightragUrl =
|
||
useTunnelForLightrag && tunnelLightragUrl ? tunnelLightragUrl : localLightragUrl;
|
||
|
||
const localMineruOk = await checkUrlReachable(localMineruEndpoint);
|
||
const useTunnelForMineru = mode === "tunnel" || (mode !== "local" && !localMineruOk);
|
||
const effectiveMineruEndpoint =
|
||
useTunnelForMineru && tunnelMineruEndpoint ? tunnelMineruEndpoint : localMineruEndpoint;
|
||
|
||
const localSearxngOk = await checkUrlReachable(localSearxngBaseUrl);
|
||
const effectiveSearxngBaseUrl =
|
||
mode === "tunnel" || (mode !== "local" && !localSearxngOk)
|
||
? tunnelSearxngBaseUrl || localSearxngBaseUrl
|
||
: localSearxngBaseUrl;
|
||
|
||
const supabaseModeLabel =
|
||
tunnelSupabaseUrl && effectiveSupabaseUrl === tunnelSupabaseUrl ? "tunnel" : "local";
|
||
const backendModeLabel =
|
||
tunnelBackendUrl && effectiveBackendUrl === tunnelBackendUrl ? "tunnel" : "local";
|
||
|
||
logger.info(
|
||
`桌面端网络模式：${mode}（supabase=${supabaseModeLabel} backend=${backendModeLabel} onlyoffice=${onlyofficeModeLabel}）`,
|
||
);
|
||
logger.info(`Supabase：${effectiveSupabaseUrl}`);
|
||
logger.info(`Backend：${effectiveBackendUrl}`);
|
||
logger.info(`OnlyOffice：${effectiveOnlyofficeBaseUrl}`);
|
||
logger.info(`Supabase anon key 长度：${String(cfg.supabaseAnonKey || "").length}`);
|
||
|
||
// 桌面端标记
|
||
process.env.MNOTE_DESKTOP = "1";
|
||
|
||
// 这些值会被 Next 运行期注入到 window.__MNOTE_RUNTIME_CONFIG__，客户端优先读取它们。
|
||
process.env.NEXT_PUBLIC_SUPABASE_URL = effectiveSupabaseUrl;
|
||
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY = cfg.supabaseAnonKey;
|
||
process.env.NEXT_PUBLIC_BACKEND_URL = effectiveBackendUrl;
|
||
process.env.BACKEND_URL = effectiveBackendUrl;
|
||
process.env.NEXT_PUBLIC_ONLYOFFICE_BASE_URL = effectiveOnlyofficeBaseUrl;
|
||
process.env.NEXT_PUBLIC_ONLYOFFICE_STORAGE_HOST_OVERRIDE = effectiveOnlyofficeStorageHostOverride;
|
||
process.env.NEXT_PUBLIC_CLOUDFLARE_APP_ORIGIN = normalizeHttpUrl(cfg.cloudflareAppOrigin);
|
||
|
||
// 服务端用（route handlers）
|
||
process.env.SUPABASE_INTERNAL_URL = effectiveSupabaseUrl;
|
||
process.env.SUPABASE_URL = effectiveSupabaseUrl;
|
||
process.env.SUPABASE_ANON_KEY = cfg.supabaseAnonKey;
|
||
|
||
// AI 工具：内部服务地址（route handlers 使用）
|
||
if (effectiveLightragUrl) process.env.LIGHTRAG_URL = effectiveLightragUrl;
|
||
if (effectiveMineruEndpoint) process.env.MINERU_ENDPOINT = effectiveMineruEndpoint;
|
||
if (effectiveSearxngBaseUrl) process.env.SEARXNG_BASE_URL = effectiveSearxngBaseUrl;
|
||
if (cfg.searxngApiToken) process.env.SEARXNG_API_TOKEN = String(cfg.searxngApiToken || "").trim();
|
||
|
||
// ONLYOFFICE：远端文档服务器需要可访问的 proxy origin
|
||
delete process.env.NEXT_PUBLIC_ONLYOFFICE_PROXY_ORIGIN;
|
||
delete process.env.ONLYOFFICE_PROXY_ORIGIN;
|
||
if (effectiveOnlyofficeProxyOrigin) {
|
||
process.env.NEXT_PUBLIC_ONLYOFFICE_PROXY_ORIGIN = effectiveOnlyofficeProxyOrigin;
|
||
process.env.ONLYOFFICE_PROXY_ORIGIN = effectiveOnlyofficeProxyOrigin;
|
||
}
|
||
|
||
// 确保运行期行为可预测：优先以桌面端 config.json 为准（避免外部 .env 残留干扰）
|
||
delete process.env.ONLYOFFICE_JWT_SECRET;
|
||
const ooSecret = normalizeSecret(cfg.onlyofficeJwtSecret);
|
||
if (ooSecret && ooSecret !== JWT_SECRET_PLACEHOLDER) {
|
||
process.env.ONLYOFFICE_JWT_SECRET = ooSecret;
|
||
} else if (ooSecret === JWT_SECRET_PLACEHOLDER) {
|
||
logger.warn(
|
||
`检测到 ONLYOFFICE JWT 占位 secret（${JWT_SECRET_PLACEHOLDER}），已按未启用处理；如需启用 JWT，请在 ${cfgPath} 填写真实 secret 并同步到 onlyoffice 容器。`,
|
||
);
|
||
}
|
||
}
|
||
|
||
async function getFreePort() {
|
||
return await new Promise((resolve, reject) => {
|
||
const server = net.createServer();
|
||
server.once("error", reject);
|
||
server.listen(0, "127.0.0.1", () => {
|
||
const { port } = server.address();
|
||
server.close(() => resolve(port));
|
||
});
|
||
});
|
||
}
|
||
|
||
async function waitForPort(host, port, timeoutMs = 20_000) {
|
||
const start = Date.now();
|
||
// 简单轮询即可（避免引入额外依赖）
|
||
// eslint-disable-next-line no-constant-condition
|
||
while (true) {
|
||
const ok = await new Promise((resolve) => {
|
||
const socket = net.createConnection({ host, port });
|
||
const timer = setTimeout(() => {
|
||
socket.destroy();
|
||
resolve(false);
|
||
}, 500);
|
||
socket.once("connect", () => {
|
||
clearTimeout(timer);
|
||
socket.end();
|
||
resolve(true);
|
||
});
|
||
socket.once("error", () => {
|
||
clearTimeout(timer);
|
||
resolve(false);
|
||
});
|
||
});
|
||
if (ok) return;
|
||
if (Date.now() - start > timeoutMs) {
|
||
throw new Error(`等待本地服务启动超时：${host}:${port}`);
|
||
}
|
||
// 100ms 间隔
|
||
// eslint-disable-next-line no-await-in-loop
|
||
await new Promise((r) => setTimeout(r, 100));
|
||
}
|
||
}
|
||
|
||
function initLogging(dataDir) {
|
||
try {
|
||
const logDir = path.join(dataDir, "logs");
|
||
ensureDir(logDir);
|
||
const logFile = path.join(logDir, "desktop.log");
|
||
const write = (level, message) => {
|
||
const line = `[${new Date().toISOString()}] [${level}] ${message}\n`;
|
||
try {
|
||
fs.appendFileSync(logFile, line, { encoding: "utf8" });
|
||
} catch {
|
||
// ignore
|
||
}
|
||
};
|
||
return {
|
||
info: (m) => write("INFO", m),
|
||
warn: (m) => write("WARN", m),
|
||
error: (m) => write("ERROR", m),
|
||
};
|
||
} catch {
|
||
return {
|
||
info: () => {},
|
||
warn: () => {},
|
||
error: () => {},
|
||
};
|
||
}
|
||
}
|
||
|
||
async function startEmbeddedNext({ dataDir, logger }) {
|
||
const nextDir = getDesktopNextDir();
|
||
logger.info(`准备启动内置 Next：resources=${process.resourcesPath} nextDir=${nextDir}`);
|
||
if (!fs.existsSync(nextDir)) {
|
||
throw new Error(
|
||
`找不到内置前端产物目录：${nextDir}。请先执行 pnpm run build:desktop:next 或重新打包安装包。`,
|
||
);
|
||
}
|
||
|
||
// 运行期数据目录（文档/导图/日志等）
|
||
ensureDir(dataDir);
|
||
ensureDir(path.join(dataDir, "documents"));
|
||
ensureDir(path.join(dataDir, "logs"));
|
||
|
||
// 让 Next 的 server routes 使用可写目录，而非 process.cwd()/public
|
||
process.env.MNOTE_DATA_DIR = dataDir;
|
||
|
||
// 禁用遥测
|
||
process.env.NEXT_TELEMETRY_DISABLED = "1";
|
||
|
||
const forcedPort = Number(process.env.MNOTE_PORT || 0);
|
||
// 说明：桌面端默认固定用 3000（更利于 Supabase/后端的 CORS 规则配置）；若被占用再回退随机端口。
|
||
let port = forcedPort || 3000;
|
||
if (!forcedPort) {
|
||
try {
|
||
const probe = net.createServer();
|
||
await new Promise((resolve, reject) => {
|
||
probe.once("error", reject);
|
||
probe.listen(port, "127.0.0.1", () => resolve());
|
||
});
|
||
await new Promise((resolve) => probe.close(resolve));
|
||
} catch {
|
||
port = await getFreePort();
|
||
}
|
||
}
|
||
process.env.PORT = String(port);
|
||
process.env.HOSTNAME = "127.0.0.1";
|
||
process.env.NODE_ENV = "production";
|
||
|
||
// Next standalone 默认用当前工作目录作为根目录，因此这里 chdir 到 standalone 根
|
||
process.chdir(nextDir);
|
||
|
||
logger.info(`启动内置 Next：dir=${nextDir} port=${port}`);
|
||
try {
|
||
// eslint-disable-next-line global-require, import/no-dynamic-require
|
||
require(path.join(nextDir, "server.js"));
|
||
} catch (error) {
|
||
const message = error instanceof Error ? error.stack || error.message : String(error);
|
||
logger.error(`启动 Next 失败：${message}`);
|
||
throw error;
|
||
}
|
||
|
||
await waitForPort("127.0.0.1", port);
|
||
logger.info(`内置 Next 已就绪：http://127.0.0.1:${port}`);
|
||
return { port, url: `http://127.0.0.1:${port}` };
|
||
}
|
||
|
||
async function createMainWindow(loadUrl, { dataDir, logger }) {
|
||
const win = new BrowserWindow({
|
||
width: 1280,
|
||
height: 800,
|
||
show: false,
|
||
backgroundColor: "#ffffff",
|
||
webPreferences: {
|
||
preload: path.join(__dirname, "preload.js"),
|
||
contextIsolation: true,
|
||
nodeIntegration: false,
|
||
},
|
||
});
|
||
|
||
win.once("ready-to-show", () => win.show());
|
||
win.webContents.on("did-fail-load", (_e, code, desc, validatedUrl) => {
|
||
logger.error(`页面加载失败：code=${code} desc=${desc} url=${validatedUrl}`);
|
||
});
|
||
|
||
// 将 Electron 的 userData 也固定到安装目录下，避免散落到 C:\Users\...\AppData
|
||
await win.loadURL(loadUrl);
|
||
}
|
||
|
||
async function main() {
|
||
const dataDir = process.env.MNOTE_DATA_DIR || getDefaultDataDir();
|
||
const logger = initLogging(dataDir);
|
||
logger.info(`MNOTE 启动：packaged=${isPackaged()} execPath=${process.execPath} dataDir=${dataDir}`);
|
||
|
||
// 尽早固定 userData（建议在 ready 前设置，但这里仍尽量提前到窗口创建之前）
|
||
try {
|
||
app.setPath("userData", path.join(dataDir, "electron"));
|
||
} catch {
|
||
// ignore
|
||
}
|
||
|
||
// 桌面端运行期配置（避免 build 时的 .env.production.local 影响桌面体验）
|
||
await applyDesktopEnvFromConfig(dataDir, logger);
|
||
|
||
// 调试模式：允许直接指定 URL（例如你本地已手动启动 wolai-frontend dev）
|
||
const directUrl = process.env.MNOTE_LOAD_URL;
|
||
if (directUrl) {
|
||
logger.info(`使用外部 URL：${directUrl}`);
|
||
await createMainWindow(directUrl, { dataDir, logger });
|
||
return;
|
||
}
|
||
|
||
const { url } = await startEmbeddedNext({ dataDir, logger });
|
||
await createMainWindow(url, { dataDir, logger });
|
||
}
|
||
|
||
app.on("window-all-closed", () => {
|
||
// macOS 才保留常驻；Windows 直接退出
|
||
if (process.platform !== "darwin") {
|
||
app.quit();
|
||
}
|
||
});
|
||
|
||
app.on("activate", () => {
|
||
// no-op：当前只做单窗口
|
||
});
|
||
|
||
app.whenReady().then(main).catch((error) => {
|
||
dialog.showErrorBox(
|
||
"MNOTE 启动失败",
|
||
error instanceof Error ? error.stack || error.message : String(error),
|
||
);
|
||
app.quit();
|
||
});
|