2461 lines
108 KiB
JavaScript
2461 lines
108 KiB
JavaScript
// Electron 主进程
|
||
// 负责窗口管理、文件 IO、IPC 桥接
|
||
|
||
// 关键：如果系统环境变量 ELECTRON_RUN_AS_NODE=1 被设置，
|
||
// electron.exe 会作为普通 Node 运行而非 Electron。
|
||
// 这会让 `require('electron')` 返回路径字符串而非 API。
|
||
// 这里主动清除它，确保应用始终作为 Electron 运行。
|
||
if (process.env.ELECTRON_RUN_AS_NODE) {
|
||
console.log('[main] 检测到 ELECTRON_RUN_AS_NODE=1，已清除（避免被当作 Node）');
|
||
delete process.env.ELECTRON_RUN_AS_NODE;
|
||
}
|
||
|
||
// Windows 控制台编码修复：默认是 GBK(cp936)，导致中文日志乱码。
|
||
// 强制切换到 UTF-8，使 console.log 的中文能正确显示。
|
||
if (process.platform === 'win32') {
|
||
try {
|
||
process.stdout.setDefaultEncoding('utf8');
|
||
process.stderr.setDefaultEncoding('utf8');
|
||
} catch {
|
||
// 某些环境下 setDefaultEncoding 不可用，忽略
|
||
}
|
||
}
|
||
|
||
// GUI 启动场景下（双击图标 / 启动器退出后），主进程的 stdout/stderr
|
||
// 没有真实终端可写，console.log 在 flush 时会触发 EPIPE: broken pipe，
|
||
// 进而被 Electron 弹成「A JavaScript error occurred in the main process」。
|
||
// 给底层流挂 error 监听，把 EPIPE / ENOTCONN / EBADF 静默吞掉，
|
||
// console.log 仍按原样输出，只是不再让异常冒到顶层炸窗。
|
||
try {
|
||
for (const stream of [process.stdout, process.stderr]) {
|
||
if (stream && typeof stream.on === 'function') {
|
||
stream.on('error', (err) => {
|
||
if (err && (err.code === 'EPIPE' || err.code === 'ENOTCONN' || err.code === 'EBADF')) {
|
||
return; // 静默忽略：没有终端可写是正常的
|
||
}
|
||
// 其他错误写到 tmp 文件，避免被 Electron 弹成主进程错误框
|
||
try {
|
||
require('fs').appendFileSync(
|
||
require('path').join(require('os').tmpdir(), 'notes-main-stderr.log'),
|
||
`[${new Date().toISOString()}] ${err.stack || err}\n`
|
||
);
|
||
} catch { /* 兜底逻辑本身不应再抛 */ }
|
||
});
|
||
}
|
||
}
|
||
} catch {
|
||
// 兜底逻辑本身不应再抛
|
||
}
|
||
|
||
// 把主进程的 console.log / console.warn / console.error 同步写到日志文件，
|
||
// 这样即便 stdout 断了（GUI 启动 / 启动器关闭），日志仍可追溯。
|
||
// 不影响原有行为：仍会尝试写到 stdout（如果可用）。
|
||
//
|
||
// audit fix (M5)：之前写 %TEMP%\notes-main.log，多用户系统上 tmp 互相可读，
|
||
// 包含路径 / senderId 等的日志会被同机其他用户读到。改用 app.getPath('logs')
|
||
// （用户私有）作为首选；app 还没 ready 时退回 userData；都拿不到再退回
|
||
// %LOCALAPPDATA%（Windows）或 ~/.local/share（POSIX）。
|
||
try {
|
||
const _origLog = console.log;
|
||
const _origWarn = console.warn;
|
||
const _origError = console.error;
|
||
const _path = require('path');
|
||
const _fsSync = require('fs');
|
||
const _resolveLogDir = () => {
|
||
try {
|
||
const { app: _app } = require('electron');
|
||
if (_app && typeof _app.getPath === 'function') {
|
||
// logs 路径可能在 app ready 之前未注册；用 userData 作为兜底
|
||
try {
|
||
const logs = _app.getPath('logs');
|
||
if (logs) return logs;
|
||
} catch {}
|
||
try {
|
||
const ud = _app.getPath('userData');
|
||
if (ud) return ud;
|
||
} catch {}
|
||
}
|
||
} catch {}
|
||
if (process.platform === 'win32' && process.env.LOCALAPPDATA) {
|
||
return process.env.LOCALAPPDATA;
|
||
}
|
||
const home = require('os').homedir();
|
||
if (process.platform === 'darwin') return _path.join(home, 'Library', 'Application Support');
|
||
return _path.join(home, '.local', 'share');
|
||
};
|
||
const _logDir = _resolveLogDir();
|
||
const _logFile = _path.join(_logDir, 'notes-main.log');
|
||
const _writeLog = (level, args) => {
|
||
try {
|
||
// 兜底：目录可能不存在（首次启动 / 权限）→ 同步 mkdirSync recursive
|
||
_fsSync.mkdirSync(_logDir, { recursive: true });
|
||
_fsSync.appendFileSync(
|
||
_logFile,
|
||
`[${new Date().toISOString()}] [${level}] ${args.map((a) => (typeof a === 'string' ? a : require('util').inspect(a))).join(' ')}\n`
|
||
);
|
||
} catch { /* 写日志失败不应影响主流程 */ }
|
||
};
|
||
console.log = (...args) => { _origLog(...args); _writeLog('log', args); };
|
||
console.warn = (...args) => { _origWarn(...args); _writeLog('warn', args); };
|
||
console.error = (...args) => { _origError(...args); _writeLog('error', args); };
|
||
} catch {
|
||
// 重写 console 失败不应阻塞启动
|
||
}
|
||
|
||
const electronModule = require('electron');
|
||
|
||
// 检查 require('electron') 是否返回正确的 API（而非路径字符串）
|
||
// 在 Windows 上，如果项目路径包含非 ASCII 字符（如中文），可能会返回路径字符串
|
||
if (typeof electronModule === 'string' || !electronModule.app) {
|
||
const errMsg = `
|
||
================================================================================
|
||
[FATAL] require('electron') 返回了无效值！
|
||
|
||
问题原因: 项目路径包含非 ASCII 字符（如中文）
|
||
当前路径: ${__dirname}
|
||
返回值: ${typeof electronModule === 'string' ? '字符串 (路径)' : '无效对象'}
|
||
|
||
解决方法: 将项目移动到 ASCII 路径，例如:
|
||
D:\\Projects\\notes
|
||
C:\\dev\\notes
|
||
|
||
或者创建一个符号链接（mklink /D，管理员命令提示符）：
|
||
mklink /D C:\\dev\\notes "${__dirname}"
|
||
|
||
然后在符号链接路径下运行 npm start
|
||
================================================================================
|
||
`;
|
||
console.error(errMsg);
|
||
try {
|
||
const { app: appApi } = require('electron');
|
||
if (appApi && typeof appApi.whenReady === 'function') {
|
||
appApi.whenReady().then(() => {
|
||
const { BrowserWindow } = require('electron');
|
||
const win = new BrowserWindow({
|
||
width: 600,
|
||
height: 380,
|
||
resizable: false,
|
||
title: 'Notes - 启动错误'
|
||
});
|
||
win.loadURL('data:text/html;charset=utf-8,' + encodeURIComponent(`
|
||
<html><body style="font-family:sans-serif;padding:30px;background:#fee;color:#900;">
|
||
<h2>⚠ 启动失败</h2>
|
||
<p><b>问题：</b>项目路径包含非 ASCII 字符（如中文），导致 Electron 无法正确加载 API。</p>
|
||
<p><b>当前路径：</b><br><code>${__dirname}</code></p>
|
||
<p><b>解决方法：</b>将项目移动到 ASCII 路径（如 <code>D:\\Projects\\notes</code>）。</p>
|
||
<p style="margin-top:30px;color:#666;font-size:12px;">详细说明请查看 README。</p>
|
||
</body></html>
|
||
`));
|
||
});
|
||
return;
|
||
}
|
||
} catch {
|
||
// fallthrough
|
||
}
|
||
process.exit(1);
|
||
}
|
||
|
||
const { app, BrowserWindow, ipcMain, dialog, Menu, shell, Tray } = electronModule;
|
||
const path = require('path');
|
||
const fs = require('fs').promises;
|
||
const fsSync = require('fs');
|
||
// 设置 schema（单一事实源）—— 主进程、preload、renderer 三处共享。
|
||
// 新增/修改设置项只需改 shared/settings-schema.js 一处。
|
||
const { validateAndSanitize } = require('./shared/settings-schema.js');
|
||
// 配置持久化层（Stage 4b.1 抽离）
|
||
const configStore = require('./main/config-store');
|
||
// 目录监听层（Stage 4b.2 抽离）
|
||
// 依赖通过参数注入 —— 不直接引用 mainWindow / configStore / scanFiles
|
||
// scanFiles 是函数声明，会被 hoist；这里注册时还未执行定义，但调用时已可用。
|
||
const { createFsWatcher } = require('./main/fs-watcher');
|
||
// 文件操作 helper（Stage 7 抽出）：可测试的纯函数，IPC 注册仍在 main.js
|
||
// 包含 isWithinDataDir / resolveFileName / scanFiles / scanDir / assertNotSymlink / classifyEntry
|
||
const fileOps = require('./main/file-ops');
|
||
const {
|
||
MAX_FILE_SIZE,
|
||
isWithinDataDir,
|
||
resolveFileName,
|
||
resolveRenameName,
|
||
scanDir,
|
||
assertNotSymlink,
|
||
assertNoSymlinkAncestor,
|
||
resolveDirRelative,
|
||
toRelativeDir,
|
||
} = fileOps;
|
||
// AI 代理（用 Node 18+ 内置 fetch 调 OpenAI 兼容 API）
|
||
const { createAiProxy } = require('./main/ai');
|
||
// 启动标记：方便用户在 DevTools / 主进程控制台确认加载了最新代码
|
||
// （修改 main.js / main/*.js 后必须完全退出重启，主进程代码只在启动时 require 一次）
|
||
console.log('[main] AI proxy loaded — token field routing per model: gpt-5/o-series → max_completion_tokens, others → max_tokens');
|
||
|
||
// 窗口图标和系统托盘共用同一图标
|
||
const APP_ICON_PATH = path.join(__dirname, 'icon.ico');
|
||
|
||
// 日志路径脱敏 helper：console.error 写 tmp 文件时会带上 filePath（含用户名），
|
||
// 多用户系统上 tmp 可被其他用户读，且 ENOENT 也打路径 = 无成本枚举文件名。
|
||
// 只保留 basename，定位「哪个文件」已经足够；完整路径不在 tmp 落地。
|
||
function _redactPath(p) {
|
||
if (typeof p !== 'string' || !p) return p;
|
||
return path.basename(p);
|
||
}
|
||
|
||
/**
|
||
* 把 file:create 阶段的 errno 翻译成中文，name 用于「创建 X 失败」前缀；
|
||
* 路径只放在 console（已 _redactPath），不让完整路径回到 renderer。
|
||
* 与 file:write 的 renderer friendlyWriteError 一致地走「中文 + errno code」。
|
||
*/
|
||
function _friendlyCreateError(e, name) {
|
||
const n = name || '文件';
|
||
switch (e && e.code) {
|
||
case 'EACCES':
|
||
case 'EPERM':
|
||
return `没有写入权限，无法创建 ${n}`;
|
||
case 'ENOSPC':
|
||
return '磁盘空间不足，无法创建文件';
|
||
case 'EROFS':
|
||
return '只读文件系统，无法创建文件';
|
||
case 'EISDIR':
|
||
return '该路径是文件夹，无法写入';
|
||
case 'ENOENT':
|
||
return '所在目录不存在，无法创建文件';
|
||
default:
|
||
return `创建 ${n} 失败`;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* audit fix (K1-H1)：file:rename 的 errno 翻译 —— 与 _friendlyCreateError
|
||
* 对称：原路径已过 isWithinDataDir / symlink 守卫，到这层基本只剩 EACCES /
|
||
* EPERM / ENOSPC / EROFS / EEXIST（同名的目录挡住文件 rename 在不同平台错
|
||
* 误码不同）。新名字走 _friendlyCreateError 同款中文提示，不让英文 errno
|
||
* 直接回到 renderer（之前的 e.message 含「EPERM: operation not permitted」
|
||
* + 完整旧路径，调试日志和 UI 都泄露）。
|
||
*/
|
||
function _friendlyRenameError(e, newName) {
|
||
const n = newName || '文件';
|
||
switch (e && e.code) {
|
||
case 'EACCES':
|
||
case 'EPERM':
|
||
return `没有重命名权限，无法将文件改名为 ${n}`;
|
||
case 'ENOSPC':
|
||
return '磁盘空间不足，无法重命名';
|
||
case 'EROFS':
|
||
return '只读文件系统，无法重命名';
|
||
case 'EEXIST':
|
||
case 'ENOTEMPTY':
|
||
return `已存在同名项，无法重命名为 ${n}`;
|
||
case 'ENOENT':
|
||
return '原文件已被删除，无法重命名';
|
||
case 'EBUSY':
|
||
return '文件被占用，无法重命名';
|
||
default:
|
||
return `重命名 ${n} 失败`;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* audit fix (K1-L2)：file:delete 的 errno 翻译 —— 与上面 _friendly*Error
|
||
* 对称。shell.trashItem 失败的常见 errno：EACCES/EPERM（没权限）、
|
||
* EBUSY（文件被占）、ENOENT（已不存在）、EACCES+Windows 共享冲突。
|
||
*/
|
||
function _friendlyDeleteError(e) {
|
||
switch (e && e.code) {
|
||
case 'EACCES':
|
||
case 'EPERM':
|
||
return '没有删除权限，请检查文件权限';
|
||
case 'EBUSY':
|
||
return '文件被其他程序占用，无法移到回收站';
|
||
case 'ENOENT':
|
||
return '文件已不存在';
|
||
case 'ENOTDIR':
|
||
case 'EISDIR':
|
||
return '目标路径不是文件';
|
||
default:
|
||
return '无法移到回收站，请手动删除文件';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* audit fix (K1-M2)：file:read 的 errno 翻译。读路径常见 errno：
|
||
* EACCES/EPERM（权限）、EIO（磁盘 I/O）、EISDIR（路径是目录）、
|
||
* ENAMETOOLONG（路径过长）。
|
||
*/
|
||
function _friendlyReadError(e) {
|
||
switch (e && e.code) {
|
||
case 'EACCES':
|
||
case 'EPERM':
|
||
return '没有读取权限';
|
||
case 'EIO':
|
||
return '磁盘 I/O 错误';
|
||
case 'EISDIR':
|
||
return '该路径是文件夹，无法读取';
|
||
case 'ENAMETOOLONG':
|
||
return '路径过长';
|
||
default:
|
||
return '读取文件失败';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* audit fix (K1-R4)：shell/app:* handler 的 errno 翻译 —— 之前直接返回
|
||
* 英文 e.message（带完整路径）到 renderer，3 个 handler（app:open-path /
|
||
* shell:show-item-in-folder / shell:open-dir）都漏。统一走 _friendlyShellError
|
||
* 翻译成中文，与 _friendlyReadError / _friendlyCreateError 对齐。
|
||
*
|
||
* 这些 handler 多半是 stat 或 shell 操作，常见 errno：
|
||
* EACCES/EPERM（权限）、ENOENT（路径不在）、EIO（磁盘 I/O）、EBUSY（被占）。
|
||
*/
|
||
function _friendlyShellError(e, fallback) {
|
||
switch (e && e.code) {
|
||
case 'EACCES':
|
||
case 'EPERM':
|
||
return '没有访问权限';
|
||
case 'ENOENT':
|
||
return '路径不存在';
|
||
case 'EIO':
|
||
return '磁盘 I/O 错误';
|
||
case 'EBUSY':
|
||
return '文件被占用';
|
||
case 'ENOTDIR':
|
||
return '目标路径不是目录';
|
||
case 'EISDIR':
|
||
return '目标路径是文件夹';
|
||
case 'ENAMETOOLONG':
|
||
return '路径过长';
|
||
default:
|
||
return fallback || '操作失败';
|
||
}
|
||
}
|
||
|
||
// 抑制 Windows 上常见的 "Unable to move the cache" / "Gpu Cache Creation failed" 警告
|
||
app.commandLine.appendSwitch('disable-gpu-cache');
|
||
app.commandLine.appendSwitch('disable-features', 'CalculateNativeWinOcclusion');
|
||
|
||
let mainWindow = null;
|
||
let tray = null;
|
||
let isQuitting = false;
|
||
let currentDataDir = null;
|
||
let forceShowTimer = null;
|
||
let rendererDirty = false; // 渲染端是否有未保存改动
|
||
// 关闭按钮触发的脏检查防重入：用户连点 × 时二次点击若没有 this 守卫会跑
|
||
// 两次 confirmDiscardIfDirty（都 await promptRendererSave，让出事件循环），
|
||
// 弹出两个原生 dialog，关闭确认也跟着弹两次。镜像 before-quit 的
|
||
// quitConfirmInFlight 模式。
|
||
let closeConfirmInFlight = false;
|
||
|
||
// 渲染进程崩溃计数器（防止 reload 死循环）
|
||
let renderGoneCount = 0;
|
||
const MAX_RENDER_GONE_RELOADS = 3;
|
||
|
||
// 目录监听实例（Stage 4b.2 抽离到 main/fs-watcher.js）
|
||
// 注入依赖：getMainWindow 是闭包（每次访问时读 mainWindow 当前值），
|
||
// resolveDataDir 同理。scanDir / toRelDir 都是模块内函数，hoist 后可用。
|
||
// Stage 8：注入 scanDir + toRelDir，监听目标是「当前显示目录」而非固定根目录。
|
||
const fsWatcher = createFsWatcher({
|
||
getMainWindow: () => mainWindow,
|
||
// 走 currentDataRoot 而不是 resolveDataDir：fsWatcher 的 updateSnapshot 里要
|
||
// 用 dataRoot 重新做相对路径转换，customDir 失效场景下默认目录才是真实 root。
|
||
resolveDataDir: () => currentDataRoot(),
|
||
scanDir,
|
||
toRelDir: (absDir) => toRelativeDir(absDir, currentDataRoot()),
|
||
});
|
||
|
||
// AI 代理实例 —— 每次 runEdit 都现读 configStore.getConfig()，
|
||
// 用户改完 BaseURL / API Key / Model 不需要重启。
|
||
// P3-2 fix (audit)：注入 log hook 让 ai:request / ai:http_error 在主进程
|
||
// 控制台可见（线上排查 AI 失败时只能靠 DevTools network 面板）。
|
||
// payload 白名单字段（url/status/detail/model/filename/promptLen/contentLen）
|
||
// 已经不含 apiKey / Authorization 头。
|
||
const aiProxy = createAiProxy({
|
||
getConfig: () => configStore.getConfig(),
|
||
log: (key, payload) => console.log(`[main][${key}]`, payload),
|
||
});
|
||
|
||
// ============================================
|
||
// 启动日志
|
||
// ============================================
|
||
|
||
console.log('[main] Electron 启动中...');
|
||
console.log('[main] Platform:', process.platform);
|
||
console.log('[main] Electron version:', process.versions.electron);
|
||
console.log('[main] Project path:', __dirname);
|
||
|
||
// audit fix (Round 9)：全局兜底异常日志。之前的代码里 IPC handler / fsWatcher /
|
||
// AI 路径的异常基本都 try/catch + console.error，但仍有「外层 promise 链
|
||
// 没人 await」「fsWatcher 内部 setTimeout 回调抛」之类的边界场景 —— 没有
|
||
// 这里兜底会被 Node 默认行为吞掉（unhandledRejection 在新 Node 上是会
|
||
// terminate 进程的，uncaughtException 默认打印 + 退出），连日志都不留。
|
||
// 只 log 不 exit（与既有 try/catch 风格一致 —— 主进程挂了 IPC 全断）。
|
||
process.on('uncaughtException', (err, origin) => {
|
||
console.error('[main] uncaughtException:', err && (err.stack || err.message || err), 'origin:', origin);
|
||
});
|
||
process.on('unhandledRejection', (reason, promise) => {
|
||
console.error('[main] unhandledRejection at:', promise, 'reason:', reason && (reason.stack || reason.message || reason));
|
||
});
|
||
|
||
// ============================================
|
||
// 窗口创建
|
||
// ============================================
|
||
|
||
function createWindow() {
|
||
if (forceShowTimer) {
|
||
clearTimeout(forceShowTimer);
|
||
forceShowTimer = null;
|
||
}
|
||
|
||
mainWindow = new BrowserWindow({
|
||
width: 1200,
|
||
height: 760,
|
||
minWidth: 600,
|
||
minHeight: 420,
|
||
backgroundColor: '#0a0a0c',
|
||
icon: APP_ICON_PATH,
|
||
show: false,
|
||
autoHideMenuBar: true,
|
||
// 自定义窗口：去掉系统标题栏，改由 renderer 顶部工具栏的 -webkit-app-region: drag
|
||
// 接管拖拽，并在工具栏右侧画出自定义最小化/还原/关闭按钮。
|
||
frame: false,
|
||
titleBarStyle: 'hidden',
|
||
webPreferences: {
|
||
preload: path.join(__dirname, 'preload.js'),
|
||
contextIsolation: true,
|
||
nodeIntegration: false,
|
||
sandbox: false,
|
||
}
|
||
});
|
||
|
||
mainWindow.loadFile('index.html');
|
||
|
||
// 启动时应用持久化的「始终置顶」状态
|
||
if (configStore.getConfig().alwaysOnTop === true) {
|
||
mainWindow.setAlwaysOnTop(true);
|
||
}
|
||
|
||
mainWindow.once('ready-to-show', () => {
|
||
console.log('[main] 窗口 ready-to-show，显示窗口');
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
mainWindow.show();
|
||
}
|
||
broadcastMaximizeState();
|
||
});
|
||
|
||
// 兜底：2 秒后如果还没显示，强制显示
|
||
forceShowTimer = setTimeout(() => {
|
||
forceShowTimer = null;
|
||
if (mainWindow && !mainWindow.isDestroyed() && !mainWindow.isVisible()) {
|
||
console.warn('[main] ready-to-show 未触发，强制显示窗口');
|
||
mainWindow.show();
|
||
}
|
||
}, 2000);
|
||
// audit fix (Round 9)：timer 句柄 .unref()，防止它单独阻塞进程退出。
|
||
// 没有 .unref 的话，正常退出路径上 forceShowTimer 还没到 2s 触发的窗口里，
|
||
// electron 会等定时器到期才退（虽然窗口已 closed 但 event loop 还被它吊着）。
|
||
// audit fix (Round 9)：窗口重建时也会创建新的 forceShowTimer（createWindow
|
||
// 顶部清掉旧的）。unref 保证不阻塞退出。
|
||
if (forceShowTimer && typeof forceShowTimer.unref === 'function') {
|
||
forceShowTimer.unref();
|
||
}
|
||
|
||
// 错误监听
|
||
mainWindow.webContents.on('did-fail-load', (event, errorCode, errorDescription, validatedURL, isMainFrame) => {
|
||
console.error('[main] 页面加载失败:', errorCode, errorDescription, validatedURL, 'isMainFrame:', isMainFrame);
|
||
// audit fix (Round 9)：只对主框架错误弹致命 dialog。子框架（iframe）/ 主动
|
||
// abort（errorCode=-3 ERR_ABORTED —— 用户按 Esc / navigate 取消）属正常
|
||
// 路径，弹 dialog 反而扰民。errorCode=-3 是 Chromium 的 ERR_ABORTED。
|
||
if (!isMainFrame || errorCode === -3) return;
|
||
if (!mainWindow || mainWindow.isDestroyed()) return;
|
||
// 主框架加载失败 → renderer 完全没起来，UI 也没法弹 toast。在主进程弹
|
||
// 原生 dialog，让用户知道发生了什么并提供手动退出的按钮。
|
||
try {
|
||
dialog.showMessageBoxSync(mainWindow, {
|
||
type: 'error',
|
||
title: '页面加载失败',
|
||
message: '应用主页面加载失败',
|
||
detail: `${errorDescription} (${validatedURL})\n\n请尝试重启应用或从任务管理器结束进程后重试。`,
|
||
buttons: ['退出', '继续（已加载的页面可能不可用）'],
|
||
defaultId: 0,
|
||
cancelId: 0,
|
||
}) === 1 && console.warn('[main] 用户选择继续，主框架加载失败但继续运行');
|
||
} catch (e) {
|
||
console.error('[main] did-fail-load dialog 弹窗失败:', e);
|
||
}
|
||
});
|
||
|
||
mainWindow.webContents.on('render-process-gone', (event, details) => {
|
||
console.error('[main] 渲染进程崩溃:', details);
|
||
// 崩溃循环保护：3 次连续崩溃后不再 reload，避免无限循环占满 CPU
|
||
renderGoneCount += 1;
|
||
if (renderGoneCount > MAX_RENDER_GONE_RELOADS) {
|
||
console.error('[main] 渲染进程连续崩溃超过上限，停止自动 reload，请手动重启');
|
||
// audit fix (Round 9)：连续崩溃超上限弹致命 dialog 让用户决定。
|
||
// renderer 已经不可用，没法自己弹 toast，必须在主进程走 dialog。
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
try {
|
||
dialog.showMessageBoxSync(mainWindow, {
|
||
type: 'error',
|
||
title: '渲染进程连续崩溃',
|
||
message: '应用渲染进程连续崩溃，已停止自动恢复',
|
||
detail: `请尝试重启应用。如果问题持续，请到 GitHub 仓库反馈（控制台有更多细节）。\n\n原因：${details.reason || 'unknown'}`,
|
||
buttons: ['退出', '关闭此提示'],
|
||
defaultId: 0,
|
||
cancelId: 0,
|
||
});
|
||
} catch (e) {
|
||
console.error('[main] render-process-gone dialog 弹窗失败:', e);
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
mainWindow.reload();
|
||
}
|
||
});
|
||
|
||
// 崩溃计数器只在「连续崩溃」时累加；reload 成功后再清零，
|
||
// 否则跨多次会话累积 3 次后就再也触发不了自动恢复了。
|
||
mainWindow.webContents.on('did-finish-load', () => {
|
||
renderGoneCount = 0;
|
||
// audit fix (Round 9)：renderer 重新加载（崩溃恢复 / Ctrl+R / 显示引导
|
||
// 重启 renderer）后必须把 rendererDirty 重置为 false —— 否则上次崩溃
|
||
// 之前的状态被「缓存」在主进程，before-quit 会拿这个 stale true 弹「未
|
||
// 保存确认」但用户其实没东西可丢。renderer 重启后 state 是干净的，主
|
||
// 进程需要跟上。
|
||
rendererDirty = false;
|
||
// auto-fallback 2026-08：renderer 就绪后广播一次 data-dir:resolved。
|
||
// 必须在 did-finish-load 里发，不能在 createWindow 末尾 ——
|
||
// 后者调用时 renderer 的 ipcRenderer.on 监听还没装好，事件被丢。
|
||
// fellBack=false 时也发（让 renderer 拿到 defaultDir 用作 UI 文案）；
|
||
// 监听器只在 fellBack=true 时弹引导弹窗，false 时只更新状态。
|
||
broadcastDataDirResolved();
|
||
});
|
||
|
||
// 拦截新窗口请求：markdown 里的 `<a target="_blank">` 默认会被 Electron 真的弹一个新窗口。
|
||
// 我们要的是外部链接走 shell.openExternal（preload 已经处理），所以这里一律拒绝。
|
||
mainWindow.webContents.setWindowOpenHandler(({ url }) => {
|
||
console.warn('[main] 拒绝新窗口请求:', url);
|
||
return { action: 'deny' };
|
||
});
|
||
|
||
// audit fix (Round 13 / Sec-L)：拒绝所有权限请求。当前 threat model 下没有
|
||
// 任何 feature 需要 media / geolocation / notifications / midi 等权限 —— 一旦
|
||
// 未来 XSS 落地，攻击者若能让 renderer 调 navigator.geolocation / webcam 等，
|
||
// 没有这层兜底会直接拿到原始权限。Electron 默认对每个权限请求都会询问用户，
|
||
// 但「弹窗让用户点」不是真安全 —— 默认 deny + 显式 allow 才能把攻击面关到 0。
|
||
// 设在 webContents 级：每窗口独立；若以后加 BrowserWindow 也要记得复制。
|
||
mainWindow.webContents.session.setPermissionRequestHandler((_wc, _permission, callback) => {
|
||
callback(false);
|
||
});
|
||
mainWindow.webContents.session.setPermissionCheckHandler(() => false);
|
||
|
||
// audit fix (Round 9)：F12 在所有平台都能打开 DevTools。
|
||
// 菜单 accelerator `F12` 在 macOS 可见菜单栏下生效，但 Windows / Linux
|
||
// 上 autoHideMenuBar=true 让菜单隐藏 → accelerator 不再触发，README
|
||
// 承诺「Windows / Linux 也可」变成谎言。webContents.on('before-input-event')
|
||
// 是 Chromium 级的输入事件，不依赖菜单可见性，跨平台一致。
|
||
// 只对 `F12`（不含修饰）生效，编辑器内也让位（CM6 不占 F12 但未来可能）。
|
||
mainWindow.webContents.on('before-input-event', (event, input) => {
|
||
if (input.type !== 'keyDown') return;
|
||
if (input.key === 'F12' && !input.alt && !input.control && !input.meta && !input.shift) {
|
||
event.preventDefault();
|
||
mainWindow.webContents.toggleDevTools();
|
||
}
|
||
});
|
||
|
||
// 拦截任何页面内导航：只允许同源 file:// 加载 index.html。
|
||
// 防止恶意 markdown 中的 <meta http-equiv="refresh"> 或 <a href> 把我们带到外部页面。
|
||
mainWindow.webContents.on('will-navigate', (event, url) => {
|
||
const allowed = mainWindow.webContents.getURL();
|
||
if (url === allowed) return; // 同 URL 重载
|
||
// 任何外部 URL → 阻止并打开外部浏览器
|
||
event.preventDefault();
|
||
console.warn('[main] 拦截外部导航:', url);
|
||
if (/^https?:\/\//i.test(url)) {
|
||
shell.openExternal(url).catch((e) => console.error('[main] openExternal 失败:', e));
|
||
}
|
||
});
|
||
|
||
// console-message 事件签名：Electron 35+ 派发 5-arg 兼容路径（runtime 不论 listener.length
|
||
// 是 1/2/5 都走同一内部接口），推荐用单参 `(event)` 直接读 WebContentsConsoleMessageEventParams：
|
||
// event.message - 消息文本
|
||
// event.level - 'verbose' | 'info' | 'warning' | 'error' | 'debug'（字符串，
|
||
// 不是 Electron 28 时代的 0-3 数字；要相等比较 === 'error'）
|
||
// event.lineNumber - 源代码行号
|
||
// event.sourceId - 源代码 URL
|
||
// event.frame - WebFrameMain
|
||
// 走单参路径运行时不会再打印 deprecated 警告（仅多参 `on(..., (a,b) => ...)` 才会触发），
|
||
// 移除 console-message 监听会让 renderer 错误不可见，故保留。
|
||
mainWindow.webContents.on('console-message', (event) => {
|
||
if (event.level === 'error') {
|
||
console.error(`[renderer ${event.sourceId}:${event.lineNumber}]`, event.message);
|
||
}
|
||
});
|
||
|
||
// 开发模式下自动打开 DevTools
|
||
if (process.env.NODE_ENV === 'development' || process.argv.includes('--dev')) {
|
||
mainWindow.webContents.openDevTools({ mode: 'detach' });
|
||
}
|
||
|
||
// 关闭事件：有托盘时拦截关闭按钮改为隐藏到托盘（不丢数据，无需确认）；
|
||
// 没有托盘时关闭就是退出，有未保存的改动必须先弹确认框。
|
||
mainWindow.on('close', async (e) => {
|
||
// isQuitting 为 true 说明 before-quit 已经做过脏检查了，直接放行
|
||
if (isQuitting) return;
|
||
e.preventDefault();
|
||
|
||
// 有托盘时关闭只是隐藏窗口，未保存的内容还在内存里，不该拿弹窗打扰用户；
|
||
// 真正的退出（托盘菜单、Cmd+Q 等）由 before-quit 统一做脏检查
|
||
if (tray) {
|
||
hideWindow();
|
||
return;
|
||
}
|
||
|
||
// audit fix (Round 9)：防 close 重入。用户双击 × 时第一次 confirmDiscardIfDirty
|
||
// 还在 await promptRendererSave（让出事件循环），第二次 close 事件进入
|
||
// → 又走 confirmDiscardIfDirty → 两个原生 dialog 同时挂起。镜像
|
||
// before-quit 的 quitConfirmInFlight 模式：第一次进入设标记，二次 click
|
||
// 直接 e.preventDefault 走人。
|
||
if (closeConfirmInFlight) return;
|
||
closeConfirmInFlight = true;
|
||
try {
|
||
// 没有托盘：关闭窗口就是退出，丢改动之前必须确认
|
||
const proceed = await confirmDiscardIfDirty();
|
||
if (!proceed) return;
|
||
isQuitting = true;
|
||
app.quit();
|
||
} finally {
|
||
closeConfirmInFlight = false;
|
||
}
|
||
});
|
||
|
||
mainWindow.on('maximize', () => broadcastMaximizeState());
|
||
mainWindow.on('unmaximize', () => broadcastMaximizeState());
|
||
|
||
// 窗口最小化 / 收进托盘时暂停 readdir 轮询，重新可见时恢复并补扫一次
|
||
mainWindow.on('minimize', () => fsWatcher.pauseDirPolling());
|
||
mainWindow.on('hide', () => fsWatcher.pauseDirPolling());
|
||
mainWindow.on('restore', () => fsWatcher.resumeDirPolling());
|
||
mainWindow.on('show', () => fsWatcher.resumeDirPolling());
|
||
|
||
mainWindow.on('closed', () => {
|
||
console.log('[main] 窗口已关闭');
|
||
// audit fix (Round 9)：清理 forceShowTimer。createWindow 顶部也清，但
|
||
// 异常路径下（窗口被强制销毁没走 createWindow）会泄漏 timer 句柄。
|
||
// 这里 closed 兜底再清一次。forceShowTimer.unref() 之后不会阻塞退出，
|
||
// 但留着没意义（窗口已 null，timer 内回调的 isDestroyed 守卫也会拦下）。
|
||
if (forceShowTimer) {
|
||
clearTimeout(forceShowTimer);
|
||
forceShowTimer = null;
|
||
}
|
||
fsWatcher.stopWatchingDir();
|
||
mainWindow = null;
|
||
});
|
||
|
||
console.log('[main] 主窗口创建完成');
|
||
|
||
// audit fix (Round 7 FS-F4)：createWindow 是重建路径（macOS activate /
|
||
// showWindow 的 destroyed 分支 / 渲染进程崩溃恢复）的统一入口。窗口重建
|
||
// 后必须重新挂载目录监听，否则整个会话的文件监听彻底死掉，外部改动再也
|
||
// 不会出现在侧栏。startWatchingDir 内部 stopWatchingDir 幂等，无副作用。
|
||
try {
|
||
fsWatcher.startWatchingDir(currentDataRoot());
|
||
} catch (e) {
|
||
console.warn('[main] 重建目录监听失败（仅依赖轮询）:', e && e.message);
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// 系统托盘
|
||
// ============================================
|
||
|
||
function showWindow() {
|
||
if (!mainWindow || mainWindow.isDestroyed()) {
|
||
createWindow();
|
||
return;
|
||
}
|
||
if (mainWindow.isMinimized()) mainWindow.restore();
|
||
mainWindow.show();
|
||
mainWindow.focus();
|
||
}
|
||
|
||
function hideWindow() {
|
||
if (!mainWindow || mainWindow.isDestroyed()) return;
|
||
if (forceShowTimer) {
|
||
clearTimeout(forceShowTimer);
|
||
forceShowTimer = null;
|
||
}
|
||
mainWindow.hide();
|
||
}
|
||
|
||
function toggleWindow() {
|
||
if (!mainWindow || mainWindow.isDestroyed()) {
|
||
createWindow();
|
||
return;
|
||
}
|
||
if (mainWindow.isVisible() && !mainWindow.isMinimized()) {
|
||
hideWindow();
|
||
} else {
|
||
showWindow();
|
||
}
|
||
}
|
||
|
||
function buildTrayMenu() {
|
||
return Menu.buildFromTemplate([
|
||
{ label: '显示窗口', click: () => showWindow() },
|
||
{ label: '隐藏窗口', click: () => hideWindow() },
|
||
{ type: 'separator' },
|
||
{
|
||
label: '始终置顶',
|
||
type: 'checkbox',
|
||
checked: configStore.getConfig().alwaysOnTop === true,
|
||
click: (item) => {
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
mainWindow.setAlwaysOnTop(item.checked);
|
||
}
|
||
// audit fix (C2)：saveConfig 现在返回 Promise（异步写盘 + 串行 queue），
|
||
// fire-and-forget 路径加 .catch 避免写盘失败时 unhandled rejection。
|
||
configStore.saveConfig({ alwaysOnTop: item.checked }).catch((e) => {
|
||
console.error('[main] tray alwaysOnTop 保存失败:', e?.error || e?.message || e);
|
||
});
|
||
mainWindow?.webContents.send('always-on-top:changed', item.checked);
|
||
}
|
||
},
|
||
{ type: 'separator' },
|
||
{
|
||
label: '退出',
|
||
click: () => {
|
||
// 不在这里置 isQuitting：交给 before-quit 做「未保存改动」确认，
|
||
// 否则托盘退出会跳过脏检查直接丢数据。
|
||
app.quit();
|
||
}
|
||
}
|
||
]);
|
||
}
|
||
|
||
function createTray() {
|
||
if (tray) return;
|
||
try {
|
||
tray = new Tray(APP_ICON_PATH);
|
||
tray.setToolTip('Notes');
|
||
tray.setContextMenu(buildTrayMenu());
|
||
tray.on('click', () => toggleWindow());
|
||
console.log('[main] 系统托盘已创建');
|
||
} catch (e) {
|
||
console.error('[main] 系统托盘创建失败:', e.message);
|
||
tray = null;
|
||
}
|
||
}
|
||
|
||
function destroyTray() {
|
||
if (!tray) return;
|
||
try {
|
||
tray.destroy();
|
||
} catch (e) {
|
||
console.warn('[main] 销毁托盘失败:', e.message);
|
||
}
|
||
tray = null;
|
||
}
|
||
|
||
// ============================================
|
||
// 单实例锁
|
||
// ============================================
|
||
const gotSingleInstanceLock = app.requestSingleInstanceLock();
|
||
|
||
if (!gotSingleInstanceLock) {
|
||
console.log('[main] 已有实例在运行，激活已有窗口后退出本实例');
|
||
isQuitting = true;
|
||
app.quit();
|
||
} else {
|
||
app.on('second-instance', () => {
|
||
console.log('[main] 检测到第二个实例启动，激活已有窗口');
|
||
showWindow();
|
||
});
|
||
}
|
||
|
||
// ============================================
|
||
// 应用生命周期
|
||
// ============================================
|
||
|
||
app.whenReady().then(async () => {
|
||
if (!gotSingleInstanceLock) return;
|
||
|
||
configStore.init();
|
||
// auto-fallback 2026-08 + auto-create 默认目录：currentDataRoot() 内部走
|
||
// resolveDataDirOrFallback，customDir 失效时回退到默认；返回 DEFAULT_DATA_DIR
|
||
// 时还会 sync mkdir（确保 fsWatcher 启动时不撞 ENOENT）+ 异步种子 welcome.md
|
||
// （fire-and-forget，下次 fsWatcher 第一次扫描大概率就绪）。
|
||
// 之前用 resolveDataDir() 不做 stat、不 mkdir —— 用户首次启动默认目录还没建、
|
||
// 或 U 盘掉线 fallback 路径下默认目录也从未被用过，都会让 fsWatcher.startWatchingDir
|
||
// 立刻 ENOENT 失败、侧栏空白、用户毫无线索。
|
||
currentDataDir = currentDataRoot();
|
||
// 注意：不要打印完整 config —— aiApiKey 等敏感字段不能进日志。
|
||
// 只打印 "已加载" 这条确认信息；详情在出错时单独打。
|
||
console.log('[main] 已加载配置');
|
||
console.log('[main] 数据目录:', currentDataDir);
|
||
|
||
// 等欢迎文档就绪再启动 fsWatcher —— 默认目录刚创建的情况下，先把 welcome.md
|
||
// 写好再让 fsWatcher 开始监听，避免「fsWatcher 第一次扫描拿到空目录、几秒
|
||
// 后 welcome.md 突然冒出侧栏」的 UX 撕裂。resolveDataDirOrFallback 内部已
|
||
// fire-and-forget 异步种子一次，这里 await 的是同一份 in-flight promise。
|
||
await configStore.scheduleEnsureDefaultDataDir();
|
||
|
||
console.log('[main] app ready');
|
||
buildMenu();
|
||
createTray();
|
||
createWindow();
|
||
|
||
// 启动目录监听器（默认目录已 sync mkdir + welcome.md 已 async 种子完毕）
|
||
fsWatcher.startWatchingDir(currentDataDir);
|
||
|
||
app.on('activate', () => {
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
showWindow();
|
||
} else if (BrowserWindow.getAllWindows().length === 0) {
|
||
createWindow();
|
||
}
|
||
});
|
||
}).catch(err => {
|
||
console.error('[main] app ready 失败:', err);
|
||
});
|
||
|
||
// 退出确认是否正在进行，防止用户连点托盘「退出」时叠出多个原生框
|
||
let quitConfirmInFlight = false;
|
||
|
||
// 所有退出路径（托盘退出、Cmd+Q、系统关机请求）都会经过 before-quit。
|
||
// isQuitting 只有在这里确认过、或单实例锁失败时才会被置为 true。
|
||
app.on('before-quit', async (e) => {
|
||
if (isQuitting) return;
|
||
|
||
if (!rendererDirty) {
|
||
isQuitting = true;
|
||
return;
|
||
}
|
||
|
||
// 已经弹着一个确认框了，忽略这次退出请求
|
||
if (quitConfirmInFlight) {
|
||
e.preventDefault();
|
||
return;
|
||
}
|
||
|
||
e.preventDefault();
|
||
quitConfirmInFlight = true;
|
||
try {
|
||
const proceed = await confirmDiscardIfDirty();
|
||
if (!proceed) return;
|
||
isQuitting = true;
|
||
app.quit();
|
||
} finally {
|
||
quitConfirmInFlight = false;
|
||
}
|
||
});
|
||
|
||
app.on('will-quit', () => {
|
||
// 退出时取消所有在飞的 AI 请求，避免响应被丢弃（付费用 API 也会浪费额度）。
|
||
// audit fix (main-M11)：把同步清理拆出来，把 revealArmedBySender 兜底清理
|
||
// 也挪到这里（armed TTL 兜底 setTimeout 已经 .unref，正常退出流程不会等它，
|
||
// 显式清理避免 reveal Map 在长跑测试 / 频繁 reload 场景下累积 entry）。
|
||
try { aiProxy.cancelAll(); } catch (e) { console.warn('[main] cancelAll 失败:', e && e.message); }
|
||
// audit fix (main-M12a)：revealArmedBySender 在 will-quit 显式清空。
|
||
// 既有 TTL 兜底（armed 5s 后 setTimeout 自动删），但用户开窗口→立刻退的
|
||
// 短路径上 entry 仍占着 Map。shutdown 时主动清掉，调试时也能在 heap
|
||
// snapshot 看到模块级 Map 是干净的。
|
||
try { revealArmedBySender.clear(); } catch (e) { console.warn('[main] revealArmed 清理失败:', e && e.message); }
|
||
// audit fix (Round 7 FS-F15)：will-quit 显式停 fsWatcher。fsWatcher 持有
|
||
// 1 个 FSWatcher 句柄 + 1 个 setInterval + 最多 2 个 setTimeout，长期跑
|
||
// 测试 / 频繁 reload 场景下堆积。closed 路径已经 stopWatchingDir，但
|
||
// macOS `before-quit` 可能跳过 closed 直接 will-quit —— 这里兜底。
|
||
try { fsWatcher.stopWatchingDir(); } catch (e) { console.warn('[main] fsWatcher 清理失败:', e && e.message); }
|
||
destroyTray();
|
||
});
|
||
|
||
app.on('window-all-closed', () => {
|
||
console.log('[main] 所有窗口已关闭');
|
||
if (tray) return;
|
||
if (process.platform !== 'darwin') app.quit();
|
||
});
|
||
|
||
// ============================================
|
||
// IPC: 渲染端脏状态同步 + 触发保存
|
||
// ============================================
|
||
|
||
ipcMain.handle('renderer:set-dirty', (_event, isDirty) => {
|
||
// 仅同步标志位，供 confirmDiscardIfDirty 在退出路径上判断「是否弹未保存确认框」。
|
||
// 不在此处刷新托盘菜单 —— dirty 状态与托盘菜单项（始终置顶、显示主窗口）无关。
|
||
rendererDirty = !!isDirty;
|
||
return true;
|
||
});
|
||
|
||
/**
|
||
* 通知渲染端立刻保存当前文件。
|
||
* 通过 webContents.send + 一次性监听 IPC 返回值的方式拿到结果。
|
||
*
|
||
* audit fix (M5 main)：webContents.send 在 webContents 已 destroyed（但
|
||
* mainWindow 还没被回收的极小窗口）会抛 TypeError —— 旧实现没 try/catch，
|
||
* 整个 Promise 永远 hang 在 unhandled 里；confirmDiscardIfDirty 调用方
|
||
* `await promptRendererSave()` 永远等不到 resolve，「关闭窗口」操作死锁。
|
||
* 收紧护栏：send 失败 → 立即解 timer + resolve(false)；webContents 中途
|
||
* destroyed → 同样提前 resolve(false) 不再等 10s。
|
||
*
|
||
* @returns {Promise<boolean>} true 表示保存成功（或没有需要保存的内容）
|
||
*/
|
||
function promptRendererSave() {
|
||
return new Promise((resolve) => {
|
||
if (!mainWindow || mainWindow.isDestroyed()) {
|
||
resolve(false);
|
||
return;
|
||
}
|
||
const reqId = `save-${Date.now()}-${Math.random().toString(36).slice(2)}`;
|
||
const channel = `renderer:save-result:${reqId}`;
|
||
let settled = false;
|
||
const settle = (value) => {
|
||
if (settled) return;
|
||
settled = true;
|
||
clearTimeout(hardTimer);
|
||
clearTimeout(graceTimer);
|
||
try { ipcMain.removeAllListeners(channel); } catch { /* ignore */ }
|
||
// Phase N M1 fix：早退路径（IPC 收到结果 / 窗口 destroyed / send 失败）清掉
|
||
// graceTimer 与 once('destroyed')，否则 onDestroyed 会留到窗口死亡才被拆、
|
||
// graceTimer 会留到 15s 才被 Node 自然 GC，延迟 process.exit 0.5s ~ 5s
|
||
// （取决于哪条路径先 settle）。granted settled 守卫让它们是 no-op，但 timer/
|
||
// listener 仍占资源。
|
||
try { wc && wc.off('destroyed', onDestroyed); } catch { /* ignore */ }
|
||
resolve(value);
|
||
};
|
||
|
||
// audit fix (Main P1 / promptRendererSave grace timer 死代码)：
|
||
// 旧版 hardTimer(10s) + graceTimer(15s) 两个 timeout 都直接调
|
||
// settle(false) —— 因为 hardTimer 先 fire，settled 守卫让 graceTimer
|
||
// 必是 no-op，「宽限期接受晚到的 ok=true 结果」根本没生效，等同于
|
||
// 一段被注释误导的 dead code。
|
||
// 修正：hardTimer fire 时只让出监听器（不再 settle），graceTimer fire
|
||
// 时才 settle(false)。这样 10-15s 之间晚到的 renderer:save-result:{reqId}
|
||
// 仍能走 settle(ok=true)，避免大文件 / 慢盘下「renderer 实际写盘成功
|
||
// 但晚到 10s+」被错判为保存失败 → 用户看到「取消关闭」，实际文件已
|
||
// 保存的诡异状态。
|
||
const HARD_DEADLINE_MS = 10000;
|
||
const GRACE_PERIOD_MS = 15000;
|
||
let hardTimer = setTimeout(() => { /* 进入宽限窗口：监听器保留 */ }, HARD_DEADLINE_MS);
|
||
let graceTimer = setTimeout(() => settle(false), GRACE_PERIOD_MS);
|
||
|
||
ipcMain.once(channel, (_event, result) => {
|
||
// 宽限期内（10-15s 之间）到达的结果一律接受；hardTimer 之前照常
|
||
// 接受；graceTimer 之后 / 已 settled 直接被 settled 守卫挡掉。
|
||
settle(!!(result && result.ok));
|
||
});
|
||
|
||
// webContents 中途被销毁（极少见但可能：before-quit 序列里被 GC）
|
||
const wc = mainWindow.webContents;
|
||
const onDestroyed = () => settle(false);
|
||
if (wc && !wc.isDestroyed()) {
|
||
wc.once('destroyed', onDestroyed);
|
||
}
|
||
|
||
try {
|
||
wc.send('renderer:save-request', { reqId });
|
||
} catch (e) {
|
||
console.error('[main] promptRendererSave send 失败:', e.message);
|
||
settle(false);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 有未保存改动时弹原生三选一确认框（保存 / 丢弃 / 取消）。
|
||
* close（无托盘）和 before-quit 共用，保证任何退出路径都不会静默丢数据。
|
||
* 隐藏到托盘不算退出，不走这里。
|
||
* @returns {Promise<boolean>} true = 可以继续退出；false = 用户取消 / 保存失败
|
||
*/
|
||
/**
|
||
* confirmDiscardIfDirty 递归上限。防止「用户一直敲字 → 保存后又脏 → 反复弹原生框」
|
||
* 死循环。Phase N-A1 修复用了递归弹框，第 MAX_CONFIRM_RECURSION 次直接返回 false
|
||
* 强制用户取消或丢弃。
|
||
*/
|
||
const MAX_CONFIRM_RECURSION = 3;
|
||
|
||
/**
|
||
* confirmDiscardIfDirty 的递归保护版本。depth=0 时不再弹原生框，
|
||
* 直接返回 false（强制用户取消或丢弃），防"用户一直敲字 → 反复提示"的死循环。
|
||
*/
|
||
async function _confirmDiscardIfDirtyBounded(depth) {
|
||
if (depth <= 0) return false;
|
||
// audit fix (Round 8 M-2)：必须把 depth 透传下去。旧实现调 confirmDiscardIfDirty()
|
||
// 不带参 → 内部又用常量 MAX_CONFIRM_RECURSION - 1 递归 → depth 恒为 2，
|
||
// 「第 3 次强制 return false」的安全网从未生效，理论上可无限递归到栈溢出。
|
||
return await confirmDiscardIfDirty(depth);
|
||
}
|
||
|
||
async function confirmDiscardIfDirty(depth = MAX_CONFIRM_RECURSION) {
|
||
if (!rendererDirty) return true;
|
||
if (!mainWindow || mainWindow.isDestroyed()) return true;
|
||
|
||
// 窗口可能已经隐藏到托盘了，先显示出来，否则原生框会挂在看不见的窗口上
|
||
if (!mainWindow.isVisible() || mainWindow.isMinimized()) {
|
||
showWindow();
|
||
}
|
||
|
||
const choice = dialog.showMessageBoxSync(mainWindow, {
|
||
type: 'warning',
|
||
buttons: ['保存后退出', '丢弃并退出', '取消'],
|
||
defaultId: 0,
|
||
cancelId: 2,
|
||
title: '未保存的改动',
|
||
message: '当前文件有未保存的改动。\n退出将丢失这些改动。',
|
||
detail: '「保存后退出」会写入磁盘再退出；「丢弃并退出」直接退出；「取消」回到窗口。',
|
||
noLink: true,
|
||
});
|
||
|
||
if (choice === 2) return false;
|
||
|
||
if (choice === 0) {
|
||
const ok = await promptRendererSave();
|
||
if (!ok) {
|
||
dialog.showMessageBoxSync(mainWindow, {
|
||
type: 'error',
|
||
buttons: ['好'],
|
||
title: '保存失败',
|
||
message: '保存当前文件失败，已取消退出。',
|
||
detail: '请回到窗口检查文件是否可写，或选择「丢弃并退出」。',
|
||
noLink: true,
|
||
});
|
||
return false;
|
||
}
|
||
// audit fix (Phase N-A1)：save 飞行期用户输入的数据丢失路径。
|
||
// 旧实现：promptRendererSave 解析为 ok → confirmDiscardIfDirty 直接 return true
|
||
// → before-quit 看到 isQuitting=true 放行 → app.quit() → 编辑器销毁 →
|
||
// 飞行期用户敲的字（C2）永久丢失（盘上是 C1）。
|
||
//
|
||
// 修复：在保存成功后再 re-check 一次 rendererDirty。rendererDirty 在 save 成功
|
||
// 路径里会被 syncSaveButton() → setDirty(false) 写回 false，但飞行期用户又敲字
|
||
// 会再次翻 true。如果保存后 dirty 重新为 true，说明用户在 save IPC 飞行期
|
||
// 输入了新内容 —— 我们没有这些内容的盘上版本，强制退出等于丢字。
|
||
//
|
||
// 处理：弹"保存后又产生新改动"原生框，用户重新决策（继续保存 / 丢弃 / 取消）。
|
||
// 取消则用户继续编辑；继续保存走递归 → promptRendererSave 二次飞行再被异步
|
||
// 重读 dirty 时可能再次脏——但主进程 IPC 在 await 期间不阻塞（renderer 的
|
||
// editor/view dispatch 同步触发 setDirty IPC 写回 rendererDirty）。最坏
|
||
// 情况用户看到"保存后又有新改动"反复弹——明确告知比静默丢字好得多。
|
||
if (rendererDirty) {
|
||
const retry = dialog.showMessageBoxSync(mainWindow, {
|
||
type: 'warning',
|
||
buttons: ['再次保存', '丢弃并退出', '取消'],
|
||
defaultId: 0,
|
||
cancelId: 2,
|
||
title: '保存后又产生了新改动',
|
||
message: '文件已保存到磁盘，但保存过程中又输入了新内容。',
|
||
detail: '「再次保存」会写入最新的内容再退出；「丢弃并退出」直接退出，丢失保存后的新内容；「取消」回到窗口继续编辑。',
|
||
noLink: true,
|
||
});
|
||
if (retry === 2) return false; // 取消：继续编辑
|
||
if (retry === 1) return true; // 丢弃：直接退出
|
||
// retry === 0：再次保存。递归调 confirmDiscardIfDirty 重新走完整流程。
|
||
// 限制递归深度 ≤ MAX_CONFIRM_RECURSION 防极端时序死循环（用户一直敲字 →
|
||
// 永远保存后又脏）。depth 沿调用链递减，耗尽后 _confirmDiscardIfDirtyBounded
|
||
// 直接 return false（= 取消退出，回窗口继续编辑），不丢数据。
|
||
return await _confirmDiscardIfDirtyBounded(depth - 1);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// ============================================
|
||
// IPC: 文件操作（只读）
|
||
// ============================================
|
||
|
||
/**
|
||
* 取当前数据目录路径（IPC handler 统一封装）
|
||
*
|
||
* auto-fallback 2026-08：改走 resolveDataDirOrFallback() —— custom 路径不存在时
|
||
* runtime 回退到默认（saved 字段保留原值，U 盘插回下次启动还能用回去）。
|
||
* 之前直接调 resolveDataDir() 不做 stat，缺失时整个文件 IO 全炸、用户侧栏空白。
|
||
*/
|
||
function currentDataRoot() {
|
||
return configStore.resolveDataDirOrFallback().dir;
|
||
}
|
||
|
||
/**
|
||
* 启动时广播一次 data-dir:resolved 给 renderer，让 UI 在 fallback 时弹一次
|
||
* 「数据文件夹不可访问」的引导弹窗 / toast。fallBack=false 时不发（无意义噪音）。
|
||
*/
|
||
function broadcastDataDirResolved() {
|
||
if (!mainWindow || mainWindow.isDestroyed()) return;
|
||
const info = configStore.resolveDataDirOrFallback();
|
||
mainWindow.webContents.send('data-dir:resolved', {
|
||
dir: info.dir,
|
||
defaultDir: configStore.getDefaultDataDir(),
|
||
fellBack: info.fellBack,
|
||
saved: info.saved,
|
||
});
|
||
}
|
||
|
||
ipcMain.handle('file:list', async () => {
|
||
const dir = currentDataRoot();
|
||
currentDataDir = dir;
|
||
// audit fix (Main P2 / file:list no validation)：其他 handler（file:scan-dir
|
||
// / file:read / file:write / file:create / file:rename / file:delete）都先
|
||
// 调 assertNoSymlinkAncestor 拒绝祖先链含 symlink 的目标；file:list 是早期
|
||
// 入口，漏了这一步。
|
||
// 威胁面：用户配置 dataDir 指到一个普通目录，但该目录里某个子项（含
|
||
// file:list 直接扫描的根）被替换成 symlink 指向外部（恶意诱导 / 备份恢复
|
||
// 时残留）—— 旧实现 fs.readdir + fs.stat 跟随 symlink，scanDir 把目标当
|
||
// 成普通目录返回，渲染端按内部文件展示，触发 NTLM 偷凭 + 路径穿越。
|
||
const ancestorCheck = await assertNoSymlinkAncestor(dir, dir);
|
||
if (!ancestorCheck.ok) {
|
||
return {
|
||
ok: false,
|
||
files: [],
|
||
entries: [],
|
||
error: ancestorCheck.error,
|
||
code: ancestorCheck.code,
|
||
message: ancestorCheck.message,
|
||
};
|
||
}
|
||
// Folder Browser：根目录也走 scanDir，渲染端用 entryType 分流显示文件夹 / 文件 / binary。
|
||
// 为了兼容老调用方，仍然把 entries 镜像成 files（仅 entryType==='editable'|'binary' 的项）。
|
||
const result = await scanDir(dir);
|
||
if (!result.ok) {
|
||
return {
|
||
ok: false,
|
||
files: [],
|
||
entries: [],
|
||
error: result.error,
|
||
code: result.code,
|
||
message: result.message,
|
||
};
|
||
}
|
||
// files = 非文件夹条目（侧栏历史逻辑兼容：state.files 仅含文件）
|
||
const files = result.entries
|
||
.filter((e) => !e.isFolder)
|
||
.map((e) => ({ name: e.name, path: e.path, size: e.size, mtimeMs: e.mtimeMs, entryType: e.entryType }));
|
||
return {
|
||
ok: true,
|
||
files,
|
||
entries: result.entries,
|
||
dir: result.dir,
|
||
relDir: '',
|
||
};
|
||
});
|
||
|
||
/**
|
||
* file:scan-dir —— Folder Browser 的核心入口（Stage 8）
|
||
*
|
||
* 入参 relDir 是 dataRoot 下的 POSIX 风格相对路径（'notes/2026'）；
|
||
* 空串表示根目录。返回一层所有条目（文件夹 + 文件 + binary）。
|
||
*
|
||
* 渲染端用这个在子目录之间导航；fs-watcher 也通过 {relDir} 字段告诉
|
||
* 渲染端「变更发生在哪一层」，渲染端比对当前目录决定是否重扫。
|
||
*/
|
||
ipcMain.handle('file:scan-dir', async (_event, relDir) => {
|
||
const dataRoot = currentDataRoot();
|
||
const resolved = resolveDirRelative(typeof relDir === 'string' ? relDir : '', dataRoot);
|
||
if (!resolved.ok) {
|
||
return { ok: false, error: resolved.error, message: resolved.message };
|
||
}
|
||
// audit fix (Phase O-H1)：祖先链 symlink 检查。
|
||
// 之前只 lstat(absDir) 自身，但 dataRoot/links 是 symlink 指向外部时，
|
||
// absDir = dataRoot/links/foo 是合法路径（symlink 在祖先链上），
|
||
// 自身不是 symlink → 通过检查。scanDir 跟随 symlink 读到外部目录文件列表，
|
||
// 渲染后等于无成本枚举外部目标内容。
|
||
// assertNoSymlinkAncestor 从 absDir 一路 lstat 到 dataRoot ，
|
||
// 中间任一层是 symlink 就拒绝 —— 与 file:read/write/rename/delete 对齐。
|
||
const ancestorCheck = await assertNoSymlinkAncestor(resolved.absDir, dataRoot);
|
||
if (!ancestorCheck.ok) {
|
||
return { ok: false, error: ancestorCheck.error, code: ancestorCheck.code, message: ancestorCheck.message };
|
||
}
|
||
const result = await scanDir(resolved.absDir);
|
||
if (!result.ok) {
|
||
return {
|
||
ok: false,
|
||
error: result.error,
|
||
code: result.code,
|
||
message: result.message,
|
||
relDir: resolved.relDir,
|
||
};
|
||
}
|
||
return { ok: true, dir: result.dir, relDir: resolved.relDir, entries: result.entries };
|
||
});
|
||
|
||
/**
|
||
* file:watch-dir —— 切换 fs-watcher 的监听目标到指定子目录（Folder Browser 用）。
|
||
*
|
||
* 渲染端进入子目录时调用：
|
||
* await api.watchDir('notes/2026');
|
||
* 之后 fs-watcher 推送的 files:changed 事件只与该子目录相关（payload.relDir 同步）。
|
||
*
|
||
* 与 startWatchingDir / scanFiles 基线的区别：startWatchingDir 会清基线并按目录类型重新初始化，
|
||
* 这里直接复用工厂内部的 rewatch()，避免「切到同名目录时无谓重置基线」。
|
||
*
|
||
* relDir 必须经过 resolveDirRelative 校验，防止传入绝对路径或 .. 段越权。
|
||
*/
|
||
ipcMain.handle('file:watch-dir', async (_event, relDir) => {
|
||
const dataRoot = currentDataRoot();
|
||
const resolved = resolveDirRelative(typeof relDir === 'string' ? relDir : '', dataRoot);
|
||
if (!resolved.ok) {
|
||
return { ok: false, error: resolved.error, code: resolved.code, message: resolved.message };
|
||
}
|
||
// audit fix (Phase O-H2)：祖先链 symlink 检查。
|
||
// 之前只 lstat(absDir) 自身。fs.watch(absDir) 会跟随 symlink 解析到外部目标的 inode，
|
||
// watcher 在外部目标盘上持锁并把外部目录变更以 files:changed 推送回 renderer
|
||
// （payload.relDir = 内部相对路径，renderer 误以为是 dataRoot 子目录活动）。
|
||
// assertNoSymlinkAncestor 挡住祖先链含 symlink 的目标。
|
||
const ancestorCheck = await assertNoSymlinkAncestor(resolved.absDir, dataRoot);
|
||
if (!ancestorCheck.ok) {
|
||
return { ok: false, error: ancestorCheck.error, code: ancestorCheck.code, message: ancestorCheck.message };
|
||
}
|
||
try {
|
||
fsWatcher.rewatch(resolved.absDir);
|
||
return { ok: true, dir: resolved.absDir, relDir: resolved.relDir };
|
||
} catch (e) {
|
||
// audit fix (K1-R4)：与其它 handler 对齐 code/message 形状，不再直回 e.message。
|
||
return { ok: false, error: e.code || 'WATCH_FAILED', code: e.code, message: '无法切换监听目录' };
|
||
}
|
||
});
|
||
|
||
ipcMain.handle('file:read', async (event, filePath) => {
|
||
if (typeof filePath !== 'string' || !filePath) {
|
||
// audit fix (Round 7 IPC-1)：补齐 message 字段。renderer 走
|
||
// `result.message || result.error || '未知错误'` 兜底，没 message 会退到
|
||
// 英文原文 + 文案语言漂移。
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_PATH',
|
||
code: 'INVALID_PATH',
|
||
message: '路径必须是字符串',
|
||
};
|
||
}
|
||
// 路径必须在当前数据目录下（防御性：防止 renderer 越权访问）
|
||
if (!isWithinDataDir(filePath, currentDataRoot())) {
|
||
return { ok: false, error: 'PATH_NOT_ALLOWED', code: 'PATH_NOT_ALLOWED', message: '路径不在数据目录内' };
|
||
}
|
||
// symlink 防护（audit Q3）：与 file:write/rename/delete 对齐。
|
||
// 之前 fs.stat(filePath) 会跟随 symlink → dataDir 内的 symlink 指向外部文件时，
|
||
// renderer 可以通过 file:read 越权读到外部文件内容。lstat 拒绝 symlink。
|
||
const linkCheck = await assertNotSymlink(filePath);
|
||
if (!linkCheck.ok) {
|
||
return { ok: false, error: linkCheck.error, code: linkCheck.code, message: linkCheck.message };
|
||
}
|
||
if (linkCheck.isFile === false) {
|
||
return { ok: false, error: 'FILE_NOT_FOUND', code: 'FILE_NOT_FOUND', message: '文件已被删除' };
|
||
}
|
||
// audit fix (main-M2)：assertNotSymlink 只看 filePath 自身，而 fs.stat /
|
||
// fs.readFile 会跟随 filePath 祖先链上的 symlink 目录。dataDir/sub 是 symlink
|
||
// 指向外部目录时，readFile 实际读到 dataDir 之外的内容。补一次祖先检查，
|
||
// 与 file:write/rename/delete 的 M1 修复保持对称。
|
||
const ancestorCheck = await assertNoSymlinkAncestor(filePath, currentDataRoot());
|
||
if (!ancestorCheck.ok) {
|
||
return { ok: false, error: ancestorCheck.error, code: ancestorCheck.code, message: ancestorCheck.message };
|
||
}
|
||
try {
|
||
const st = await fs.stat(filePath);
|
||
if (!st.isFile()) {
|
||
return { ok: false, error: 'NOT_A_FILE', code: 'NOT_A_FILE', message: '不是普通文件' };
|
||
}
|
||
if (st.size > MAX_FILE_SIZE) {
|
||
return {
|
||
ok: false,
|
||
error: 'FILE_TOO_LARGE',
|
||
code: 'FILE_TOO_LARGE',
|
||
message: `文件过大（${(st.size / 1024 / 1024).toFixed(1)} MB），已超过 ${(MAX_FILE_SIZE / 1024 / 1024).toFixed(0)} MB 上限`
|
||
};
|
||
}
|
||
const content = await fs.readFile(filePath, 'utf-8');
|
||
// audit fix (Phase L3-FS 2A)：去掉 UTF-8 BOM（Notepad 等 Windows 工具会带
|
||
// 字节序标记存 UTF-8）。BOM 在第一行 heading 之前渲染成零宽字符，会让
|
||
// 文内锚点的 slug 偏移 / 复制粘贴时污染 / DOMPurify 把它当成不可见字符
|
||
// 吞掉前的不一致。原子写会原样写回字节（BOM 是三字节 0xEFBBBF），
|
||
// 这里 strip 后 save 也是无 BOM，写盘时已经清掉。
|
||
let stripped = content.charCodeAt(0) === 0xFEFF ? content.slice(1) : content;
|
||
// audit fix (Phase L3-FS 1A)：detect binary content misnamed as .md。
|
||
// fs.readFile(..., 'utf-8') 把无效字节替换成 U+FFFD（<44>）。JPEG/PNG/ZIP 等
|
||
// 二进制文件被外部改名成 .md 时直接命中 EDITABLE_EXTS 走 readFile，
|
||
// 用户编辑保存 → atomicWriteFile 把污染后的 U+FFFD 字符串写回，原二进制
|
||
// 内容永久丢失。简单阈值：前 4 KB 内 U+FFFD 占比 > 1% → 当作二进制拒绝。
|
||
// （正常 UTF-8 文本几乎不会有 U+FFFD；CJK 偶发坏字符也不至于达到 1%。）
|
||
if (stripped.length > 0) {
|
||
const probeLen = Math.min(stripped.length, 4096);
|
||
let replacements = 0;
|
||
for (let i = 0; i < probeLen; i += 1) {
|
||
if (stripped.charCodeAt(i) === 0xFFFD) replacements += 1;
|
||
}
|
||
if (replacements / probeLen > 0.01) {
|
||
return {
|
||
ok: false,
|
||
error: 'NOT_TEXT',
|
||
code: 'NOT_TEXT',
|
||
message: '该文件不是有效的 UTF-8 文本（疑似二进制），无法编辑',
|
||
};
|
||
}
|
||
}
|
||
return { ok: true, content: stripped, mtimeMs: st.mtimeMs, size: st.size };
|
||
} catch (e) {
|
||
if (e.code === 'ENOENT') {
|
||
return { ok: false, error: 'FILE_NOT_FOUND', code: 'ENOENT', message: '文件已被删除' };
|
||
}
|
||
// audit fix (K1-M2)：message 之前直回 e.message（英文 errno + 完整路径），
|
||
// 跟 file:write 的 renderer friendlyWriteError 不一致 —— renderer 一律走
|
||
// 「未知错误」分支。按 errno 翻译。
|
||
console.error('[main] 读取文件失败:', _redactPath(filePath), e.code || e.message);
|
||
return {
|
||
ok: false,
|
||
error: e.code || 'READ_FAILED',
|
||
code: e.code,
|
||
message: _friendlyReadError(e),
|
||
};
|
||
}
|
||
});
|
||
|
||
/**
|
||
* file:write —— 新增 expectedMtimeMs 校验（audit #2）
|
||
*
|
||
* renderer 传入 expectedMtimeMs（state.lastSavedMtimeMs）时，主进程先
|
||
* 读当前磁盘 mtime，不一致则拒绝写入并返回 FILE_CHANGED_EXTERNALLY。
|
||
* 这样可以挡住「外部编辑器刚刚修改 → fs:changed 还没投到 renderer → 用户 Ctrl+S
|
||
* 静默覆盖外部修改」的竞态。
|
||
*
|
||
* 不传 expectedMtimeMs（老调用 / 强写场景）则跳过校验。
|
||
*/
|
||
ipcMain.handle('file:write', async (event, filePath, content, expectedMtimeMs = null) => {
|
||
if (typeof filePath !== 'string' || !filePath) {
|
||
// audit fix (Round 7 IPC-3)：补齐 code + message，对齐其它 file:* handler 的
|
||
// 字段集。renderer 一律 `result.code / result.message` 取值，没这两个字段
|
||
// 会兜底走 result.error 英文原文 + 文案漂移。
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_PATH',
|
||
code: 'INVALID_PATH',
|
||
message: '路径必须是字符串',
|
||
};
|
||
}
|
||
if (typeof content !== 'string') {
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_CONTENT',
|
||
code: 'INVALID_CONTENT',
|
||
message: '内容必须是字符串',
|
||
};
|
||
}
|
||
// 写入大小限制：与 file:read 对齐（MAX_FILE_SIZE），避免恶意 / bug 写入巨型文件导致下次读不出
|
||
if (Buffer.byteLength(content, 'utf8') > MAX_FILE_SIZE) {
|
||
return {
|
||
ok: false,
|
||
error: 'FILE_TOO_LARGE',
|
||
code: 'FILE_TOO_LARGE',
|
||
message: `文件超过 ${MAX_FILE_SIZE} 字节上限`,
|
||
};
|
||
}
|
||
// 路径必须在当前数据目录下（防御性：防止 renderer 越权写入）
|
||
if (!isWithinDataDir(filePath, currentDataRoot())) {
|
||
return { ok: false, error: 'PATH_NOT_ALLOWED', code: 'PATH_NOT_ALLOWED', message: '路径不在数据目录内' };
|
||
}
|
||
// symlink 防护（audit #7）：写入 symlink 会跟随到外部文件，绕过 isWithinDataDir
|
||
const linkCheck = await assertNotSymlink(filePath);
|
||
if (!linkCheck.ok) {
|
||
return { ok: false, error: linkCheck.error, code: linkCheck.code, message: linkCheck.message };
|
||
}
|
||
// audit fix (M1)：symlink 祖先链防护 —— 父目录是 symlink 时，target 的
|
||
// 真实路径会跳出 dataDir。光检查 target 文件不够。
|
||
const ancestorCheck = await assertNoSymlinkAncestor(filePath, currentDataRoot());
|
||
if (!ancestorCheck.ok) {
|
||
return { ok: false, error: ancestorCheck.error, code: ancestorCheck.code, message: ancestorCheck.message };
|
||
}
|
||
if (linkCheck.isFile === false) {
|
||
// audit fix (M2)：assertNotSymlink 不区分「目录」与「不存在」，与 file:rename 对齐：
|
||
// 命中目录 → NOT_A_FILE，让 renderer 给出「该路径是文件夹」的中文提示；命中不存在 → FILE_NOT_FOUND。
|
||
// 否则 fs.writeFile 在目录上会抛 EISDIR 但被 catch 转成通用 WRITE_FAILED，用户只看到 errno。
|
||
let st;
|
||
try {
|
||
st = await fs.stat(filePath);
|
||
} catch {
|
||
st = null;
|
||
}
|
||
if (st && st.isDirectory()) {
|
||
return { ok: false, error: 'NOT_A_FILE', code: 'NOT_A_FILE', message: '该路径是文件夹，不能写入' };
|
||
}
|
||
return { ok: false, error: 'FILE_NOT_FOUND', code: 'FILE_NOT_FOUND', message: '文件已被删除' };
|
||
}
|
||
try {
|
||
// mtime 校验（audit #2）
|
||
if (Number.isFinite(expectedMtimeMs)) {
|
||
const stNow = await fs.stat(filePath);
|
||
// Math.floor 兼容 sub-ms 浮点误差
|
||
if (Math.floor(stNow.mtimeMs) !== Math.floor(expectedMtimeMs)) {
|
||
return {
|
||
ok: false,
|
||
error: 'FILE_CHANGED_EXTERNALLY',
|
||
code: 'FILE_CHANGED_EXTERNALLY',
|
||
mtimeMs: stNow.mtimeMs,
|
||
size: stNow.size,
|
||
message: '文件在外部被修改，请重新加载或选择强制覆盖',
|
||
};
|
||
}
|
||
}
|
||
// audit fix (C1 file-IO)：原子写（tmp + fsync + rename），防止进程在
|
||
// writeFile 中途崩溃导致文件内容半截（用户丢失全部编辑）。
|
||
await fileOps.atomicWriteFile(filePath, content);
|
||
const st = await fs.stat(filePath);
|
||
return { ok: true, mtimeMs: st.mtimeMs, size: st.size };
|
||
} catch (e) {
|
||
if (e.code === 'ENOENT') {
|
||
return { ok: false, error: 'FILE_NOT_FOUND', code: 'ENOENT', message: '文件已被删除' };
|
||
}
|
||
// P1-7：权限 / 只读 / 磁盘满 / 文件被占用 → 把原始 code 透出，renderer 才能给中文提示
|
||
//
|
||
// audit fix (Phase N Q-fix)：message 字段从 e.message（含英文 errno + 完整
|
||
// 路径，可能泄露）改为 fileOps.friendlyWriteError(e) 翻译成中文，与 _friendlyCreateError
|
||
// / _friendlyRenameError / _friendlyDeleteError / _friendlyReadError 对齐。
|
||
// helper 放在 main/file-ops.js（不是本文件）方便单测 —— main.js 加载 Electron
|
||
// app 实例副作用重，没法在 vitest 里 require。
|
||
console.error('[main] 写入文件失败:', _redactPath(filePath), e.message);
|
||
return {
|
||
ok: false,
|
||
error: e.code || 'WRITE_FAILED',
|
||
code: e.code,
|
||
message: fileOps.friendlyWriteError(e),
|
||
};
|
||
}
|
||
});
|
||
|
||
ipcMain.handle('file:create', async (_event, rawName, opts) => {
|
||
if (typeof rawName !== 'string') {
|
||
return { ok: false, error: 'INVALID_NAME', code: 'INVALID_NAME', message: '文件名必须是字符串' };
|
||
}
|
||
const dataRoot = currentDataRoot();
|
||
if (!dataRoot) return { ok: false, error: 'DATA_DIR_UNAVAILABLE', code: 'DATA_DIR_UNAVAILABLE', message: '数据目录不可用' };
|
||
|
||
// Stage 8：file:create 扩展签名以支持子目录。
|
||
// 向后兼容旧调用：(name, initialContentString) —— 旧 IPC 把 initialContent 当字符串。
|
||
// 新调用：(name, { dir?, initialContent? })。
|
||
let targetDir = dataRoot;
|
||
let initialContent = '';
|
||
if (typeof opts === 'string') {
|
||
initialContent = opts;
|
||
} else if (opts && typeof opts === 'object') {
|
||
if (typeof opts.initialContent === 'string') initialContent = opts.initialContent;
|
||
if (typeof opts.dir === 'string' && opts.dir) {
|
||
// dir 必须是 dataRoot 下的绝对路径或根
|
||
if (!isWithinDataDir(opts.dir, dataRoot)) {
|
||
return { ok: false, error: 'PATH_NOT_ALLOWED', code: 'PATH_NOT_ALLOWED', message: '目标目录不在数据目录内' };
|
||
}
|
||
targetDir = opts.dir;
|
||
}
|
||
}
|
||
|
||
// audit fix：与 file:write 对齐写入大小上限（**在 mkdir 之前**）。
|
||
// 之前 file:create 漏掉 MAX_FILE_SIZE 检查，导致 initialContent 可塞任意大字符串
|
||
// （粘贴一篇 100MB 小说）→ 下次 file:read 直接返回 FILE_TOO_LARGE，应用被自己
|
||
// 写入的文件锁死、删都删不掉（rename/delete 也可能受影响）。在这里预先拒绝。
|
||
// 放在 mkdir 之前：超大 initialContent 没必要先在磁盘上建空目录再拒绝，浪费 IO。
|
||
if (Buffer.byteLength(initialContent, 'utf8') > MAX_FILE_SIZE) {
|
||
return {
|
||
ok: false,
|
||
error: 'FILE_TOO_LARGE',
|
||
code: 'FILE_TOO_LARGE',
|
||
message: `初始内容超过 ${MAX_FILE_SIZE} 字节上限`,
|
||
};
|
||
}
|
||
|
||
// 子目录可能不存在（用户首次进入空子目录并新建文件）→ 自动创建。
|
||
// 这是有意的：用户在 UI 上明确选择了"在该目录下新建"，自动 mkdir 是合理语义。
|
||
//
|
||
// audit fix (Phase O-H3)：祖先链 symlink 检查必须在 mkdir 之前。
|
||
// 之前只 lstat(targetDir) 自己：targetDir 不存在时 ENOENT 跳过；然后
|
||
// mkdir(targetDir, {recursive:true}) 会跟随 symlink 在外部目标盘上真实创建
|
||
// 子目录，副作用先发生；之后 line 1307 的 assertNoSymlinkAncestor(r.path)
|
||
// 才拒绝 atomicWriteFile —— 用户没创建文件但外部目标盘上多了空目录。
|
||
// assertNoSymlinkAncestor 覆盖 targetDir 自身 + 全部祖先，等价且更严格。
|
||
if (targetDir !== dataRoot) {
|
||
const ancestorCheck = await assertNoSymlinkAncestor(targetDir, dataRoot);
|
||
if (!ancestorCheck.ok) {
|
||
return { ok: false, error: ancestorCheck.error, code: ancestorCheck.code, message: ancestorCheck.message };
|
||
}
|
||
}
|
||
try {
|
||
await fs.mkdir(targetDir, { recursive: true });
|
||
} catch (e) {
|
||
// audit fix (K1-H2)：mkdir 失败之前直回 e.message（英文 + 含完整路径），
|
||
// 与上面 atomicWrite 的 _friendlyCreateError 不对称；renderer 一律走
|
||
// 「未知错误」分支。按 errno 翻译：EACCES/EPERM = 没权限，
|
||
// ENOSPC = 磁盘满，EROFS = 只读，ENOENT = 路径里有不存在组件。
|
||
console.error('[main] file:create mkdir 失败:', _redactPath(targetDir), e.code || e.message);
|
||
return {
|
||
ok: false,
|
||
error: e.code || 'MKDIR_FAILED',
|
||
code: e.code,
|
||
message: _friendlyCreateError(e, '所在目录'),
|
||
};
|
||
}
|
||
|
||
const r = await resolveFileName(rawName, targetDir);
|
||
// audit fix (Round 7 IPC-2)：补齐 code + message 字段，与其它 file:* handler
|
||
// 对齐。resolveFileName 返回的 r.error 已经是中文明文消息（"文件名不能为空"
|
||
// / "文件名包含 Windows 保留字符" 等），把它同时塞 message 让 renderer 走
|
||
// friendlyFsError(code, message) 时不再兜底到 result.error 字符串。
|
||
if (!r.ok) {
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_NAME',
|
||
code: 'INVALID_NAME',
|
||
message: r.error,
|
||
};
|
||
}
|
||
|
||
// audit fix (1.1)：与其他 file:* handler 对称地做 isWithinDataDir 防御 + symlink 防护。
|
||
// 理论上是新文件不会有 symlink，但 resolveFileName 已过滤路径分隔符 / '..'，
|
||
// 这层只为了与 read/write/rename/delete 保持对称，且挡住未来可能的边界输入。
|
||
if (!isWithinDataDir(r.path, dataRoot)) {
|
||
return { ok: false, error: 'PATH_NOT_ALLOWED', code: 'PATH_NOT_ALLOWED', message: '路径不在数据目录内' };
|
||
}
|
||
const linkCheck = await assertNotSymlink(r.path);
|
||
if (!linkCheck.ok) {
|
||
return { ok: false, error: linkCheck.error, code: linkCheck.code, message: linkCheck.message };
|
||
}
|
||
|
||
// audit fix：与 file:read/write/rename/delete 对称做 assertNoSymlinkAncestor。
|
||
// file:create 的 targetDir 上面只 lstat 了自己（如果非根），但 r.path 落在某个
|
||
// 中间是 symlink 的目录下时（如 dataRoot/links/sub/foo.md，其中 links 是
|
||
// 指向外部的 symlink），atomicWriteFile 会跟随 symlink 把文件写到外部，
|
||
// 绕过 isWithinDataDir 的字符串前缀边界。assertNotSymlink 只判 r.path 本身
|
||
// （不存在 → 放过），挡不住中间路径是 symlink 的场景。
|
||
const ancestorCheck = await assertNoSymlinkAncestor(r.path, dataRoot);
|
||
if (!ancestorCheck.ok) {
|
||
return { ok: false, error: ancestorCheck.error, message: ancestorCheck.message };
|
||
}
|
||
|
||
try {
|
||
// 初始内容默认为 `# 标题\n\n` —— 哪怕空字符串也保证文件可读
|
||
// 2026-08-28 反馈：resolveFileName 不再强制补 .md，所以这里按最后一个 .
|
||
// 剥除任意扩展名（foo.md → foo；foo.txt → foo；无扩展名 → 原样）。
|
||
const baseForTitle = r.name.replace(/\.[^./\\]+$/, '');
|
||
const content = typeof initialContent === 'string' && initialContent.length > 0
|
||
? initialContent
|
||
: `# ${baseForTitle}\n\n`;
|
||
// audit fix (C2 file-IO)：原子写，与 file:write 对齐。
|
||
// 即便 create 失败也不该留半截文件——磁盘要么没这个文件，要么是完整的。
|
||
await fileOps.atomicWriteFile(r.path, content);
|
||
const st = await fs.stat(r.path);
|
||
return { ok: true, path: r.path, name: r.name, mtimeMs: st.mtimeMs, size: st.size };
|
||
} catch (e) {
|
||
// audit fix (1.1)：补齐 code / message 字段，与 file:read/write 对齐，
|
||
// renderer 的 friendlyWriteError 才能按 errno 给中文提示。
|
||
// audit fix (B-2)：这里之前直接返回 e.message（英文 + 含完整路径），与 file:write
|
||
// 不一致。按 errno 翻译成中文提示，路径走 _redactPath 防泄露到 tmp 日志。
|
||
console.error('[main] file:create 失败:', _redactPath(r.path), e.code || e.message);
|
||
return {
|
||
ok: false,
|
||
error: e.code || 'CREATE_FAILED',
|
||
code: e.code,
|
||
message: _friendlyCreateError(e, r.name),
|
||
};
|
||
}
|
||
});
|
||
|
||
/**
|
||
* file:rename —— 修复两点（audit #4 + audit #12 + audit #7）：
|
||
* - 返回 mtimeMs / size 让 renderer 立刻同步侧边栏与状态栏
|
||
* - Windows 上大小写不敏感比对（path.resolve 保留原大小写）
|
||
* - symlink 防护：拒绝重命名 symlink
|
||
*/
|
||
ipcMain.handle('file:rename', async (_event, oldPath, newName) => {
|
||
if (typeof oldPath !== 'string' || typeof newName !== 'string') {
|
||
return { ok: false, error: 'INVALID_ARGS', code: 'INVALID_ARGS', message: '参数类型不合法' };
|
||
}
|
||
const dir = currentDataRoot();
|
||
if (!isWithinDataDir(oldPath, dir)) {
|
||
return { ok: false, error: 'PATH_NOT_ALLOWED', code: 'PATH_NOT_ALLOWED', message: '原路径不在数据目录内' };
|
||
}
|
||
// symlink 防护（audit #7）
|
||
const linkCheck = await assertNotSymlink(oldPath);
|
||
if (!linkCheck.ok) {
|
||
return { ok: false, error: linkCheck.error, code: linkCheck.code, message: linkCheck.message };
|
||
}
|
||
// audit fix (M4 main)：拒绝目录 —— file:rename 契约是「重命名文件」。
|
||
// assertNotSymlink 在 isFile=false 时不区分「目录」与「不存在」，调用方
|
||
// 以前会把目录也当作文件 rename 进去（POSIX 上 fs.rename 真能把目录改名），
|
||
// 与 file:create / file:delete 的 file-only 契约不一致。把目录提前拒掉，
|
||
// 让 Folder Browser 用专门的 folder:rename 路径（见后）。
|
||
if (linkCheck.isFile === false) {
|
||
let st;
|
||
try {
|
||
st = await fs.stat(oldPath);
|
||
} catch {
|
||
st = null;
|
||
}
|
||
if (st && st.isDirectory()) {
|
||
return { ok: false, error: 'NOT_A_FILE', code: 'NOT_A_FILE', message: '该路径是文件夹，请使用文件夹重命名' };
|
||
}
|
||
return { ok: false, error: 'FILE_NOT_FOUND', code: 'FILE_NOT_FOUND', message: '文件已被删除' };
|
||
}
|
||
// audit fix (M1)：原路径父目录链上的 symlink 也要拒 —— 否则 rename 会
|
||
// 跟随到 dataDir 外。
|
||
const oldAncestorCheck = await assertNoSymlinkAncestor(oldPath, dir);
|
||
if (!oldAncestorCheck.ok) {
|
||
return { ok: false, error: oldAncestorCheck.error, code: oldAncestorCheck.code, message: oldAncestorCheck.message };
|
||
}
|
||
|
||
// 解析新文件名（重命名专用：不强制 .md 后缀，用户输入什么就用什么 —— 见 [[project-no-auto-md-on-rename-2026-08]]；
|
||
// 仍做路径分隔符 / Windows 保留字符 / 控制字符 / 重名避让校验）。
|
||
const r = await resolveRenameName(newName, dir);
|
||
// audit fix (Round 7 IPC-3)：补齐 message 字段，并保证 code 一定存在。
|
||
// 旧版直接 `code: r.code`，但 resolveRenameName 历史上不返回 code 字段
|
||
// （参见 main/file-ops.js#resolveRenameName：返回 `{ ok:false, error }`），
|
||
// 导致 code=undefined → renderer 兜底走 result.error 文案语言漂移。
|
||
// 这里给所有失败分支兜底 code='INVALID_NAME'（rename 路径专属）。
|
||
if (!r.ok) {
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_NAME',
|
||
code: 'INVALID_NAME',
|
||
message: r.error,
|
||
};
|
||
}
|
||
|
||
// audit 防御性修复：resolveFileName 内部已 access 失败才返回 r.path，
|
||
// 但 resolve 与 rename 之间存在 TOCTOU 窗口（本地攻击者 / 并发进程可能
|
||
// 在 r.path 位置抢先放一个 symlink，fs.rename 在 POSIX 上会跟随 symlink
|
||
// 重命名到外部目标）。在 rename 前再 lstat 一次，命中 symlink 就拒。
|
||
// 若中间有进程在该位置放了普通文件，fs.rename 会自己撞 EEXIST。
|
||
const targetLinkCheck = await assertNotSymlink(r.path);
|
||
if (!targetLinkCheck.ok) {
|
||
return { ok: false, error: targetLinkCheck.error, code: targetLinkCheck.code, message: targetLinkCheck.message };
|
||
}
|
||
// audit fix (M1)：新路径的父目录链同样要无 symlink。
|
||
const newAncestorCheck = await assertNoSymlinkAncestor(r.path, dir);
|
||
if (!newAncestorCheck.ok) {
|
||
return { ok: false, error: newAncestorCheck.error, code: newAncestorCheck.code, message: newAncestorCheck.message };
|
||
}
|
||
|
||
// 新路径不能等于原路径（Windows 上大小写不敏感比对，audit #12）
|
||
const oldResolved = path.resolve(oldPath);
|
||
const newResolved = path.resolve(r.path);
|
||
const isSamePath = process.platform === 'win32'
|
||
? oldResolved.toLowerCase() === newResolved.toLowerCase()
|
||
: oldResolved === newResolved;
|
||
if (isSamePath) {
|
||
// 同名 short-circuit 时拿真实 mtime/size（状态栏需要）。
|
||
// 若 stat 失败（权限 / 瞬时错误），不要用 0 值污染调用方 —— 状态栏会显示
|
||
// 1970-01-01 让用户怀疑数据丢失。直接返回错误，让 UI 不被 0 值污染。
|
||
let st;
|
||
try {
|
||
st = await fs.stat(oldPath);
|
||
} catch (e) {
|
||
return {
|
||
ok: false,
|
||
error: e.code || 'STAT_FAILED',
|
||
code: e.code,
|
||
message: '读取文件状态失败',
|
||
};
|
||
}
|
||
return {
|
||
ok: true,
|
||
path: r.path,
|
||
name: r.name,
|
||
unchanged: true,
|
||
mtimeMs: st.mtimeMs,
|
||
size: st.size,
|
||
};
|
||
}
|
||
try {
|
||
await fs.rename(oldPath, r.path);
|
||
// 重新 stat 拿到新 mtime/size（audit #4：之前漏掉，renderer 状态栏会短暂无日期）
|
||
const st = await fs.stat(r.path);
|
||
return { ok: true, path: r.path, name: r.name, mtimeMs: st.mtimeMs, size: st.size };
|
||
} catch (e) {
|
||
// audit fix (K1-H1)：console 走 _redactPath（之前 e.message 直接打到日志，
|
||
// 含完整旧路径，tmp 日志 / heap snapshot 里泄漏）；message 走 _friendlyRenameError
|
||
// 翻译成中文，不让英文 errno + 完整路径直接回到 renderer。
|
||
console.error('[main] file:rename 失败:', _redactPath(oldPath), '→', _redactPath(r.path), e.code || e.message);
|
||
return {
|
||
ok: false,
|
||
error: e.code || 'RENAME_FAILED',
|
||
code: e.code,
|
||
message: _friendlyRenameError(e, r.name),
|
||
};
|
||
}
|
||
});
|
||
|
||
/**
|
||
* file:delete —— 修复一点（audit #7）：
|
||
* - symlink 防护：拒绝删除 symlink（避免 trashItem 跟随到外部真实文件）
|
||
* - Stage 8：支持删除文件夹（Folder Browser）。空判断逻辑：
|
||
* `assertNotSymlink` 返回 isFile:false 可能是「目录」或「不存在」；
|
||
* 用 stat 二次判定，存在但不是文件 → 当作目录走 trashItem。
|
||
*/
|
||
ipcMain.handle('file:delete', async (_event, filePath) => {
|
||
if (typeof filePath !== 'string' || !filePath) {
|
||
return { ok: false, error: 'INVALID_PATH', code: 'INVALID_PATH', message: '路径必须是字符串' };
|
||
}
|
||
if (!isWithinDataDir(filePath, currentDataRoot())) {
|
||
return { ok: false, error: 'PATH_NOT_ALLOWED', code: 'PATH_NOT_ALLOWED', message: '路径不在数据目录内' };
|
||
}
|
||
// symlink 防护（audit #7）
|
||
const linkCheck = await assertNotSymlink(filePath);
|
||
if (!linkCheck.ok) {
|
||
return { ok: false, error: linkCheck.error, code: linkCheck.code, message: linkCheck.message };
|
||
}
|
||
// audit fix (M1)：祖先链 symlink 防护 —— 父目录是 symlink 时 trashItem
|
||
// 会跟随到外部真实文件，造成越权删除。
|
||
const ancestorCheck = await assertNoSymlinkAncestor(filePath, currentDataRoot());
|
||
if (!ancestorCheck.ok) {
|
||
return { ok: false, error: ancestorCheck.error, code: ancestorCheck.code, message: ancestorCheck.message };
|
||
}
|
||
// isFile=false 时再 stat 一次区分「目录」与「不存在」；
|
||
// 目录走 trashItem（macOS/Windows 原生支持），ENOENT 报 FILE_NOT_FOUND。
|
||
if (linkCheck.isFile === false) {
|
||
let st;
|
||
try {
|
||
st = await fs.stat(filePath);
|
||
} catch (e) {
|
||
if (e.code === 'ENOENT') {
|
||
return { ok: false, error: 'FILE_NOT_FOUND', code: 'ENOENT', message: '路径已不存在' };
|
||
}
|
||
// audit fix (K1-R4)：与其它 handler 对齐 code/message 形状，不再直回 e.message。
|
||
return { ok: false, error: e.code || 'STAT_FAILED', code: e.code, message: _friendlyShellError(e, '读取状态失败') };
|
||
}
|
||
if (!st.isDirectory()) {
|
||
return { ok: false, error: 'NOT_A_FILE_OR_DIR', code: 'NOT_A_FILE_OR_DIR', message: '该路径既不是文件也不是目录' };
|
||
}
|
||
// 走系统回收站 —— 目录也行；失败兜底 fs.rmdir 删空目录
|
||
try {
|
||
await shell.trashItem(filePath);
|
||
return { ok: true, path: filePath, recycled: true, isFolder: true };
|
||
} catch (e) {
|
||
console.warn('[main] trashItem(目录) 失败，降级到 rmdir:', e.message);
|
||
try {
|
||
await fs.rmdir(filePath);
|
||
return { ok: true, path: filePath, recycled: false, isFolder: true };
|
||
} catch (e2) {
|
||
// 不拼 e2.message（英文 errno + 路径）—— 其它 file:* handler 都用纯中文 message
|
||
return {
|
||
ok: false,
|
||
error: e2.code || 'DELETE_DIR_FAILED',
|
||
code: e2.code,
|
||
message: '删除目录失败（可能非空）',
|
||
};
|
||
}
|
||
}
|
||
}
|
||
// 文件路径：走系统回收站，失败时**不再静默 unlink**。
|
||
// 旧版「trashItem 失败 → fallback unlink」在以下场景会让用户永久失去文件：
|
||
// - 回收站被禁用 / 满（Linux + 部分 Windows 配置）
|
||
// - trashItem 因权限 / EBUSY 失败
|
||
// - 文件在外部存储 / 网络盘等 trash 不可达的位置
|
||
// 现在：trashItem 失败时直接报错，让 UI 提示用户（而不是悄悄 unlink 把文件抹掉）。
|
||
try {
|
||
await shell.trashItem(filePath);
|
||
return { ok: true, path: filePath, recycled: true };
|
||
} catch (e) {
|
||
// audit fix (K1-L2)：之前 message 拼 e.message（英文 errno + 路径）回到 renderer
|
||
// —— 漏完整路径到 UI。其他 file:* handler 都用纯中文 message，这里对齐。
|
||
// 按 errno 翻译：EACCES/EPERM = 没权限、EBUSY = 文件被占、ENOENT = 已不在。
|
||
console.warn('[main] shell.trashItem 失败，不降级 unlink:', _redactPath(filePath), e.code || e.message);
|
||
return {
|
||
ok: false,
|
||
error: 'TRASH_FAILED',
|
||
code: e.code || 'TRASH_FAILED',
|
||
message: _friendlyDeleteError(e),
|
||
};
|
||
}
|
||
});
|
||
|
||
// ============================================
|
||
// IPC: 应用信息
|
||
// ============================================
|
||
|
||
ipcMain.handle('app:get-data-dir', () => currentDataRoot());
|
||
ipcMain.handle('app:get-default-data-dir', () => configStore.getDefaultDataDir());
|
||
ipcMain.handle('app:get-version', () => app.getVersion());
|
||
|
||
ipcMain.handle('app:open-data-dir', async () => {
|
||
let dir;
|
||
try {
|
||
dir = path.resolve(currentDataRoot());
|
||
const st = await fs.stat(dir);
|
||
if (!st.isDirectory()) {
|
||
return { ok: false, error: 'NOT_A_DIRECTORY', code: 'NOT_A_DIRECTORY', message: '数据路径不是一个目录' };
|
||
}
|
||
} catch (e) {
|
||
// audit fix (K1-M1)：补齐 ok / code / message 字段，与其它 handler 形状一致；
|
||
// message 不再拼 e.message（英文 errno + 路径）。
|
||
console.warn('[main] app:open-data-dir stat 失败:', _redactPath(dir), e.code || e.message);
|
||
return {
|
||
ok: false,
|
||
error: e.code || 'STAT_FAILED',
|
||
code: e.code,
|
||
message: '无法访问数据目录',
|
||
};
|
||
}
|
||
try {
|
||
// audit fix (K1-M5)：shell.openPath 返回 Promise，未 await 时空字符串 = 失败
|
||
// 会被静默吞掉，调用方以为「打开成功」实际啥都没发生。await 后检查空串。
|
||
const failure = await shell.openPath(dir);
|
||
if (failure) {
|
||
// shell.openPath 失败时返回错误消息字符串（不是抛错）
|
||
console.warn('[main] shell.openPath 返回失败:', failure);
|
||
return {
|
||
ok: false,
|
||
error: 'OPEN_FAILED',
|
||
code: 'OPEN_FAILED',
|
||
message: `无法打开数据目录：${failure}`,
|
||
};
|
||
}
|
||
return { ok: true, path: dir };
|
||
} catch (e) {
|
||
console.warn('[main] shell.openPath 抛错:', _redactPath(dir), e.message);
|
||
return {
|
||
ok: false,
|
||
error: e.code || 'OPEN_FAILED',
|
||
code: e.code,
|
||
message: '无法打开数据目录',
|
||
};
|
||
}
|
||
});
|
||
|
||
// 仅打开路径，不修改持久化设置（用于设置对话框的"打开"预览按钮）
|
||
//
|
||
// 安全：renderer 不能传任意路径触发 shell.openPath（即使只是打开文件管理器，
|
||
// 也是无谓的权限暴露）。这里强制 target 必须是当前数据目录（settings-dialog.js
|
||
// 也只拿 _configDir 来调用）。路径比对走 path.resolve + 大小写规整化
|
||
// （Windows 不区分大小写、POSIX 区分），避免通过 '..' / 大小写绕过。
|
||
ipcMain.handle('app:open-path', async (_event, target) => {
|
||
if (typeof target !== 'string' || !target) {
|
||
// audit fix (Round 8 IPC-5)：补齐 message 字段，与 file:read / file:write /
|
||
// shell:open-dir 等 handler 对齐。renderer 走 `result.message || result.error
|
||
// || '未知错误'` 兜底，没 message 会拿到英文业务码。
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_PATH',
|
||
code: 'INVALID_PATH',
|
||
message: '路径必须是字符串',
|
||
};
|
||
}
|
||
// path 已在文件顶部 require，这里不再重复（避免阅读时被遮蔽误以为是局部变量）
|
||
// 走 currentDataRoot 而不是 resolveDataDir：customDir 失效时回退到默认，
|
||
// 让预览按钮跟用户实际在用的目录一致（与 fallback 语义对齐）。
|
||
const dataDir = currentDataRoot();
|
||
const resolvedTarget = path.resolve(target);
|
||
const resolvedData = path.resolve(dataDir);
|
||
const samePath = process.platform === 'win32'
|
||
? resolvedTarget.toLowerCase() === resolvedData.toLowerCase()
|
||
: resolvedTarget === resolvedData;
|
||
if (!samePath) {
|
||
return { ok: false, error: 'PATH_NOT_ALLOWED', code: 'PATH_NOT_ALLOWED', message: '仅允许打开当前数据目录' };
|
||
}
|
||
try {
|
||
const st = await fs.stat(resolvedTarget);
|
||
if (!st.isDirectory()) {
|
||
// audit fix (K1-R4)：error 改用 NOT_A_DIRECTORY 业务码（与 shell:open-dir 对齐），
|
||
// 之前用中文 '不是一个目录' 与全文件英文 error 风格不一致。
|
||
return { ok: false, error: 'NOT_A_DIRECTORY', code: 'NOT_A_DIRECTORY', message: '不是一个目录' };
|
||
}
|
||
await shell.openPath(resolvedTarget);
|
||
return { ok: true, path: resolvedTarget };
|
||
} catch (e) {
|
||
// audit fix (K1-R4)：走 _friendlyShellError 翻译 errno，不再直回 e.message。
|
||
return { ok: false, error: e.code || 'OPEN_FAILED', code: e.code, message: _friendlyShellError(e, '无法打开数据目录') };
|
||
}
|
||
});
|
||
|
||
ipcMain.handle('app:choose-data-dir', async () => {
|
||
if (!mainWindow) return null;
|
||
const result = await dialog.showOpenDialog(mainWindow, {
|
||
title: '选择数据文件夹',
|
||
properties: ['openDirectory', 'createDirectory'],
|
||
buttonLabel: '选择此文件夹',
|
||
});
|
||
if (result.canceled || !result.filePaths.length) return null;
|
||
return result.filePaths[0];
|
||
});
|
||
|
||
/**
|
||
* app:reset-data-dir —— 「回到默认」按钮的 IPC（auto-fallback 2026-08）：
|
||
* 1) saveConfig({ dataDir: '' }) 把 custom 持久化值清空，下次启动也走默认
|
||
* 2) 重启 fsWatcher（监听目标从缺失的旧路径切到默认）
|
||
* 3) 刷新托盘菜单（托盘「打开数据文件夹」缓存了旧路径）
|
||
* 4) 返回 { dir, defaultDir } 让 renderer 弹 toast
|
||
*
|
||
* 与 runtime fallback 的区别：runtime fallback 只在内存里走默认，config.json 里
|
||
* 的 dataDir 不动 —— U 盘插回下次启动还能用回去；这里走 saveConfig 是「永久放弃
|
||
* custom 路径」的语义。auto-fallback 已尽量减少用户误触发，这里只对应用户主动点
|
||
* 「回到默认」按钮的明确指令。
|
||
*/
|
||
ipcMain.handle('app:reset-data-dir', async () => {
|
||
if (!mainWindow || mainWindow.isDestroyed()) {
|
||
return { ok: false, error: 'NO_WINDOW' };
|
||
}
|
||
try {
|
||
const saveResult = await configStore.saveConfig({ dataDir: '' });
|
||
if (!saveResult.ok) {
|
||
return { ok: false, error: saveResult.error || '配置保存失败' };
|
||
}
|
||
// 走 currentDataRoot 而不是 resolveDataDir —— 内部会 sync mkdir（默认目录可能
|
||
// 从未被用过）+ 异步种子 welcome.md，让 fsWatcher 启动时不撞 ENOENT、侧栏里
|
||
// 立刻有欢迎文档可见。
|
||
const newDir = currentDataRoot();
|
||
currentDataDir = newDir;
|
||
// 等欢迎文档就绪再重启 fsWatcher，避免「fsWatcher 启动时拿到空目录、
|
||
// 几秒后 welcome.md 突然冒出侧栏」的 UX 撕裂。
|
||
await configStore.scheduleEnsureDefaultDataDir();
|
||
// 重启目录监听：旧监听在缺失的 custom 路径上，新监听切到默认
|
||
try {
|
||
fsWatcher.startWatchingDir(newDir);
|
||
} catch (e) {
|
||
console.warn('[main] 重启目录监听失败（仅依赖轮询）:', e && e.message);
|
||
}
|
||
if (tray) {
|
||
tray.setContextMenu(buildTrayMenu());
|
||
}
|
||
return {
|
||
ok: true,
|
||
dir: newDir,
|
||
defaultDir: configStore.getDefaultDataDir(),
|
||
};
|
||
} catch (e) {
|
||
console.error('[main] app:reset-data-dir 失败:', e && (e.message || e));
|
||
return { ok: false, error: e?.message || '未知错误' };
|
||
}
|
||
});
|
||
|
||
// ============================================
|
||
// IPC: shell.openExternal（链接点击跳转默认浏览器）
|
||
// ============================================
|
||
ipcMain.handle('shell:open-external', async (_event, url) => {
|
||
// audit fix (Round 7 IPC-10)：改成 `{ ok, code, message }` envelope，与全文件
|
||
// 其它 IPC handler 对齐。renderer 端 `if (!ok)` 无法区分「URL 不合法」/「shell
|
||
// 调用失败」/「系统级错误」，统一走 envelope 让 toast 文案可针对原因。
|
||
if (typeof url !== 'string' || !url) {
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_URL',
|
||
code: 'INVALID_URL',
|
||
message: '链接必须是字符串',
|
||
};
|
||
}
|
||
// 防御性：只允许 http(s) 和 mailto，避免被利用打开 file:// / 其他协议
|
||
if (!/^(https?:\/\/|mailto:)/i.test(url)) {
|
||
console.warn('[main] 拒绝打开非 http(s)/mailto URL:', url);
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_URL',
|
||
code: 'INVALID_URL',
|
||
message: '只允许 http(s) / mailto 链接',
|
||
};
|
||
}
|
||
// 进一步校验：scheme 后必须有合法主机部分。
|
||
// 之前只校验前缀，会放过畸形 URL（如 'http:///etc/passwd' / 'http://\x00/foo' /
|
||
// 'http:// host' 带空格）。new URL 在解析失败时抛错，刚好兜底。
|
||
try {
|
||
const parsed = new URL(url);
|
||
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:' && parsed.protocol !== 'mailto:') {
|
||
console.warn('[main] 拒绝打开：协议不匹配', parsed.protocol, url);
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_URL',
|
||
code: 'INVALID_URL',
|
||
message: '协议不被允许',
|
||
};
|
||
}
|
||
// mailto 不要求 hostname；http/https 必须有非空 hostname
|
||
if ((parsed.protocol === 'http:' || parsed.protocol === 'https:') && !parsed.hostname) {
|
||
console.warn('[main] 拒绝打开：缺少 hostname', url);
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_URL',
|
||
code: 'INVALID_URL',
|
||
message: '链接缺少主机名',
|
||
};
|
||
}
|
||
} catch (e) {
|
||
console.warn('[main] 拒绝打开：URL 解析失败', url, e.message);
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_URL',
|
||
code: 'INVALID_URL',
|
||
message: '链接格式不合法',
|
||
};
|
||
}
|
||
try {
|
||
// 必须 await：openExternal 返回 Promise，不接住的话失败会变成
|
||
// unhandledRejection，而渲染端还以为打开成功了
|
||
await shell.openExternal(url);
|
||
return { ok: true };
|
||
} catch (e) {
|
||
console.error('[main] openExternal 失败:', e.message);
|
||
return {
|
||
ok: false,
|
||
error: e.code || 'OPEN_FAILED',
|
||
code: e.code || 'OPEN_FAILED',
|
||
message: '无法打开链接',
|
||
};
|
||
}
|
||
});
|
||
|
||
/**
|
||
* 在系统文件管理器中显示文件（macOS = Reveal，Win/Linux = 选中文件）。
|
||
*
|
||
* 旧版走 `app:open-path` 但那个 IPC 要求 path 必须是目录，
|
||
* 传文件会被拒绝（"不是一个目录"）。这里单独走 shell.showItemInFolder，
|
||
* 是 Electron 提供的"显示文件"标准入口。
|
||
*/
|
||
ipcMain.handle('shell:show-item-in-folder', async (_event, fullPath) => {
|
||
if (typeof fullPath !== 'string' || !fullPath) {
|
||
// audit fix (Round 8 IPC-6)：补齐 message 字段，与 shell:open-dir / file:read
|
||
// 等 handler 对齐。renderer friendlyFsError 兜底走 result.message，没 message
|
||
// 会退到英文业务码。
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_PATH',
|
||
code: 'INVALID_PATH',
|
||
message: '路径必须是字符串',
|
||
};
|
||
}
|
||
// isWithinDataDir 需要数据目录作为第二参；不传则内部 root 为 undefined → 永远 false → 误拒
|
||
if (!isWithinDataDir(fullPath, currentDataRoot())) {
|
||
return { ok: false, error: 'PATH_NOT_ALLOWED', code: 'PATH_NOT_ALLOWED', message: '路径不在数据目录内' };
|
||
}
|
||
try {
|
||
// audit fix (Main P1 / shell:show-item-in-folder symlink check)：
|
||
// 之前 isWithinDataDir 只检「路径字面值是否在数据目录下」—— 但路径若
|
||
// 是数据目录里的符号链接（symlink）且指向外部，shell.showItemInFolder
|
||
// 实际会在文件管理器里打开 symlink 真实目标。攻击向量：
|
||
// - 攻击者诱导用户把外部恶意目录 / 网络共享（`\\evil\share`）做成
|
||
// 数据目录里的 symlink；
|
||
// - 渲染端走 fs.stat（跟随 symlink）拿到合法 st.isFile()=true 通过；
|
||
// - shell.showItemInFolder 在 Windows 上解析为 SMB UNC，系统静默做
|
||
// NTLM 认证（与 Sec-H2 同一族风险，CVE-2023-23397 的笔记版本）。
|
||
// 修复：realpath 拿到「symlink 真实指向」，再次 isWithinDataDir 校验。
|
||
// 真实路径不在数据目录 → 拒（错误码 SYMLINK_OUTSIDE，与 file:write
|
||
// 路径的 SYMLINK_NOT_ALLOWED 对齐但语义更准确）。
|
||
const real = await fs.promises.realpath(fullPath);
|
||
if (!isWithinDataDir(real, currentDataRoot())) {
|
||
return {
|
||
ok: false,
|
||
error: 'SYMLINK_OUTSIDE',
|
||
code: 'SYMLINK_OUTSIDE',
|
||
message: '符号链接指向数据目录外',
|
||
};
|
||
}
|
||
const st = await fs.stat(fullPath);
|
||
if (!st.isFile()) {
|
||
return { ok: false, error: 'NOT_A_FILE', code: 'NOT_A_FILE', message: '不是一个文件' };
|
||
}
|
||
shell.showItemInFolder(fullPath);
|
||
return { ok: true };
|
||
} catch (e) {
|
||
if (e.code === 'ENOENT') return { ok: false, error: 'FILE_NOT_FOUND', code: 'FILE_NOT_FOUND', message: '文件不存在' };
|
||
// audit fix (K1-R4)：走 _friendlyShellError 翻译 errno，不再直回 e.message。
|
||
return { ok: false, error: e.code || 'STAT_FAILED', code: e.code, message: _friendlyShellError(e, '无法在文件夹中显示') };
|
||
}
|
||
});
|
||
|
||
/**
|
||
* 在系统文件管理器中打开数据目录下的任意目录（子目录 / 数据根）。
|
||
*
|
||
* 与 `shell:show-item-in-folder` 的差别：showItemInFolder 只接受文件路径
|
||
* （"在文件夹中显示并选中文件"语义），无法用来打开一个目录供用户浏览。
|
||
* 状态栏左侧的路径 chip 在「没打开文件」时会显示当前浏览目录，此时点击应该
|
||
* 真的打开那个目录（Win/Linux = 资源管理器进目录；macOS = Finder 进目录），
|
||
* 而不是静默无副作用。
|
||
*
|
||
* 安全：与 `shell:show-item-in-folder` 对称 —— 强制 isWithinDataDir 边界检查，
|
||
* 不让 renderer 通过这条 IPC 打开任意系统目录。
|
||
*/
|
||
ipcMain.handle('shell:open-dir', async (_event, dirPath) => {
|
||
if (typeof dirPath !== 'string' || !dirPath) {
|
||
// audit fix (Round 7 IPC-4)：补齐 code + message 字段，与其它 shell:* handler
|
||
// 对齐。renderer 走 friendlyFsError(code, message) 没 message 兜底到英文。
|
||
return {
|
||
ok: false,
|
||
error: 'INVALID_PATH',
|
||
code: 'INVALID_PATH',
|
||
message: '路径必须是字符串',
|
||
};
|
||
}
|
||
const resolved = path.resolve(dirPath);
|
||
if (!isWithinDataDir(resolved, currentDataRoot())) {
|
||
return { ok: false, error: 'PATH_NOT_ALLOWED', message: '路径不在数据目录内' };
|
||
}
|
||
try {
|
||
// audit fix：用 lstat 拒绝 symlink 目录（与 file:scan-dir 对齐）。
|
||
// fs.stat 跟随 symlink —— resolved 若指向外部目录，stat 仍能拿到目标目录
|
||
// 信息，导致下面的 shell.openPath 跑出数据目录边界。lstat + isSymbolicLink
|
||
// 检查与 file:scan-dir 一致。
|
||
const lst = await fs.lstat(resolved);
|
||
if (lst.isSymbolicLink()) {
|
||
return { ok: false, error: 'SYMLINK_NOT_ALLOWED', code: 'SYMLINK_NOT_ALLOWED', message: '不允许在符号链接目录上执行此操作' };
|
||
}
|
||
if (!lst.isDirectory()) {
|
||
// audit fix (Round 7 IPC-9)：补齐 message 字段，与 line 1705/1717/1720 对齐。
|
||
// renderer 走 `friendlyFsError(code, message || error || '未知错误')` 时
|
||
// 缺 message 兜底到 result.error 业务码字符串 'NOT_A_DIRECTORY'，用户看到
|
||
// 的是代码不是中文。
|
||
return {
|
||
ok: false,
|
||
error: 'NOT_A_DIRECTORY',
|
||
code: 'NOT_A_DIRECTORY',
|
||
message: '路径不是文件夹',
|
||
};
|
||
}
|
||
const failure = await shell.openPath(resolved);
|
||
if (failure) {
|
||
// shell.openPath 失败时返回错误消息字符串（不是抛错），参考 app:open-path
|
||
return { ok: false, error: 'OPEN_FAILED', code: 'OPEN_FAILED', message: failure };
|
||
}
|
||
return { ok: true };
|
||
} catch (e) {
|
||
if (e.code === 'ENOENT') return { ok: false, error: 'DIR_NOT_FOUND', code: 'DIR_NOT_FOUND', message: '目录不存在' };
|
||
// audit fix (K1-R4)：走 _friendlyShellError 翻译 errno，不再直回 e.message。
|
||
return { ok: false, error: e.code || 'OPEN_FAILED', code: e.code, message: _friendlyShellError(e, '无法打开目录') };
|
||
}
|
||
});
|
||
|
||
// ============================================
|
||
// IPC: 窗口控制
|
||
// ============================================
|
||
|
||
ipcMain.handle('window:set-always-on-top', (_event, enabled) => {
|
||
if (!mainWindow || mainWindow.isDestroyed()) return false;
|
||
if (typeof enabled !== 'boolean') {
|
||
console.warn('[main] setAlwaysOnTop 收到非布尔值:', enabled);
|
||
return false;
|
||
}
|
||
try {
|
||
mainWindow.setAlwaysOnTop(enabled);
|
||
return true;
|
||
} catch (e) {
|
||
console.error('[main] setAlwaysOnTop 失败:', e.message);
|
||
return false;
|
||
}
|
||
});
|
||
|
||
ipcMain.handle('window:minimize', () => {
|
||
if (!mainWindow || mainWindow.isDestroyed()) return false;
|
||
// audit fix (K1-L4)：try/catch 兜底 —— minimize() 在窗口被销毁过程中可能抛
|
||
// "Object has been destroyed"，与 setAlwaysOnTop 的 L4 修复对齐。
|
||
try {
|
||
mainWindow.minimize();
|
||
return true;
|
||
} catch (e) {
|
||
console.warn('[main] window:minimize 失败:', e.message);
|
||
return false;
|
||
}
|
||
});
|
||
|
||
ipcMain.handle('window:toggle-maximize', () => {
|
||
if (!mainWindow || mainWindow.isDestroyed()) return false;
|
||
try {
|
||
if (mainWindow.isMaximized()) {
|
||
mainWindow.unmaximize();
|
||
} else {
|
||
mainWindow.maximize();
|
||
}
|
||
return mainWindow.isMaximized();
|
||
} catch (e) {
|
||
console.warn('[main] window:toggle-maximize 失败:', e.message);
|
||
return false;
|
||
}
|
||
});
|
||
|
||
ipcMain.handle('window:close', () => {
|
||
if (!mainWindow || mainWindow.isDestroyed()) return false;
|
||
try {
|
||
mainWindow.close();
|
||
return true;
|
||
} catch (e) {
|
||
console.warn('[main] window:close 失败:', e.message);
|
||
return false;
|
||
}
|
||
});
|
||
|
||
function broadcastMaximizeState() {
|
||
if (!mainWindow || mainWindow.isDestroyed()) return;
|
||
mainWindow.webContents.send('window:maximize-state', mainWindow.isMaximized());
|
||
}
|
||
|
||
// ============================================
|
||
// IPC: AI 修改
|
||
// ============================================
|
||
|
||
/**
|
||
* 渲染端发来修改请求：调 OpenAI 兼容 API，返回 { id, content, responseFormat }。
|
||
* 错误统一返回 { ok:false, error, message } 供 renderer 弹 toast。
|
||
*/
|
||
ipcMain.handle('ai:edit', async (_event, payload) => {
|
||
if (!payload || typeof payload !== 'object') {
|
||
return { ok: false, error: 'INVALID_PAYLOAD', message: '请求体无效' };
|
||
}
|
||
const { prompt, content, filename, requestId } = payload;
|
||
return aiProxy.runEdit({ prompt, content, filename, requestId });
|
||
});
|
||
|
||
/**
|
||
* 渲染端发来取消请求：找到对应 requestId 的 AbortController 并触发 abort。
|
||
* 找不到（请求已完成 / 超时）静默忽略。
|
||
*/
|
||
ipcMain.on('ai:cancel', (_event, requestId) => {
|
||
if (typeof requestId === 'string' && requestId) {
|
||
aiProxy.cancel(requestId);
|
||
}
|
||
});
|
||
|
||
// ============================================
|
||
// IPC: 应用设置（持久化）
|
||
// ============================================
|
||
|
||
ipcMain.handle('app:get-settings', () => {
|
||
const cfg = configStore.getConfig() || {};
|
||
const { aiApiKey, ...rest } = cfg;
|
||
// P1-1 fix (audit)：过滤 aiApiKey 真值，只露布尔标记。renderer 任何位置
|
||
// 通过 window.api.getSettings() 都拿不到完整 Key —— 必须显式调
|
||
// app:reveal-ai-key 才能拿真值（settings 对话框回显用）。
|
||
return { ...rest, aiApiKey: '', _hasAiKey: !!aiApiKey };
|
||
});
|
||
|
||
/**
|
||
* Q7/Q9 fix (audit)：「显示 API Key」必须先 arm 再 reveal：
|
||
*
|
||
* 1. settings-dialog 在用户主动点击「显示 Key」时先调 app:arm-reveal-ai-key
|
||
* —— 主进程记录一个 5 秒 armed 窗口（per-sender，按 webContents.id 区分）。
|
||
* 2. 然后调 app:reveal-ai-key —— 主进程检查 armed 窗口仍在有效期内。
|
||
* 3. reveal 后立即 disarm。
|
||
*
|
||
* DevTools / 第三方 hook / 任何意外注入的 JS 不会先经过「用户点按钮」事件，
|
||
* 自然不会调 arm。一旦 arm 流程跑过，主进程日志记下 time + senderId，方便
|
||
* 事后审计。这条链路**不能**完全防御已被攻陷的 renderer（renderer 拿到的
|
||
* IPC 桥跟合法代码一样），但能在「合法流程之外」显著抬高成本（attacker 必须
|
||
* 也调 arm 才能拿 key，会留下可追溯的日志条目）。
|
||
*
|
||
* 不入 renderer 常驻缓存；调用方应在用完后立即从 DOM 清掉。
|
||
*/
|
||
const REVEAL_ARMED_TTL_MS = 5_000;
|
||
/** @type {Map<number, number>} webContents.id → 截止时间戳 */
|
||
const revealArmedBySender = new Map();
|
||
|
||
ipcMain.handle('app:arm-reveal-ai-key', (event) => {
|
||
const senderId = event.sender && event.sender.id;
|
||
if (typeof senderId !== 'number') {
|
||
return { ok: false, error: 'INVALID_SENDER' };
|
||
}
|
||
const until = Date.now() + REVEAL_ARMED_TTL_MS;
|
||
revealArmedBySender.set(senderId, until);
|
||
// L4 fix (audit)：去掉 ISO 时间戳（精确到 ms 让 arm 时刻成为可关联的 fingerprint），
|
||
// 改用 ttlMs 表明窗口长度即可。
|
||
console.log('[reveal-ai-key] armed by sender', senderId, 'ttlMs=', REVEAL_ARMED_TTL_MS);
|
||
// 兜底：armed 窗口过期自动清理（防止 reveal 永远不来，Map 一直占位）
|
||
setTimeout(() => {
|
||
const cur = revealArmedBySender.get(senderId);
|
||
if (cur === until) revealArmedBySender.delete(senderId);
|
||
}, REVEAL_ARMED_TTL_MS + 100).unref?.();
|
||
return { ok: true, ttlMs: REVEAL_ARMED_TTL_MS };
|
||
});
|
||
|
||
ipcMain.handle('app:reveal-ai-key', (event) => {
|
||
const senderId = event.sender && event.sender.id;
|
||
const until = (typeof senderId === 'number') ? revealArmedBySender.get(senderId) : undefined;
|
||
// 任意一条命中即拒绝：没 arm / arm 已过期 / sender 不匹配
|
||
if (typeof until !== 'number' || until <= Date.now()) {
|
||
if (typeof senderId === 'number') revealArmedBySender.delete(senderId);
|
||
// 不打印 apiKey 内容；只记"拒绝了一次 reveal 尝试"，方便事后追查
|
||
console.warn('[reveal-ai-key] rejected: no valid arm window for sender', senderId);
|
||
return { ok: false, error: 'NOT_AUTHORIZED' };
|
||
}
|
||
// 一次性：reveal 后立即 disarm，避免同一窗口被重放
|
||
revealArmedBySender.delete(senderId);
|
||
const cfg = configStore.getConfig() || {};
|
||
// 显式记一条"成功 reveal"日志（含 key 长度而非真值，便于事后核对"有没有人偷 key"）
|
||
// L4 fix (audit)：单行结构、sender + length，去掉任何 key 相关指纹；
|
||
// 配 arm 日志一起能看出 arm→reveal 时序关系。
|
||
const keyStr = String(cfg.aiApiKey || '');
|
||
console.log('[reveal-ai-key] revealed by sender', senderId, 'length=', keyStr.length);
|
||
return { ok: true, aiApiKey: keyStr };
|
||
});
|
||
|
||
/**
|
||
* 返回 config.json 的真实路径 + 所在目录。
|
||
* 设置对话框用：让用户看到 API Key / 设置到底存在了哪个文件，
|
||
* 并能一键打开所在目录自行核对/备份。
|
||
*
|
||
* audit fix (M4)：路径在 tmp 日志 / 屏幕共享 / 截图里出现会暴露 Windows 用户名
|
||
* （`C:\Users\<name>\AppData\...`）。设置面板只需要「哪个文件 / 哪个目录」足够
|
||
* 用户理解位置，把 basename / dir basename 返回即可，完整路径仅在「打开所在
|
||
* 目录」按钮内部使用（不再经过 IPC）。
|
||
*/
|
||
ipcMain.handle('app:get-config-path', () => {
|
||
const filePath = configStore.getConfigPath();
|
||
return {
|
||
name: path.basename(filePath),
|
||
dirName: path.basename(path.dirname(filePath)),
|
||
};
|
||
});
|
||
|
||
/**
|
||
* 打开 config.json 所在目录（设置对话框 AI 段的 [打开文件夹] 按钮）。
|
||
*
|
||
* audit fix (Round 9 CFG-1)：这个按钮之前完全是死的，两处同时坏掉 ——
|
||
* 1) M4 把 `app:get-config-path` 的返回从 `{path, dir}` 改成 `{name, dirName}`
|
||
* 做隐私脱敏，但 settings-dialog 仍读 `cfg.path` / `cfg.dir` → 都是
|
||
* undefined → `initial._configPath` 永不赋值 → hint 里的路径 + 按钮
|
||
* 整段模板不渲染（文案还断在「存储于 config.json」和「。每次请求」之间）。
|
||
* 2) 即便按钮渲染出来，它调的 `app:open-path` 强制 target === 当前数据目录，
|
||
* 传 config 目录会被 PATH_NOT_ALLOWED 拒掉（那个 handler 的注释说
|
||
* 「settings-dialog 也只拿 _configDir 来调用」，但 _configDir 是 userData
|
||
* 目录、不是数据目录 —— 注释与事实不符）。
|
||
*
|
||
* 这里用「不接参数」的专用 handler 同时满足两个既有约束：完整路径不过 IPC
|
||
* （隐私），renderer 也无法传任意路径（安全）。形状与 app:open-data-dir 对齐。
|
||
*/
|
||
ipcMain.handle('app:open-config-dir', async () => {
|
||
let dir;
|
||
try {
|
||
dir = path.dirname(configStore.getConfigPath());
|
||
const st = await fs.stat(dir);
|
||
if (!st.isDirectory()) {
|
||
return { ok: false, error: 'NOT_A_DIRECTORY', code: 'NOT_A_DIRECTORY', message: '配置路径不是一个目录' };
|
||
}
|
||
} catch (e) {
|
||
console.warn('[main] app:open-config-dir stat 失败:', _redactPath(dir), e.code || e.message);
|
||
return { ok: false, error: e.code || 'STAT_FAILED', code: e.code, message: '无法访问配置目录' };
|
||
}
|
||
try {
|
||
const failure = await shell.openPath(dir);
|
||
if (failure) {
|
||
console.warn('[main] shell.openPath 返回失败:', failure);
|
||
return { ok: false, error: 'OPEN_FAILED', code: 'OPEN_FAILED', message: `无法打开配置目录：${failure}` };
|
||
}
|
||
// 不回传 dir —— 完整路径带 Windows 用户名，与 app:get-config-path 的脱敏一致。
|
||
return { ok: true };
|
||
} catch (e) {
|
||
console.warn('[main] shell.openPath 抛错:', _redactPath(dir), e.message);
|
||
return { ok: false, error: e.code || 'OPEN_FAILED', code: e.code, message: _friendlyShellError(e, '无法打开配置目录') };
|
||
}
|
||
});
|
||
|
||
/**
|
||
* 保存设置。
|
||
* 返回结构化结果 { ok:true, settings } / { ok:false, error }，而不是抛错 ——
|
||
* ipcMain.handle 抛出的错误会被 Electron 包装成
|
||
* "Error invoking remote method 'app:save-settings': Error: 目录不存在"，
|
||
* 渲染端直接把这串东西塞进 toast 很难看。
|
||
*/
|
||
ipcMain.handle('app:save-settings', async (event, partial) => {
|
||
if (!partial || typeof partial !== 'object') return { ok: true, settings: configStore.getConfig() };
|
||
|
||
// 目录存在性校验（schema 里用 opts.resolveDir 注入，因为要异步 fs.stat + access）
|
||
const resolveDir = async (p) => {
|
||
try {
|
||
const st = await fs.stat(p);
|
||
if (!st.isDirectory()) return { ok: false, error: '路径不是一个目录' };
|
||
await fs.access(p, fsSync.constants.R_OK);
|
||
return { ok: true };
|
||
} catch (e) {
|
||
if (e.code === 'ENOENT') return { ok: false, error: '目录不存在' };
|
||
if (e.code === 'EACCES' || e.code === 'EPERM') return { ok: false, error: '没有访问权限' };
|
||
return { ok: false, error: e.message || '无法访问该目录' };
|
||
}
|
||
};
|
||
|
||
const result = await validateAndSanitize(partial, { resolveDir });
|
||
if (!result.ok) return { ok: false, error: result.error };
|
||
const sanitized = result.sanitized;
|
||
|
||
// audit fix (main-M4)：先 saveConfig 再 apply 窗口 / 托盘副作用。旧实现先
|
||
// setAlwaysOnTop / 重建 tray menu，saveConfig 失败时 UI 已变更、磁盘还是
|
||
// 旧值，重启后置顶状态被撤回 + 用户以为配置损坏。修复后语义：「磁盘先
|
||
// 落定，UI 再跟上」—— saveConfig 失败直接返回 {ok:false}，副作用一段都
|
||
// 不跑。
|
||
// audit fix (Round 8 M-1)：必须在 saveConfig 之前快照旧值。saveConfig 成功时
|
||
// 会把 appConfig 就地换成 merged（config-store.js:188），之后再读
|
||
// configStore.getConfig().alwaysOnTop 拿到的已经是新值 → 与 sanitized 恒等 →
|
||
// `!==` 恒为 false → setAlwaysOnTop / 托盘菜单刷新一次都不跑。表现：用户勾选
|
||
// 「始终置顶」后磁盘和 UI 都变了，但窗口实际没置顶、托盘勾选状态也不同步，
|
||
// 要重启（createWindow 重新 apply）才生效。
|
||
const prevAlwaysOnTop = configStore.getConfig().alwaysOnTop;
|
||
const saveResult = await configStore.saveConfig(sanitized);
|
||
if (!saveResult.ok) {
|
||
return { ok: false, error: saveResult.error || '配置保存失败' };
|
||
}
|
||
const next = saveResult.value;
|
||
|
||
// alwaysOnTop 变更需要同步到窗口 + tray（schema 不应耦合 Electron API，所以副作用留在 main.js）
|
||
if ('alwaysOnTop' in sanitized && prevAlwaysOnTop !== sanitized.alwaysOnTop) {
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
mainWindow.setAlwaysOnTop(sanitized.alwaysOnTop);
|
||
}
|
||
if (tray) {
|
||
tray.setContextMenu(buildTrayMenu());
|
||
}
|
||
}
|
||
|
||
// dataDir 变更后重新启动目录监听 + 刷新托盘菜单（托盘「打开数据文件夹」缓存了旧路径）
|
||
if ('dataDir' in sanitized) {
|
||
// 走 currentDataRoot 而不是 resolveDataDir：customDir 失效时 fallback 到默认
|
||
// 并 sync mkdir，确保 fsWatcher 启动时不撞 ENOENT。
|
||
const newDirRaw = currentDataRoot();
|
||
await configStore.scheduleEnsureDefaultDataDir();
|
||
// audit fix：直接比较字符串会因为尾斜杠 / 大小写 / `..` 残留而误判。
|
||
// 用 path.resolve 归一化后再比；Windows 上大小写不敏感。
|
||
const newResolved = path.resolve(newDirRaw);
|
||
const curResolved = path.resolve(currentDataDir);
|
||
const same = process.platform === 'win32'
|
||
? newResolved.toLowerCase() === curResolved.toLowerCase()
|
||
: newResolved === curResolved;
|
||
if (!same) {
|
||
currentDataDir = newDirRaw;
|
||
fsWatcher.startWatchingDir(newDirRaw);
|
||
if (tray) {
|
||
tray.setContextMenu(buildTrayMenu());
|
||
}
|
||
}
|
||
}
|
||
|
||
// Phase N 安全修复：save-settings 之前直接 echo `next`，里面含 aiApiKey 明文。
|
||
// renderer settingsStore.update 会拿这个 settings 调 coerceLoadedSettings
|
||
// 覆盖 _settings —— 把真值灌进内存。后续 getSettings / getAll / IPC echo 都
|
||
// 走同一份内存，AI Key 明文在内存里能待到下次 restart。
|
||
// 与 get-settings 同款 redaction：剥掉 aiApiKey 真值、用 aiApiKey='' 占位、
|
||
// 用 _hasAiKey 标记"是否配置过 Key"。renderer settings-store 已在 update 路径
|
||
// 把 aiApiKey='' 落进 _settings 与 cachePartial，"清空 Key" 的写入也无副作用
|
||
// 走空字符串 diff。
|
||
const { aiApiKey: realKey, ...rest } = next;
|
||
return { ok: true, settings: { ...rest, aiApiKey: '', _hasAiKey: !!realKey } };
|
||
});
|
||
|
||
// ============================================
|
||
// 应用菜单
|
||
// ============================================
|
||
|
||
function buildMenu() {
|
||
const isMac = process.platform === 'darwin';
|
||
const template = [
|
||
...(isMac ? [{
|
||
label: app.name,
|
||
submenu: [
|
||
{ role: 'about' },
|
||
{ type: 'separator' },
|
||
{ role: 'quit' }
|
||
]
|
||
}] : []),
|
||
{
|
||
label: '视图',
|
||
submenu: [
|
||
{
|
||
label: '切换主题',
|
||
accelerator: 'CmdOrCtrl+Shift+T',
|
||
click: () => mainWindow?.webContents.send('menu:toggle-theme')
|
||
},
|
||
{ type: 'separator' },
|
||
{
|
||
label: '设置...',
|
||
accelerator: 'CmdOrCtrl+,',
|
||
click: () => mainWindow?.webContents.send('menu:settings')
|
||
},
|
||
{ type: 'separator' },
|
||
{
|
||
label: '开发者工具',
|
||
accelerator: 'F12',
|
||
click: () => mainWindow?.webContents.toggleDevTools()
|
||
},
|
||
{ role: 'reload', label: '重新加载' }
|
||
]
|
||
}
|
||
];
|
||
|
||
Menu.setApplicationMenu(Menu.buildFromTemplate(template));
|
||
} |