dennii/Termix
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases 22 Wiki Activity

Update logo, move translations, update electron building.

Browse Source
This commit is contained in:
LukeGus
2025-09-10 19:18:06 -05:00
parent 9d84469ea3
commit 86671a670d
35 changed files with 2386 additions and 832 deletions
Download Patch File Download Diff File Expand all files Collapse all files
electron/main-simple.cjs
-236
View File
@@ -1,236 +0,0 @@
const { app, BrowserWindow, Menu, shell, ipcMain } = require('electron');
const path = require('path');
const { spawn } = require('child_process');
// 全局变量
let mainWindow = null;
let backendProcess = null;
// 开发环境检测
const isDev = process.env.NODE_ENV === 'development' || !app.isPackaged;
// 启动后端服务
function startBackendServer() {
if (backendProcess) {
console.log('Backend server already running');
return;
}
// 在打包环境中，后端文件在 resources/app/dist/backend/backend/ 目录下
const backendPath = isDev
? path.join(__dirname, '../dist/backend/starter.js')
: path.join(process.resourcesPath, 'app', 'dist', 'backend', 'backend', 'starter.js');
console.log('Starting backend server from:', backendPath);
console.log('Working directory:', process.cwd());
// 设置环境变量
const env = {
...process.env,
NODE_ENV: 'production',
DATA_PATH: app.getPath('userData'),
DB_PATH: path.join(app.getPath('userData'), 'database.db'),
VERSION: app.getVersion()
};
// 检查文件是否存在
const fs = require('fs');
if (!fs.existsSync(backendPath)) {
console.error('Backend file not found at:', backendPath);
return;
}
console.log('Backend file exists, starting process...');
console.log('Environment variables:', env);
backendProcess = spawn('node', [backendPath], {
stdio: ['ignore', 'pipe', 'pipe'],
detached: false,
cwd: isDev ? path.join(__dirname, '..') : process.resourcesPath,
env: env
});
backendProcess.stdout.on('data', (data) => {
console.log('Backend stdout:', data.toString());
});
backendProcess.stderr.on('data', (data) => {
console.error('Backend stderr:', data.toString());
});
backendProcess.on('close', (code) => {
console.log(`Backend process exited with code ${code}`);
backendProcess = null;
});
backendProcess.on('error', (error) => {
console.error('Failed to start backend process:', error);
console.error('Error details:', error.message);
console.error('Error code:', error.code);
backendProcess = null;
});
// 等待一下看看进程是否启动成功
setTimeout(() => {
if (backendProcess && !backendProcess.killed) {
console.log('Backend process appears to be running');
} else {
console.error('Backend process failed to start or died immediately');
}
}, 1000);
}
// 停止后端服务
function stopBackendServer() {
if (backendProcess) {
console.log('Stopping backend server...');
backendProcess.kill();
backendProcess = null;
}
}
// 防止多开
const gotTheLock = app.requestSingleInstanceLock();
if (!gotTheLock) {
app.quit();
} else {
app.on('second-instance', () => {
if (mainWindow) {
if (mainWindow.isMinimized()) mainWindow.restore();
mainWindow.focus();
}
});
}
// 创建主窗口
function createWindow() {
mainWindow = new BrowserWindow({
width: 1200,
height: 800,
minWidth: 800,
minHeight: 600,
title: 'Termix',
icon: path.join(__dirname, '..', 'public', 'icon.png'),
webPreferences: {
nodeIntegration: false,
contextIsolation: true,
preload: path.join(__dirname, 'preload-simple.cjs'),
webSecurity: !isDev
},
show: false,
});
// 创建应用菜单（包含开发者工具快捷键）
const template = [
{
label: 'View',
submenu: [
{
label: 'Toggle Developer Tools',
accelerator: process.platform === 'darwin' ? 'Alt+Command+I' : 'Ctrl+Shift+I',
click: () => {
mainWindow.webContents.toggleDevTools();
}
},
{
label: 'Reload',
accelerator: 'CmdOrCtrl+R',
click: () => {
mainWindow.webContents.reload();
}
}
]
}
];
const menu = Menu.buildFromTemplate(template);
Menu.setApplicationMenu(menu);
// 加载应用
if (isDev) {
// 开发环境：连接到 Vite 开发服务器
mainWindow.loadURL('http://localhost:5173');
mainWindow.webContents.openDevTools();
} else {
// 生产环境：加载构建后的文件
mainWindow.loadFile(path.join(__dirname, '..', 'dist', 'index.html'));
// 生产环境也启用开发者工具以便调试
mainWindow.webContents.openDevTools();
}
// 窗口准备好后显示
mainWindow.once('ready-to-show', () => {
mainWindow.show();
});
// 处理窗口关闭事件
mainWindow.on('closed', () => {
mainWindow = null;
});
// 处理外部链接
mainWindow.webContents.setWindowOpenHandler(({ url }) => {
shell.openExternal(url);
return { action: 'deny' };
});
}
// IPC 通信处理
ipcMain.handle('get-app-version', () => {
return app.getVersion();
});
ipcMain.handle('get-platform', () => {
return process.platform;
});
ipcMain.handle('get-backend-port', () => {
return 8081; // 后端服务端口
});
ipcMain.handle('restart-backend', async () => {
try {
stopBackendServer();
await new Promise(resolve => setTimeout(resolve, 1000)); // 等待1秒
startBackendServer();
return { success: true };
} catch (error) {
return { success: false, error: error.message };
}
});
// 应用事件处理
app.whenReady().then(async () => {
// 启动后端服务
startBackendServer();
// 等待后端服务启动
await new Promise(resolve => setTimeout(resolve, 2000));
createWindow();
});
app.on('window-all-closed', () => {
stopBackendServer();
if (process.platform !== 'darwin') {
app.quit();
}
});
app.on('activate', () => {
if (BrowserWindow.getAllWindows().length === 0) {
createWindow();
} else if (mainWindow) {
mainWindow.show();
}
});
// 处理未捕获的异常
process.on('uncaughtException', (error) => {
console.error('Uncaught Exception:', error);
});
process.on('unhandledRejection', (reason, promise) => {
console.error('Unhandled Rejection at:', promise, 'reason:', reason);
});
electron/main.cjs
+80 -348
View File
@@ -1,52 +1,24 @@
const { app, BrowserWindow, Menu, Tray, shell, ipcMain, dialog } = require('electron');
const { app, BrowserWindow, Menu, shell, ipcMain } = require('electron');
const path = require('path');
const { spawn } = require('child_process');
const fs = require('fs');
// 动态导入可能有 ESM 问题的模块
let portfinder;
let Store;
let autoUpdater;
try {
portfinder = require('portfinder');
Store = require('electron-store');
const updaterModule = require('electron-updater');
autoUpdater = updaterModule.autoUpdater;
} catch (error) {
console.error('Error loading modules:', error);
// 提供后备方案
portfinder = {
getPortPromise: async () => 18080 + Math.floor(Math.random() * 100)
};
Store = class {
constructor() { this.data = {}; }
get(key, defaultValue) { return this.data[key] || defaultValue; }
set(key, value) { this.data[key] = value; }
};
}
// 初始化配置存储
const store = new Store();
// 全局变量
// Global variables
let mainWindow = null;
let backendProcess = null;
let tray = null;
let backendPort = null;
let isQuitting = false;
// 开发环境检测
// Development environment detection
const isDev = process.env.NODE_ENV === 'development' || !app.isPackaged;
// 防止多开
const gotTheLock = app.requestSingleInstanceLock();
const BACKEND_CONFIG = {
port: 18080
};
// Prevent multiple instances
const gotTheLock = app.requestSingleInstanceLock();
if (!gotTheLock) {
app.quit();
} else {
app.on('second-instance', () => {
// 如果用户试图运行第二个实例，我们应该聚焦我们的窗口
if (mainWindow) {
if (mainWindow.isMinimized()) mainWindow.restore();
mainWindow.focus();
@@ -54,217 +26,43 @@ if (!gotTheLock) {
});
}
// 后端进程管理类
class BackendManager {
constructor() {
this.process = null;
this.port = null;
this.retryCount = 0;
this.maxRetries = 3;
this.isStarting = false;
this.healthCheckInterval = null;
}
// Simple backend management
async function startBackend() {
try {
console.log('Starting backend...');
// Set up environment
process.env.NODE_ENV = 'production';
process.env.PORT = BACKEND_CONFIG.port.toString();
process.env.DATA_PATH = app.getPath('userData');
process.env.DB_PATH = path.join(app.getPath('userData'), 'database.db');
process.env.VERSION = app.getVersion();
async findAvailablePort() {
portfinder.basePort = store.get('backend.port', 18080);
try {
const port = await portfinder.getPortPromise();
this.port = port;
return port;
} catch (error) {
console.error('Error finding available port:', error);
throw error;
}
}
// Get backend path
const backendPath = isDev
? path.join(__dirname, '..', 'dist', 'backend', 'starter.js')
: path.join(process.resourcesPath, 'dist', 'backend', 'starter.js');
async start() {
if (this.isStarting || this.process) {
console.log('Backend already starting or running');
return;
console.log('Loading backend from:', backendPath);
if (!fs.existsSync(backendPath)) {
console.error('Backend file not found at:', backendPath);
return null;
}
this.isStarting = true;
// Load and start the backend
const { startServer } = await import(backendPath);
backendPort = await startServer();
console.log('Backend started successfully on port:', backendPort);
return backendPort;
try {
// 查找可用端口
await this.findAvailablePort();
console.log(`Starting backend on port ${this.port}`);
// 确定后端可执行文件路径
let backendPath;
if (isDev) {
// 开发环境：使用 node 运行构建后的 JS
backendPath = path.join(__dirname, '..', 'dist', 'backend', 'starter.js');
} else {
// 生产环境：使用打包后的后端
backendPath = path.join(process.resourcesPath, 'backend', 'starter.js');
}
// 确保后端文件存在
if (!fs.existsSync(backendPath)) {
throw new Error(`Backend file not found at ${backendPath}`);
}
// 设置环境变量
const env = {
...process.env,
PORT: this.port.toString(),
NODE_ENV: isDev ? 'development' : 'production',
DATA_PATH: app.getPath('userData'),
DB_PATH: path.join(app.getPath('userData'), 'database.db'),
};
// 启动后端进程
if (isDev) {
this.process = spawn('node', [backendPath], {
env,
cwd: path.join(__dirname, '..'),
stdio: ['ignore', 'pipe', 'pipe']
});
} else {
this.process = spawn('node', [backendPath], {
env,
cwd: process.resourcesPath,
stdio: ['ignore', 'pipe', 'pipe']
});
}
// 监听后端输出
this.process.stdout.on('data', (data) => {
console.log(`Backend stdout: ${data}`);
// 向渲染进程发送日志
if (mainWindow) {
mainWindow.webContents.send('backend-log', data.toString());
}
});
this.process.stderr.on('data', (data) => {
console.error(`Backend stderr: ${data}`);
if (mainWindow) {
mainWindow.webContents.send('backend-error', data.toString());
}
});
// 监听后端进程退出
this.process.on('exit', (code) => {
console.log(`Backend process exited with code ${code}`);
this.process = null;
this.isStarting = false;
// 如果不是正在退出且退出码不为0，尝试重启
if (!isQuitting && code !== 0 && this.retryCount < this.maxRetries) {
this.retryCount++;
console.log(`Attempting to restart backend (retry ${this.retryCount}/${this.maxRetries})`);
setTimeout(() => this.start(), 2000);
}
});
// 等待后端启动
await this.waitForBackend();
// 启动健康检查
this.startHealthCheck();
// 更新全局端口变量
backendPort = this.port;
// 通知渲染进程
if (mainWindow) {
mainWindow.webContents.send('backend-started', { port: this.port });
}
this.isStarting = false;
this.retryCount = 0;
return this.port;
} catch (error) {
console.error('Failed to start backend:', error);
this.isStarting = false;
throw error;
}
}
async waitForBackend() {
const maxWaitTime = 30000; // 30秒
const checkInterval = 500; // 每500ms检查一次
const startTime = Date.now();
while (Date.now() - startTime < maxWaitTime) {
try {
// 尝试连接后端健康检查端点
const response = await fetch(`http://127.0.0.1:${this.port}/health`);
if (response.ok) {
console.log('Backend is ready');
return;
}
} catch (error) {
// 继续等待
}
await new Promise(resolve => setTimeout(resolve, checkInterval));
}
throw new Error('Backend failed to start within timeout period');
}
startHealthCheck() {
if (this.healthCheckInterval) {
clearInterval(this.healthCheckInterval);
}
this.healthCheckInterval = setInterval(async () => {
if (!this.process) return;
try {
const response = await fetch(`http://127.0.0.1:${this.port}/health`);
if (!response.ok) {
console.error('Backend health check failed');
// 可以在这里触发重启逻辑
}
} catch (error) {
console.error('Backend health check error:', error);
}
}, 10000); // 每10秒检查一次
}
stop() {
return new Promise((resolve) => {
if (this.healthCheckInterval) {
clearInterval(this.healthCheckInterval);
this.healthCheckInterval = null;
}
if (!this.process) {
resolve();
return;
}
console.log('Stopping backend process...');
// 设置超时强制杀死
const killTimeout = setTimeout(() => {
if (this.process) {
console.log('Force killing backend process');
this.process.kill('SIGKILL');
}
}, 5000);
this.process.on('exit', () => {
clearTimeout(killTimeout);
this.process = null;
console.log('Backend process stopped');
resolve();
});
// 优雅关闭
this.process.kill('SIGTERM');
});
} catch (error) {
console.error('Failed to start backend:', error);
return null;
}
}
// 创建后端管理器实例
const backendManager = new BackendManager();
// 创建主窗口
// Create main window
function createWindow() {
mainWindow = new BrowserWindow({
width: 1200,
@@ -272,44 +70,51 @@ function createWindow() {
minWidth: 800,
minHeight: 600,
title: 'Termix',
icon: path.join(__dirname, '..', 'public', 'icon.png'),
icon: isDev
? path.join(__dirname, '..', 'public', 'icon.png')
: path.join(process.resourcesPath, 'public', 'icon.png'),
webPreferences: {
nodeIntegration: false,
contextIsolation: true,
preload: path.join(__dirname, 'preload.cjs'),
webSecurity: !isDev
},
show: false, // 先不显示，等加载完成
show: false
});
// 移除默认菜单栏（Windows/Linux）
// Remove menu bar on Windows/Linux
if (process.platform !== 'darwin') {
mainWindow.setMenuBarVisibility(false);
}
// 加载应用
// Load application
if (isDev) {
// 开发环境：连接到 Vite 开发服务器
mainWindow.loadURL('http://localhost:5173');
mainWindow.webContents.openDevTools();
} else {
// 生产环境：加载构建后的文件
mainWindow.loadFile(path.join(__dirname, '..', 'dist', 'index.html'));
// Load from dist folder
const indexPath = path.join(__dirname, '..', 'dist', 'index.html');
console.log('Loading frontend from:', indexPath);
mainWindow.loadFile(indexPath);
}
// 窗口准备好后显示
// Show window when ready
mainWindow.once('ready-to-show', () => {
console.log('Window ready to show');
mainWindow.show();
});
// 处理窗口关闭事件
// Handle load errors
mainWindow.webContents.on('did-fail-load', (event, errorCode, errorDescription, validatedURL) => {
console.error('Failed to load:', errorCode, errorDescription, validatedURL);
});
mainWindow.webContents.on('did-finish-load', () => {
console.log('Frontend loaded successfully');
});
// Handle window close
mainWindow.on('close', (event) => {
if (!isQuitting && process.platform === 'darwin') {
// macOS：隐藏窗口而不是退出
event.preventDefault();
mainWindow.hide();
} else if (!isQuitting && store.get('minimizeToTray', true)) {
// Windows/Linux：最小化到托盘
if (process.platform === 'darwin') {
event.preventDefault();
mainWindow.hide();
}
@@ -319,53 +124,14 @@ function createWindow() {
mainWindow = null;
});
// 处理外部链接
// Handle external links
mainWindow.webContents.setWindowOpenHandler(({ url }) => {
shell.openExternal(url);
return { action: 'deny' };
});
}
// 创建系统托盘
function createTray() {
if (process.platform === 'darwin') return; // macOS 不需要托盘
const iconPath = path.join(__dirname, '..', 'public', 'icon.png');
tray = new Tray(iconPath);
const contextMenu = Menu.buildFromTemplate([
{
label: '显示',
click: () => {
if (mainWindow) {
mainWindow.show();
mainWindow.focus();
}
}
},
{ type: 'separator' },
{
label: '退出',
click: () => {
isQuitting = true;
app.quit();
}
}
]);
tray.setToolTip('Termix');
tray.setContextMenu(contextMenu);
// 双击托盘图标显示窗口
tray.on('double-click', () => {
if (mainWindow) {
mainWindow.show();
mainWindow.focus();
}
});
}
// IPC 通信处理
// IPC handlers
ipcMain.handle('get-backend-port', () => {
return backendPort;
});
@@ -380,61 +146,29 @@ ipcMain.handle('get-platform', () => {
ipcMain.handle('restart-backend', async () => {
try {
await backendManager.stop();
await backendManager.start();
return { success: true, port: backendManager.port };
backendPort = await startBackend();
return { success: true, port: backendPort };
} catch (error) {
return { success: false, error: error.message };
}
});
ipcMain.handle('show-save-dialog', async (event, options) => {
const result = await dialog.showSaveDialog(mainWindow, options);
return result;
});
ipcMain.handle('show-open-dialog', async (event, options) => {
const result = await dialog.showOpenDialog(mainWindow, options);
return result;
});
// 自动更新
if (!isDev && autoUpdater) {
try {
autoUpdater.checkForUpdatesAndNotify();
autoUpdater.on('update-available', () => {
if (mainWindow) {
mainWindow.webContents.send('update-available');
}
});
autoUpdater.on('update-downloaded', () => {
if (mainWindow) {
mainWindow.webContents.send('update-downloaded');
}
});
} catch (error) {
console.log('Auto-updater not available:', error);
}
}
// 应用事件处理
// App event handlers
app.whenReady().then(async () => {
// Create window immediately for fast startup
createWindow();
// Start backend in background (non-blocking)
try {
// 启动后端
await backendManager.start();
// 创建窗口
createWindow();
// 创建托盘
createTray();
backendPort = await startBackend();
if (backendPort) {
console.log('Backend started successfully on port:', backendPort);
}
} catch (error) {
console.error('Failed to initialize application:', error);
dialog.showErrorBox('启动失败', `无法启动应用: ${error.message}`);
app.quit();
console.error('Backend failed to start:', error);
}
console.log('Termix started successfully');
});
app.on('window-all-closed', () => {
@@ -451,17 +185,15 @@ app.on('activate', () => {
}
});
app.on('before-quit', async () => {
isQuitting = true;
await backendManager.stop();
app.on('before-quit', () => {
console.log('App is quitting...');
});
// 处理未捕获的异常
// Error handling
process.on('uncaughtException', (error) => {
console.error('Uncaught Exception:', error);
dialog.showErrorBox('未捕获的异常', error.message);
});
process.on('unhandledRejection', (reason, promise) => {
console.error('Unhandled Rejection at:', promise, 'reason:', reason);
});
});
electron/preload-simple.cjs
-24
View File
@@ -1,24 +0,0 @@
const { contextBridge, ipcRenderer } = require('electron');
// 暴露简化的 API 给渲染进程
contextBridge.exposeInMainWorld('electronAPI', {
// 获取应用版本
getAppVersion: () => ipcRenderer.invoke('get-app-version'),
// 获取平台信息
getPlatform: () => ipcRenderer.invoke('get-platform'),
// 获取后端端口
getBackendPort: () => ipcRenderer.invoke('get-backend-port'),
// 重启后端服务
restartBackend: () => ipcRenderer.invoke('restart-backend'),
// 环境检测
isElectron: true,
isDev: process.env.NODE_ENV === 'development',
});
// 添加一个标识，让渲染进程知道这是 Electron 环境
// 在上下文隔离环境中，使用 contextBridge 暴露
contextBridge.exposeInMainWorld('IS_ELECTRON', true);
electron/preload.cjs
-54
View File
@@ -1,54 +0,0 @@
const { contextBridge, ipcRenderer } = require('electron');
// 暴露安全的 API 给渲染进程
contextBridge.exposeInMainWorld('electronAPI', {
// 获取后端端口
getBackendPort: () => ipcRenderer.invoke('get-backend-port'),
// 获取应用版本
getAppVersion: () => ipcRenderer.invoke('get-app-version'),
// 获取平台信息
getPlatform: () => ipcRenderer.invoke('get-platform'),
// 重启后端
restartBackend: () => ipcRenderer.invoke('restart-backend'),
// 文件对话框
showSaveDialog: (options) => ipcRenderer.invoke('show-save-dialog', options),
showOpenDialog: (options) => ipcRenderer.invoke('show-open-dialog', options),
// 监听后端事件
onBackendStarted: (callback) => {
ipcRenderer.on('backend-started', (event, data) => callback(data));
},
onBackendLog: (callback) => {
ipcRenderer.on('backend-log', (event, data) => callback(data));
},
onBackendError: (callback) => {
ipcRenderer.on('backend-error', (event, data) => callback(data));
},
// 监听更新事件
onUpdateAvailable: (callback) => {
ipcRenderer.on('update-available', () => callback());
},
onUpdateDownloaded: (callback) => {
ipcRenderer.on('update-downloaded', () => callback());
},
// 移除事件监听器
removeAllListeners: (channel) => {
ipcRenderer.removeAllListeners(channel);
},
// 环境检测
isElectron: true,
isDev: process.env.NODE_ENV === 'development',
});
// 添加一个标识，让渲染进程知道这是 Electron 环境
window.IS_ELECTRON = true;