nexfep 0.2.0 → 0.3.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 zhuxiaojt
+Copyright (c) 2026 Nexfteam
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README-CN.md

@@ -22,6 +22,10 @@ Nexfep 是一个基于 [@webviewjs/webview](https://github.com/webviewjs/webview
 - **IPC 通信** — 支持主进程与 WebView 之间的双向消息通信，通过注入的函数进行调用
 - **窗口控制** — 提供最大化、最小化、关闭、标题设置、开发者工具等完整窗口操作 API
 - **拖拽区域** — 内置 HTML 属性支持，方便定义窗口拖拽区域（`nexfep-area-drag` 等）
+- **系统托盘** — 创建和管理系统托盘图标及右键菜单
+- **桌面通知** — 通过 `app.utils.notify()` 发送桌面通知
+- **日志系统** — 内置 Logger，支持文件日志和彩色控制台输出，自动拦截页面 console 消息
+- **CLI 构建工具** — 通过 `nexfep build` 将应用打包为独立可执行文件
 - **TypeScript 支持** — 完整的类型定义，开发体验优秀
 
 ## 安装
@@ -46,26 +50,64 @@ await window.loadHTML('<h1 nexfep-area-drag>Hello Nexfep!</h1>');
 
 ### Application
 
-`Application` 是框架的主入口，负责管理应用生命周期，提供窗口和系统托盘的访问。
+`Application` 是框架的主入口，负责管理应用生命周期，提供窗口、系统托盘和日志的访问。
 
 ```typescript
 import { Application } from 'nexfep';
 
 const app = new Application();
-// 或指定自定义 WebView2 用户数据目录（仅 Windows）
-const app = new Application('C:\\custom\\webview2-data');
+// 或指定自定义 WebView2 用户数据目录（仅 Windows 生效）
+const app = new Application({ WindowsWebview2UserDataFolder: 'C:\\custom\\webview2-data' });
+// 或指定日志文件路径
+const app = new Application({ LogFilePath: './app.log' });
 ```
 
+**构造函数参数**
+
+| 选项 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `WindowsWebview2UserDataFolder` | `string`（可选） | `%LOCALAPPDATA%\NexfepDevelopment.webview2-data` | WebView2 用户数据目录（仅 Windows） |
+| `LogFilePath` | `string`（可选） | 无 | 日志文件输出路径 |
+
 **属性**
 
 - `windows` — `WindowPool` 实例，用于管理浏览器窗口
 - `utils` — 工具方法（如桌面通知）
+- `logger` — `Logger` 实例，用于日志记录
 
 **方法**
 
 - `createTray(options)` — 创建系统托盘图标和右键菜单
 - `exit()` — 退出应用
 
+### Logger
+
+Logger 支持文件输出和彩色控制台输出，可通过 `app.logger` 访问。
+
+```typescript
+app.logger.log('Hello World');
+app.logger.error('发生错误');
+app.logger.warn('警告信息');
+app.logger.info('提示信息');
+app.logger.debug('调试信息');
+```
+
+**方法**
+
+| 方法 | 说明 |
+|------|------|
+| `log(message)` | 记录日志 |
+| `error(message)` | 记录错误日志（红色） |
+| `warn(message)` | 记录警告日志（黄色） |
+| `info(message)` | 记录提示日志（蓝色） |
+| `debug(message)` | 记录调试日志（灰色） |
+
+每个方法接受字符串或字符串数组作为参数。
+
+**页面 Console 拦截**
+
+页面中的 `console.log`、`console.error`、`console.info`、`console.warn`、`console.debug` 调用会被自动拦截并转发到主进程 Logger，输出中包含来源窗口的 ID。
+
 ### 托盘图标
 
 通过 `app.createTray()` 创建和管理系统托盘图标及右键菜单。
@@ -141,11 +183,6 @@ const notification = app.utils.notify('标题', '通知内容');
 const pool = app.windows;
 ```
 
-**构造函数参数**
-
-- `app` — `Application` 实例
-- `WindowsWebview2UserDataFolder`（可选）— WebView2 用户数据目录，默认为 `%LOCALAPPDATA%\NexfepDevelopment.webview2-data`
-
 ### 窗口创建
 
 ```typescript
@@ -166,6 +203,7 @@ window.maximize();
 window.minimize();
 window.close();
 window.setTitle('新标题');
+window.setSize(800, 600);
 window.openDevTools();
 ```
 
@@ -271,9 +309,9 @@ const value = await window.getGlobal('hello');
 
 - `name` — 全局变量名称
 
-#### 全局变量Map
+#### 全局变量 Map
 
-在主进程中通过 `WindowPool.global` 获取一个包含所有全局变量的 `Map<string, any>` 对象，可对其进行设置、获取等操作：
+在主进程中通过 `pool.global` 获取一个包含所有全局变量的 `Map<string, any>` 对象，可对其进行设置、获取等操作：
 
 ```typescript
 const globals = pool.global;
@@ -424,40 +462,94 @@ if (window.isNexfepLoadDone) {
 }
 ```
 
+## CLI
+
+Nexfep 提供命令行工具，用于将应用打包为独立可执行文件。
+
+### 用法
+
+```bash
+npx nexfep build [options]
+```
+
+### 选项
+
+| 选项 | 说明 |
+|------|------|
+| `-n, --name <name>` | 应用名称（默认：来自 package.json） |
+| `-e, --entry <file>` | 入口文件路径（默认：来自 package.json main） |
+| `-o, --output <dir>` | 输出目录（默认：dist） |
+| `-i, --ignore <pattern>` | 要忽略的文件或目录（可多次使用） |
+| `-c, --console` | 在 Windows 上显示控制台窗口（默认：false） |
+| `-r, --reinstall` | 构建前仅重新安装生产依赖 |
+| `-s, --skip-clean` | 跳过清理旧的构建文件 |
+| `-u, --upx <level>` | 使用 UPX 压缩可执行文件，级别 0-9（默认：0） |
+
+### 示例
+
+```bash
+# 使用 package.json 默认配置构建
+nexfep build
+
+# 设置自定义应用名称和入口文件
+nexfep build -n my-app -e ./src/index.js
+
+# 设置自定义输出目录
+nexfep build -o ./build
+
+# 忽略多个模式
+nexfep build -i node_modules -i test -i temp
+
+# 使用 UPX 压缩构建
+nexfep build -u 7
+```
+
+该命令使用 [nexfpack](https://github.com/nexfteam/Nexfpack) 将应用打包为独立可执行文件。
+
 ## API
 
+### Application
+
+| 方法/属性 | 参数 | 返回值 | 说明 |
+|-----------|------|--------|------|
+| `constructor(options?)` | `{ WindowsWebview2UserDataFolder?, LogFilePath? }` | Application | 创建应用实例 |
+| `windows` | / | WindowPool | 窗口池实例 |
+| `utils` | / | \_\_Utils | 工具方法（通知） |
+| `logger` | / | Logger | 日志实例 |
+| `createTray(options)` | 见 Tray 章节 | Tray | 创建系统托盘图标 |
+| `exit()` | 无 | void | 退出应用 |
+
 ### WindowPool
 
-| 方法/属性                                 | 参数                                                          | 返回值              | 说明                         |
-| ------------------------------------- | ----------------------------------------------------------- | ---------------- | -------------------------- |
-| `constructor(userDataFolder?)`        | `userDataFolder`: string（可选）                                | WindowPool       | 创建窗口池，可选指定 WebView2 用户数据目录 |
-| `createWindow(isShow?, isDecorated?)` | `isShow`: boolean（默认 true）, `isDecorated`: boolean（默认 true） | Promise\<Window> | 创建并获取一个窗口                  |
-| `handle(event, callback)`             | `event`: string, `callback`: (data: string) => void | 无                | 监听指定事件，当收到事件时触发回调函数 |
-| `unhandle(event, callback)`                     | `event`: string, `callback`: (data: string) => void | 无                | 取消监听指定事件回调中的指定函数 |
-| `global`                              | /                                                                          | Map\<string, any> | 全局变量Map，类型为 `Map<string, any>`                         |
-| `closeWindow(window)`                 | `window`: Window                                            | Promise\<void>   | 关闭指定窗口并回收至池中               |
-| `onCustomMessage`                     | `(window: Window, data: string) => void`                    | 无                | 自定义消息回调函数，当收到页面发来的自定义消息时触发 |
+| 方法/属性 | 参数 | 返回值 | 说明 |
+|-----------|------|--------|------|
+| `createWindow(isShow?, isDecorated?)` | `isShow`: boolean（默认 true）, `isDecorated`: boolean（默认 true） | Promise\<Window> | 创建并获取一个窗口 |
+| `handle(event, callback)` | `event`: string, `callback`: (data: any) => any | 无 | 监听指定事件 |
+| `unhandle(event, callback)` | `event`: string, `callback`: (data: any) => any | 无 | 取消监听指定事件 |
+| `global` | / | Map\<string, any> | 全局变量 Map |
+| `closeWindow(window)` | `window`: Window | Promise\<void> | 关闭指定窗口并回收至池中 |
+| `onCustomMessage` | `(window: Window, data: string) => void` | 无 | 自定义消息回调函数 |
 
 ### Window
 
-| 方法/属性                       | 参数                                | 返回值            | 说明            |
-| --------------------------- | --------------------------------- | -------------- | ------------- |
-| `loadURL(url)`              | `url`: string — 要加载的网页地址          | Promise\<void> | 加载指定 URL      |
-| `loadHTML(html)`            | `html`: string — HTML 字符串         | Promise\<void> | 加载指定 HTML 内容  |
-| `show()`                    | 无                                 | void           | 显示窗口          |
-| `hide()`                    | 无                                 | void           | 隐藏窗口          |
-| `maximize()`                | 无                                 | void           | 最大化窗口         |
-| `unMaximize()`              | 无                                 | void           | 还原窗口（取消最大化）   |
-| `minimize()`                | 无                                 | void           | 最小化窗口         |
-| `unMinimize()`              | 无                                 | void           | 还原窗口（取消最小化）   |
-| `close()`                   | 无                                 | void           | 关闭窗口并回收至池中    |
-| `setTitle(title)`           | `title`: string — 窗口标题            | void           | 设置窗口标题        |
-| `setDecorated(isDecorated)` | `isDecorated`: boolean — 是否使用系统装饰 | void           | 设置窗口是否带边框和标题栏 |
-| `resizable(resizable)`      | `resizable`: boolean — 是否可调整大小    | void           | 设置窗口是否可调整大小   |
-| `setSize(width, height)`    | `width`: number, `height`: number  | void           | 设置窗口尺寸（像素）   |
-| `openDevTools()`            | 无                                 | void           | 打开开发者工具       |
-| `closeDevTools()`           | 无                                 | void           | 关闭开发者工具       |
-| `id`                        | 无                                 | number         | 窗口唯一标识，自增编号   |
+| 方法/属性 | 参数 | 返回值 | 说明 |
+|-----------|------|--------|------|
+| `loadURL(url)` | `url`: string — 要加载的网页地址 | Promise\<void> | 加载指定 URL |
+| `loadHTML(html)` | `html`: string — HTML 字符串 | Promise\<void> | 加载指定 HTML 内容 |
+| `show()` | 无 | void | 显示窗口 |
+| `hide()` | 无 | void | 隐藏窗口 |
+| `maximize()` | 无 | void | 最大化窗口 |
+| `unMaximize()` | 无 | void | 还原窗口（取消最大化） |
+| `minimize()` | 无 | void | 最小化窗口 |
+| `unMinimize()` | 无 | void | 还原窗口（取消最小化） |
+| `close()` | 无 | void | 关闭窗口并回收至池中 |
+| `setTitle(title)` | `title`: string | void | 设置窗口标题 |
+| `setDecorated(isDecorated)` | `isDecorated`: boolean | void | 设置窗口是否带边框和标题栏 |
+| `resizable(resizable)` | `resizable`: boolean | void | 设置窗口是否可调整大小 |
+| `setSize(width, height)` | `width`: number, `height`: number | void | 设置窗口尺寸（像素） |
+| `openDevTools()` | 无 | void | 打开开发者工具 |
+| `closeDevTools()` | 无 | void | 关闭开发者工具 |
+| `id` | 无 | number | 窗口唯一标识，自增编号 |
 
 ## 开发
 

package/README.md

@@ -22,6 +22,10 @@ The framework uses a window pool management mechanism, supporting multi-window a
 - **IPC Communication** — Supports bidirectional message communication between the main process and WebView, via injected functions
 - **Window Control** — Provides complete window operation APIs including maximize, minimize, close, title setting, and developer tools
 - **Drag Regions** — Built-in HTML attribute support for defining window drag regions (`nexfep-area-drag`, etc.)
+- **System Tray** — Create and manage system tray icons with context menus
+- **Desktop Notifications** — Send desktop notifications via `app.utils.notify()`
+- **Logging System** — Built-in logger with file output and colored console support, with automatic interception of page console messages
+- **CLI Build Tool** — Package your application into a standalone executable via `nexfep build`
 - **TypeScript Support** — Complete type definitions for excellent development experience
 
 ## Installation
@@ -46,26 +50,64 @@ await window.loadHTML('<h1 nexfep-area-drag>Hello Nexfep!</h1>');
 
 ### Application
 
-`Application` is the main entry point of the framework, responsible for managing the application lifecycle and providing access to windows and system tray.
+`Application` is the main entry point of the framework, responsible for managing the application lifecycle and providing access to windows, system tray, and logger.
 
 ```typescript
 import { Application } from 'nexfep';
 
 const app = new Application();
 // or with custom WebView2 user data directory (Windows only)
-const app = new Application('C:\\custom\\webview2-data');
+const app = new Application({ WindowsWebview2UserDataFolder: 'C:\\custom\\webview2-data' });
+// or with log file path
+const app = new Application({ LogFilePath: './app.log' });
 ```
 
+**Constructor Options**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `WindowsWebview2UserDataFolder` | `string` (optional) | `%LOCALAPPDATA%\NexfepDevelopment.webview2-data` | WebView2 user data directory (Windows only) |
+| `LogFilePath` | `string` (optional) | none | File path for log output |
+
 **Properties**
 
 - `windows` — The `WindowPool` instance for managing browser windows
 - `utils` — Utility methods (e.g., desktop notifications)
+- `logger` — The `Logger` instance for logging
 
 **Methods**
 
 - `createTray(options)` — Create a system tray icon with context menu
 - `exit()` — Exit the application
 
+### Logger
+
+The logger supports both file output and colored console output. It can be accessed via `app.logger`.
+
+```typescript
+app.logger.log('Hello World');
+app.logger.error('An error occurred');
+app.logger.warn('Warning message');
+app.logger.info('Info message');
+app.logger.debug('Debug message');
+```
+
+**Methods**
+
+| Method | Description |
+|--------|-------------|
+| `log(message)` | Log a message |
+| `error(message)` | Log an error message (red) |
+| `warn(message)` | Log a warning message (yellow) |
+| `info(message)` | Log an info message (blue) |
+| `debug(message)` | Log a debug message (gray) |
+
+Each method accepts either a string or an array of strings.
+
+**Page Console Interception**
+
+Console calls (`console.log`, `console.error`, `console.info`, `console.warn`, `console.debug`) in the page are automatically intercepted and forwarded to the main process logger, with the source window ID included in the output.
+
 ### Tray
 
 Create and manage system tray icons with context menus via `app.createTray()`.
@@ -141,11 +183,6 @@ const notification = app.utils.notify('Title', 'Notification body');
 const pool = app.windows;
 ```
 
-**Constructor Parameters**
-
-- `app` — The `Application` instance
-- `WindowsWebview2UserDataFolder` (optional) — WebView2 user data directory, defaults to `%LOCALAPPDATA%\NexfepDevelopment.webview2-data`
-
 ### Window Creation
 
 ```typescript
@@ -166,6 +203,7 @@ window.maximize();
 window.minimize();
 window.close();
 window.setTitle('New Title');
+window.setSize(800, 600);
 window.openDevTools();
 ```
 
@@ -273,7 +311,7 @@ const value = await window.getGlobal('hello');
 
 #### Global Variable Map
 
-Get a `Map<string, any>` containing all global variables via `WindowPool.global` in the main process, which supports operations like set and get:
+Get a `Map<string, any>` containing all global variables via `pool.global` in the main process, which supports operations like set and get:
 
 ```typescript
 const globals = pool.global;
@@ -424,40 +462,94 @@ if (window.isNexfepLoadDone) {
 }
 ```
 
+## CLI
+
+Nexfep provides a command-line tool for building applications into standalone executables.
+
+### Usage
+
+```bash
+npx nexfep build [options]
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `-n, --name <name>` | Application name (default: from package.json) |
+| `-e, --entry <file>` | Entry file path (default: from package.json main) |
+| `-o, --output <dir>` | Output directory (default: dist) |
+| `-i, --ignore <pattern>` | Files or directories to ignore (can be used multiple times) |
+| `-c, --console` | Show console window on Windows (default: false) |
+| `-r, --reinstall` | Reinstall production dependencies only before building |
+| `-s, --skip-clean` | Skip cleaning old build files before building |
+| `-u, --upx <level>` | Use UPX to compress the executable, level 0-9 (default: 0) |
+
+### Examples
+
+```bash
+# Build using defaults from package.json
+nexfep build
+
+# Set custom application name and entry file
+nexfep build -n my-app -e ./src/index.js
+
+# Set custom output directory
+nexfep build -o ./build
+
+# Ignore multiple patterns
+nexfep build -i node_modules -i test -i temp
+
+# Build with UPX compression
+nexfep build -u 7
+```
+
+This command uses [nexfpack](https://github.com/nexfteam/Nexfpack) to package your application into a standalone executable.
+
 ## API
 
+### Application
+
+| Method/Property | Parameters | Return Value | Description |
+|----------------|-----------|--------------|-------------|
+| `constructor(options?)` | `{ WindowsWebview2UserDataFolder?, LogFilePath? }` | Application | Creates the application instance |
+| `windows` | / | WindowPool | The window pool instance |
+| `utils` | / | \_\_Utils | Utility methods (notifications) |
+| `logger` | / | Logger | The logger instance |
+| `createTray(options)` | see Tray section | Tray | Creates a system tray icon |
+| `exit()` | None | void | Exits the application |
+
 ### WindowPool
 
-| Method/Property                       | Parameters                                                                 | Return Value     | Description                                                              |
-| ------------------------------------- | -------------------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------ |
-| `constructor(userDataFolder?)`        | `userDataFolder`: string (optional)                                        | WindowPool       | Creates a window pool, optionally specifying the WebView2 user data directory |
-| `createWindow(isShow?, isDecorated?)` | `isShow`: boolean (default true), `isDecorated`: boolean (default true)    | Promise\<Window> | Creates and returns a window                                             |
-| `handle(event, callback)`             | `event`: string, `callback`: (data: string) => void                        | None             | Listens for the specified event, triggers callback when event is received |
-| `unhandle(event, callback)`           | `event`: string, `callback`: (data: string) => void                        | None             | Removes the specified callback from the event listener                     |
-| `global`                              | /                                                                          | Map\<string, any> | A global variable map of type: `Map<string, any>`                         |
-| `closeWindow(window)`                 | `window`: Window                                                           | Promise\<void>   | Closes the specified window and returns it to the pool                   |
-| `onCustomMessage`                     | `(window: Window, data: string) => void`                                   | None             | Custom message callback, triggered when receiving custom messages from pages |
+| Method/Property | Parameters | Return Value | Description |
+|----------------|-----------|--------------|-------------|
+| `createWindow(isShow?, isDecorated?)` | `isShow`: boolean (default true), `isDecorated`: boolean (default true) | Promise\<Window> | Creates and returns a window |
+| `handle(event, callback)` | `event`: string, `callback`: (data: any) => any | None | Listens for the specified event |
+| `unhandle(event, callback)` | `event`: string, `callback`: (data: any) => any | None | Removes the specified event listener |
+| `global` | / | Map\<string, any> | A global variable map |
+| `closeWindow(window)` | `window`: Window | Promise\<void> | Closes the specified window and returns it to the pool |
+| `onCustomMessage` | `(window: Window, data: string) => void` | None | Custom message callback |
 
 ### Window
 
-| Method/Property                       | Parameters                                  | Return Value     | Description                              |
-| ------------------------------------- | ------------------------------------------- | ---------------- | ---------------------------------------- |
-| `loadURL(url)`                        | `url`: string — URL to load                 | Promise\<void>   | Loads the specified URL                 |
-| `loadHTML(html)`                      | `html`: string — HTML string                | Promise\<void>   | Loads the specified HTML content        |
-| `show()`                              | None                                        | void             | Shows the window                         |
-| `hide()`                              | None                                        | void             | Hides the window                         |
-| `maximize()`                          | None                                        | void             | Maximizes the window                     |
-| `unMaximize()`                        | None                                        | void             | Restores the window (cancels maximize)   |
-| `minimize()`                          | None                                        | void             | Minimizes the window                     |
-| `unMinimize()`                        | None                                        | void             | Restores the window (cancels minimize)   |
-| `close()`                             | None                                        | void             | Closes the window and returns to pool    |
-| `setTitle(title)`                     | `title`: string — Window title              | void             | Sets the window title                   |
-| `setDecorated(isDecorated)`           | `isDecorated`: boolean — Use system decorations | void          | Sets whether the window has borders and title bar |
-| `resizable(resizable)`                | `resizable`: boolean — Resizable            | void             | Sets whether the window is resizable     |
-| `setSize(width, height)`              | `width`: number, `height`: number           | void             | Sets the window size in pixels           |
-| `openDevTools()`                      | None                                        | void             | Opens developer tools                   |
-| `closeDevTools()`                     | None                                        | void             | Closes developer tools                  |
-| `id`                                  | None                                        | number           | Unique window identifier, auto-incrementing |
+| Method/Property | Parameters | Return Value | Description |
+|----------------|-----------|--------------|-------------|
+| `loadURL(url)` | `url`: string — URL to load | Promise\<void> | Loads the specified URL |
+| `loadHTML(html)` | `html`: string — HTML string | Promise\<void> | Loads the specified HTML content |
+| `show()` | None | void | Shows the window |
+| `hide()` | None | void | Hides the window |
+| `maximize()` | None | void | Maximizes the window |
+| `unMaximize()` | None | void | Restores the window (cancels maximize) |
+| `minimize()` | None | void | Minimizes the window |
+| `unMinimize()` | None | void | Restores the window (cancels minimize) |
+| `close()` | None | void | Closes the window and returns to pool |
+| `setTitle(title)` | `title`: string | void | Sets the window title |
+| `setDecorated(isDecorated)` | `isDecorated`: boolean | void | Sets whether the window has borders and title bar |
+| `resizable(resizable)` | `resizable`: boolean | void | Sets whether the window is resizable |
+| `setSize(width, height)` | `width`: number, `height`: number | void | Sets the window size in pixels |
+| `openDevTools()` | None | void | Opens developer tools |
+| `closeDevTools()` | None | void | Closes developer tools |
+| `id` | None | number | Unique window identifier, auto-incrementing |
 
 ## Development
 
@@ -468,4 +560,4 @@ pnpm run compile
 
 ## License
 
-MIT License
+MIT License

package/cli/index.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import build from './build.mjs';
+import help from './help.mjs';
+const args = process.argv.slice(2);
+if(args.length === 0) {
+    help();
+    process.exit(1);
+}
+if(args[0] === 'help') {
+    if(args.length > 1) {
+        help(args[1]);
+    } else {
+        help();
+    }
+}
+if(args[0] === 'build') {
+    build(args.slice(1));
+}

package/package.json

@@ -6,6 +6,9 @@
   "bugs": {
     "url": "https://github.com/nexfteam/Nexfep/issues"
   },
+  "bin": {
+    "nexfep": "cli/index.mjs"
+  },
   "keywords": [
     "desktop",
     "application",
@@ -14,7 +17,7 @@
     "webview",
     "typescript"
   ],
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "./index.js",
   "scripts": {

package/src/Application.d.ts

@@ -1,6 +1,7 @@
 import { Application as WebviewApplication, TrayIconImage, Notification } from '@webviewjs/webview';
 import { WindowPool } from './WindowManager.js';
 import { Tray } from './Tray.js';
+import { Logger } from './Logger.js';
 declare class __Utils {
     app: WebviewApplication;
     constructor(app: WebviewApplication);
@@ -9,8 +10,12 @@ declare class __Utils {
 declare class Application {
     app: WebviewApplication;
     windows: WindowPool;
+    logger: Logger;
     utils: __Utils;
-    constructor(WindowsWebview2UserDataFolder?: string);
+    constructor(options: {
+        WindowsWebview2UserDataFolder?: string;
+        LogFilePath?: string;
+    });
     createTray(options: {
         id: string;
         tooltip: string;

package/src/Application.js

@@ -1,8 +1,7 @@
 import { Application as WebviewApplication, Notification } from '@webviewjs/webview';
 import { WindowPool } from './WindowManager.js';
 import { Tray } from './Tray.js';
-import path from 'path';
-import os from 'os';
+import { Logger } from './Logger.js';
 class __Utils {
     app;
     constructor(app) {
@@ -16,11 +15,14 @@ class __Utils {
 class Application {
     app;
     windows;
+    logger;
     utils;
-    constructor(WindowsWebview2UserDataFolder = path.join(process.env.LOCALAPPDATA || os.homedir(), 'NexfepDevelopment.webview2-data')) {
+    constructor(options) {
         this.app = new WebviewApplication();
         this.utils = new __Utils(this.app);
-        this.windows = new WindowPool(this.app, WindowsWebview2UserDataFolder);
+        this.logger = new Logger(options.LogFilePath);
+        const poolOptions = { WindowsWebview2UserDataFolder: options.WindowsWebview2UserDataFolder, logger: this.logger };
+        this.windows = new WindowPool(this.app, poolOptions);
         this.app.whenReady();
     }
     createTray(options) {

package/src/WindowManager.d.ts

@@ -1,4 +1,5 @@
 import { Application, BrowserWindow, Webview } from "@webviewjs/webview";
+import { Logger } from "./Logger.js";
 declare class Window {
     window: BrowserWindow;
     webview: Webview;
@@ -27,13 +28,17 @@ declare class Window {
 declare class WindowPool {
     onCustomMessage: (window: Window, data: string) => void;
     app: Application;
+    logger: Logger;
     private windows;
     private handlers;
     private injectCount;
     private windowCount;
     private freeWindowCount;
     global: Map<string, any>;
-    constructor(app: Application, WindowsWebview2UserDataFolder?: string);
+    constructor(app: Application, options: {
+        WindowsWebview2UserDataFolder?: string;
+        logger?: Logger;
+    });
     __injectCode(window: Window, code: string): Promise<void>;
     __injectControlFunctions(windowObj: Window): Promise<void>;
     __createNewWindowObj(): Promise<Window>;

package/src/WindowManager.js

@@ -1,3 +1,4 @@
+import { Logger } from "./Logger.js";
 import os from 'os';
 import path from 'path';
 import fs from 'fs';
@@ -72,16 +73,17 @@ class Window {
 class WindowPool {
     onCustomMessage;
     app;
+    logger;
     windows;
     handlers;
     injectCount;
     windowCount;
     freeWindowCount;
     global;
-    constructor(app, WindowsWebview2UserDataFolder = path.join(process.env.LOCALAPPDATA || os.homedir(), 'NexfepDevelopment.webview2-data')) {
+    constructor(app, options) {
         if (os.platform() === 'win32') {
             // 设置 WebView2 用户数据目录（仅 Windows 需要此配置）
-            const userDataDir = WindowsWebview2UserDataFolder;
+            const userDataDir = options.WindowsWebview2UserDataFolder || path.join(process.env.LOCALAPPDATA || os.homedir(), 'NexfepDevelopment.webview2-data');
             if (!fs.existsSync(userDataDir)) {
                 fs.mkdirSync(userDataDir, { recursive: true });
             }
@@ -97,6 +99,7 @@ class WindowPool {
         this.windowCount = 0;
         this.freeWindowCount = 0;
         this.global = new Map();
+        this.logger = options.logger || new Logger();
     }
     async __injectCode(window, code) {
         await window.webview.evaluateScript(code);
@@ -235,6 +238,37 @@ class WindowPool {
             const MessageBody = { type: 'NexfepTell', to: to, message: message, data: data }
             window.ipc.postMessage(JSON.stringify(MessageBody));
         }
+
+        window.__originConsoleLog = console.log;
+        window.__originConsoleError = console.error;
+        window.__originConsoleInfo = console.info;
+        window.__originConsoleWarn = console.warn;
+        window.__originConsoleDebug = console.debug;
+        console.log = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleLog', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleLog(...args);
+        }
+        console.error = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleError', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleError(...args);
+        }
+        console.info = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleInfo', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleInfo(...args);
+        }
+        console.warn = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleWarn', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleWarn(...args);
+        }
+        console.debug = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleDebug', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleDebug(...args);
+        }
         
         // 注入 CSS 样式
         const style = document.createElement('style');
@@ -250,99 +284,118 @@ class WindowPool {
         await this.__injectCode(windowObj, INJECT_CODE);
     }
     async __createNewWindowObj() {
-        const window = this.app.createBrowserWindow({ title: "Nexfep" });
-        window.hide();
-        this.freeWindowCount++;
-        const webview = window.createWebview();
-        const windowObj = new Window(window, webview, ++this.windowCount, this);
-        this.windows.push(windowObj);
-        webview.onIpcMessage((data) => {
-            const dataText = data.body.toString();
-            const dataObj = JSON.parse(dataText);
-            if (dataObj.type == 'NexfepBeforeUnload') {
-                webview.evaluateScript(`if(window?.isNexfepLoadDone){
-                    const MessageBody = { type: 'NexfepBeforeUnload' }
-                    window.ipc.postMessage(JSON.stringify(MessageBody));
-                }else{
-                    const MessageBody = { type: 'NexfepLoadFalse' }
-                    window.ipc.postMessage(JSON.stringify(MessageBody));
-                }`);
-            }
-            else if (dataObj.type == 'NexfepLoadFalse') {
-                this.__injectControlFunctions(windowObj);
-            }
-            else if (dataObj.type == 'NexfepCloseWindow') {
-                this.closeWindow(windowObj);
-            }
-            else if (dataObj.type == 'NexfepMinimizeWindow') {
-                window.setMinimized(true);
-            }
-            else if (dataObj.type == 'NexfepUnMinimizeWindow') {
-                window.setMinimized(false);
-            }
-            else if (dataObj.type == 'NexfepMaximizeWindow') {
-                window.setMaximized(true);
-            }
-            else if (dataObj.type == 'NexfepUnMaximizeWindow') {
-                window.setMaximized(false);
-            }
-            else if (dataObj.type == 'NexfepSetTitle') {
-                window.setTitle(dataObj.title);
-            }
-            else if (dataObj.type == 'NexfepOpenDevTools') {
-                webview.openDevtools();
-            }
-            else if (dataObj.type == 'NexfepCloseDevTools') {
-                webview.closeDevtools();
-            }
-            else if (dataObj.type == 'CustomMessage') {
-                this.onCustomMessage(windowObj, dataObj.data);
-            }
-            else if (dataObj.type == 'NexfepInvoke') {
-                const handlers = this.handlers.get(dataObj.event) || [];
-                handlers.forEach(async (handler) => {
-                    const result = await handler(dataObj.data);
-                    if (result) {
-                        webview.evaluateScript(`
-                            window.dispatchEvent(new CustomEvent('nexfep-invoke-result-${dataObj.eventId[0]}-${dataObj.eventId[1]}', { detail: ${JSON.stringify(result)} }));
-                        `);
+        return await new Promise((resolve, reject) => {
+            setImmediate(() => {
+                const window = this.app.createBrowserWindow({ title: "Nexfep" });
+                window.hide();
+                this.freeWindowCount++;
+                const webview = window.createWebview();
+                const windowObj = new Window(window, webview, ++this.windowCount, this);
+                this.windows.push(windowObj);
+                webview.onIpcMessage((data) => {
+                    const dataText = data.body.toString();
+                    const dataObj = JSON.parse(dataText);
+                    if (dataObj.type == 'NexfepBeforeUnload') {
+                        webview.evaluateScript(`if(window?.isNexfepLoadDone){
+                            const MessageBody = { type: 'NexfepBeforeUnload' }
+                            window.ipc.postMessage(JSON.stringify(MessageBody));
+                        }else{
+                            const MessageBody = { type: 'NexfepLoadFalse' }
+                            window.ipc.postMessage(JSON.stringify(MessageBody));
+                        }`);
+                    }
+                    else if (dataObj.type == 'NexfepLoadFalse') {
+                        this.__injectControlFunctions(windowObj);
+                    }
+                    else if (dataObj.type == 'NexfepCloseWindow') {
+                        this.closeWindow(windowObj);
                     }
-                    else {
+                    else if (dataObj.type == 'NexfepMinimizeWindow') {
+                        window.setMinimized(true);
+                    }
+                    else if (dataObj.type == 'NexfepUnMinimizeWindow') {
+                        window.setMinimized(false);
+                    }
+                    else if (dataObj.type == 'NexfepMaximizeWindow') {
+                        window.setMaximized(true);
+                    }
+                    else if (dataObj.type == 'NexfepUnMaximizeWindow') {
+                        window.setMaximized(false);
+                    }
+                    else if (dataObj.type == 'NexfepSetTitle') {
+                        window.setTitle(dataObj.title);
+                    }
+                    else if (dataObj.type == 'NexfepOpenDevTools') {
+                        webview.openDevtools();
+                    }
+                    else if (dataObj.type == 'NexfepCloseDevTools') {
+                        webview.closeDevtools();
+                    }
+                    else if (dataObj.type == 'CustomMessage') {
+                        this.onCustomMessage(windowObj, dataObj.data);
+                    }
+                    else if (dataObj.type == 'NexfepInvoke') {
+                        const handlers = this.handlers.get(dataObj.event) || [];
+                        handlers.forEach(async (handler) => {
+                            const result = await handler(dataObj.data);
+                            if (result) {
+                                webview.evaluateScript(`
+                                    window.dispatchEvent(new CustomEvent('nexfep-invoke-result-${dataObj.eventId[0]}-${dataObj.eventId[1]}', { detail: ${JSON.stringify(result)} }));
+                                `);
+                            }
+                            else {
+                                webview.evaluateScript(`
+                                    window.dispatchEvent(new CustomEvent('nexfep-invoke-result-${dataObj.eventId[0]}-${dataObj.eventId[1]}', { detail: undefined }));
+                                `);
+                            }
+                        });
+                    }
+                    else if (dataObj.type == 'NexfepSetGlobal') {
+                        this.global.set(dataObj.name, dataObj.value);
+                    }
+                    else if (dataObj.type == 'NexfepGetGlobal') {
+                        const value = this.global.get(dataObj.name);
                         webview.evaluateScript(`
-                            window.dispatchEvent(new CustomEvent('nexfep-invoke-result-${dataObj.eventId[0]}-${dataObj.eventId[1]}', { detail: undefined }));
+                            window.dispatchEvent(new CustomEvent('nexfep-get-global-result-${dataObj.eventId[0]}-${dataObj.eventId[1]}', { detail: ${JSON.stringify(value)} }));
                         `);
                     }
-                });
-            }
-            else if (dataObj.type == 'NexfepSetGlobal') {
-                this.global.set(dataObj.name, dataObj.value);
-            }
-            else if (dataObj.type == 'NexfepGetGlobal') {
-                const value = this.global.get(dataObj.name);
-                webview.evaluateScript(`
-                    window.dispatchEvent(new CustomEvent('nexfep-get-global-result-${dataObj.eventId[0]}-${dataObj.eventId[1]}', { detail: ${JSON.stringify(value)} }));
-                `);
-            }
-            else if (dataObj.type == 'NexfepBroadcast') {
-                this.windows.forEach(async (w) => {
-                    if (w != windowObj && w.isOpen) {
-                        w.webview.evaluateScript(`
-                            window.dispatchEvent(new CustomEvent('${dataObj.name}', { detail: ${JSON.stringify(dataObj.data)} }));
-                        `);
+                    else if (dataObj.type == 'NexfepBroadcast') {
+                        this.windows.forEach(async (w) => {
+                            if (w != windowObj && w.isOpen) {
+                                w.webview.evaluateScript(`
+                                    window.dispatchEvent(new CustomEvent('${dataObj.name}', { detail: ${JSON.stringify(dataObj.data)} }));
+                                `);
+                            }
+                        });
                     }
-                });
-            }
-            else if (dataObj.type == 'NexfepTell') {
-                this.windows.forEach(async (w) => {
-                    if (w.id == dataObj.to) {
-                        w.webview.evaluateScript(`
-                            window.dispatchEvent(new CustomEvent('${dataObj.message}', { detail: ${JSON.stringify(dataObj.data)} }));
-                        `);
+                    else if (dataObj.type == 'NexfepTell') {
+                        this.windows.forEach(async (w) => {
+                            if (w.id == dataObj.to) {
+                                w.webview.evaluateScript(`
+                                    window.dispatchEvent(new CustomEvent('${dataObj.message}', { detail: ${JSON.stringify(dataObj.data)} }));
+                                `);
+                            }
+                        });
+                    }
+                    else if (dataObj.type == 'NexfepConsoleLog') {
+                        this.logger.__printLog(windowObj.id, 'Log', dataObj.message);
+                    }
+                    else if (dataObj.type == 'NexfepConsoleError') {
+                        this.logger.__printLog(windowObj.id, 'Error', dataObj.message, '\x1b[31m', '\x1b[0m');
+                    }
+                    else if (dataObj.type == 'NexfepConsoleInfo') {
+                        this.logger.__printLog(windowObj.id, 'Info', dataObj.message, '\x1b[34m', '\x1b[0m');
+                    }
+                    else if (dataObj.type == 'NexfepConsoleWarn') {
+                        this.logger.__printLog(windowObj.id, 'Warn', dataObj.message, '\x1b[33m', '\x1b[0m');
+                    }
+                    else if (dataObj.type == 'NexfepConsoleDebug') {
+                        this.logger.__printLog(windowObj.id, 'Debug', dataObj.message, '\x1b[90m', '\x1b[0m');
                     }
                 });
-            }
+                resolve(windowObj);
+            });
         });
-        return windowObj;
     }
     async createWindow(isShow = true, isDecorated = true) {
         const window = this.windows.find(w => w.isOpen === false) || await this.__createNewWindowObj();
@@ -356,7 +409,7 @@ class WindowPool {
             }
         }
         if (this.freeWindowCount == 0) {
-            await this.__createNewWindowObj();
+            this.__createNewWindowObj();
         }
         return window;
     }