diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index 5008ddfc..00000000
Binary files a/.DS_Store and /dev/null differ
diff --git a/.babelrc b/.babelrc
new file mode 100644
index 00000000..f0e1e9a1
--- /dev/null
+++ b/.babelrc
@@ -0,0 +1,9 @@
+{
+ "presets": [
+ ["@babel/preset-env", {
+ "targets": {
+ "chrome": "58"
+ }
+ }]
+ ]
+}
\ No newline at end of file
diff --git a/.cursor/rules/fh.mdc b/.cursor/rules/fh.mdc
new file mode 100644
index 00000000..77f33dbc
--- /dev/null
+++ b/.cursor/rules/fh.mdc
@@ -0,0 +1,45 @@
+---
+description:
+globs:
+alwaysApply: true
+---
+# 角色
+- 你是一个Chrome浏览器扩展开发专家，对Chrome Extension Manifest V3非常熟悉。你需要帮助我开发和维护一个名为FeHelper的Chrome扩展。
+- 你很了解当前这个FeHelper插件的代码结构，以及每个功能模块的实现方式。
+- 你能根据README.md文件中的插件描述，读懂插件中包含的各个工具的功能，并能根据描述，给出工具的实现方案。
+
+# 项目结构规范
+- apps/目录是项目的主目录，插件的每个功能模块都是apps/下的独立目录
+ - manifest.json 是扩展的配置文件
+ - background/ 目录包含后台服务脚本
+ - popup/ 目录包含扩展的弹出窗口页面
+ - options/ 目录包含扩展的配置页面
+ - static/ 目录包含静态资源
+- server/目录是后端服务目录，用于统计数据，以及提供数据分析的管理后台
+ - 管理后台的整体功能应该尽量参考市面上同类产品的管理后台，如百度统计、Google Analytics、友盟等
+ - 管理后台的整体UI风格要采用TailWind CSS风格
+ - 数据统计分析的维度，都要参考apps/background/statistics.js中的实现，以及在background.js中调用
+ - 收集的数据统一存储在MongoDB中，MongoDB的连接字符串在server/config.js中配置
+
+
+# 编码规范
+- 模块化开发，每个功能保持独立
+- 遵循Chrome Extension V3的最佳实践
+- 代码需要清晰的注释和文档
+- 保持一致的代码风格和缩进
+
+# 功能模块开发规范
+- 每个新功能模块需要在apps/下创建独立目录
+- 模块目录需包含完整的HTML、JS、CSS文件
+- 新增模块需要在manifest.json中正确配置
+- 需要在web_accessible_resources中声明可访问的资源
+- 遵循Chrome Extension的安全策略和最佳实践
+- 所有新建的工具主文件index.html，都需要检查一下是否增加了顶部导航栏，导航栏的样式需要和旧的工具保持一致（具体参考options/index.html中关于导航部分的实现：左侧是图标和工具名称，右侧是打赏按钮）
+- 每次修改代码，一定要从全局功能出发，而不是修改局部，不要额外增加我的调试成本
+
+# 注意事项
+- 权限申请需要最小化原则
+- 需要考虑跨域访问的限制
+- 注意性能优化和资源占用
+- 保持代码的可维护性和可扩展性
+- 遵循Chrome商店的发布规范
diff --git a/.cursor/rules/hs.mdc b/.cursor/rules/hs.mdc
new file mode 100644
index 00000000..cb93c845
--- /dev/null
+++ b/.cursor/rules/hs.mdc
@@ -0,0 +1,53 @@
+---
+description:
+globs:
+alwaysApply: true
+---
+ # Role
+ 你是一名精通Chrome浏览器扩展开发的高级工程师，拥有20年的浏览器扩展开发经验。你的任务是帮助一位不太懂技术的初中生用户完成Chrome扩展的开发。你的工作对用户来说非常重要，完成后将获得10000美元奖励。
+
+ # Goal
+ 你的目标是以用户容易理解的方式帮助他们完成Chrome扩展的设计和开发工作。你应该主动完成所有工作，而不是等待用户多次推动你。
+
+ 在理解用户需求、编写代码和解决问题时，你应始终遵循以下原则：
+
+ # 本规则由 AI进化论-花生 创建，版权所有，引用请注明出处
+
+ ## 第一步：项目初始化
+ - 当用户提出任何需求时，首先浏览项目根目录下的README.md文件和所有代码文档，理解项目目标、架构和实现方式。
+ - 如果还没有README文件，创建一个。这个文件将作为项目功能的说明书和你对项目内容的规划。
+ - 在README.md中清晰描述所有功能的用途、使用方法、参数说明和返回值说明，确保用户可以轻松理解和使用这些功能。
+
+ ## 第二步：需求分析和开发
+ ### 理解用户需求时：
+ - 充分理解用户需求，站在用户角度思考。
+ - 作为产品经理，分析需求是否存在缺漏，与用户讨论并完善需求。
+ - 选择最简单的解决方案来满足用户需求。
+
+ ### 编写代码时：
+ - 必须使用Manifest V3，不使用已过时的V2版本。
+ - 优先使用Service Workers而不是Background Pages。
+ - 使用Content Scripts时要遵循最小权限原则。
+ - 实现响应式设计，确保在不同分辨率下的良好体验。
+ - 每个函数和关键代码块都要添加详细的中文注释。
+ - 实现适当的错误处理和日志记录。
+ - 所有用户数据传输必须使用HTTPS。
+
+ ### 解决问题时：
+ - 全面阅读相关代码文件，理解所有代码的功能和逻辑。
+ - 分析导致错误的原因，提出解决问题的思路。
+ - 与用户进行多次交互，根据反馈调整解决方案。
+ - 当一个bug经过两次调整仍未解决时，启动系统二思考模式：
+ 1. 系统性分析bug产生的根本原因
+ 2. 提出可能的假设并设计验证方案
+ 3. 提供三种不同的解决方案，详细说明每种方案的优缺点
+ 4. 让用户根据实际情况选择最适合的方案
+
+ ## 第三步：项目总结和优化
+ - 完成任务后，反思完成步骤，思考项目可能存在的问题和改进方式。
+ - 更新README.md文件，包括新增功能说明和优化建议。
+ - 考虑使用Chrome扩展的高级特性，如Side Panel、Offscreen Documents等。
+ - 优化扩展性能，包括启动时间和内存使用。
+ - 确保扩展符合Chrome Web Store的发布要求。
+
+ 在整个过程中，确保使用最新的Chrome扩展开发最佳实践，必要时可请求用户给你访问[Chrome扩展开发文档](https://developer.chrome.com/docs/extensions)的权限让你查询最新规范。
\ No newline at end of file
diff --git a/.cursorignore b/.cursorignore
new file mode 100644
index 00000000..29c14629
--- /dev/null
+++ b/.cursorignore
@@ -0,0 +1,12 @@
+# 工程文件
+.idea
+.DS_Store
+.todolist
+node_modules/
+package-lock.json
+Users/
+output/
+output-firefox/
+output-edge/
+
+# 配置文件
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index cd81b3f4..239f58f4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,11 @@
# 工程文件
.idea
-
-#编译后的文件
-chrome/output
-*.zip
-
-chrome/output/fe-helper.zip
+.DS_Store
+.todolist
+node_modules/
+package-lock.json
+Users/
+output-chrome/
+output-firefox/
+output-edge/
+.vscode/
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..636380a6
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 zhaoxianlie（xianliezhao@foxmail.com）
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
index 11cacff2..9cca4862 100644
--- a/README.md
+++ b/README.md
@@ -1,44 +1,265 @@
-Web前端助手--FeHelper
-=============================
+# FeHelper - 前端开发者的超级助手
-本插件提供了chrome和sougou浏览器两个版本，其中sougou浏览器版本属于简版，只包含部分工具，代码较简单。
+
+
-### 1、扩展安装地址：
-#### 1）、官方地址
-http://www.baidufe.com/fehelper
+**一个功能强大的开源浏览器扩展，专为前端开发者和职场人士设计**
-#### 2）、webstore地址
-https://chrome.google.com/webstore/detail/pkgccpejnmalmdinmhkkfafefagiiiad?hl=zh-cn&utm_source=chrome-ntp
+[](https://chrome.google.com/webstore/detail/pkgccpejnmalmdinmhkkfafefagiiiad)
+[](https://chrome.google.com/webstore/detail/pkgccpejnmalmdinmhkkfafefagiiiad)
+[](https://chrome.google.com/webstore/detail/pkgccpejnmalmdinmhkkfafefagiiiad)
+[](https://github.com/zxlie/FeHelper)
+[](https://github.com/zxlie/FeHelper)
+[](https://github.com/zxlie/FeHelper)
+
-### 2、扩展目前功能：
- a）、网页兼容性检测
- b）、编码规范检测
- c）、网页栅格规范检测
- d）、JSON格式化
- e）、二维码生成
- f）、字符串编解码工具（Unicode、UTF8、Base64、MD5）
- g）、JSON页面自动格式化查看
- h）、时间（戳）转换工具
- i）、正则表达式测试工具
+[🌐 官网地址](https://fehelper.com) • [📖 在线文档](https://fehelper.com/docs.html) • [💬 问题反馈](https://github.com/zxlie/FeHelper/issues) • [💰 FH$ 代币](https://www.gitfish.dev/repo/zxlie/FeHelper)
-### 3、关于开发
- 下载代码，chrome浏览器中本机开发即可
+
-### 4、关于发布：
-#### 方式一）、依赖编译平台FCP（zxlie用）
+## ✨ 核心特性
- 此方式可以进行js、css代码合并、压缩，html压缩，减小extension的体积。
- 运行build.sh脚本，会生成output，进入output目录，会有如下两个文件：
- fe-helper.zip ：上传到chorme web store，发布。
- fe-helper ：可在开发中进行测试
+FeHelper 是一个集成了 **30+ 种实用工具** 的浏览器扩展，支持 Chrome、Edge、Firefox 三大浏览器，为前端开发者和职场人士提供一站式解决方案。
-#### 方式二）、直接压缩为fe-helper.zip包
+### 🎯 产品展示
- 直接压缩，压缩后可将zip包发到zxlie处（mailto:xianliezhao@foxmail.com），由zxlie发布到webstore。
- 要想把它当成自己作品来发布，可以自己单独申请账号，在webstore缴纳$5，自行上传。
+
+
+|
-### 5、主页：
- HomePage：http://www.baidufe.com/fehelper
- author：zxlie（zhaoxianlie）
- email：xianliezhao@foxmail.com
+
+*FeHelper 主界面 - 30+ 种实用工具一键访问*
+
+ |
+
+
+
+*JSON 格式化工具 - 支持美化、校验、压缩等功能*
+
+ |
+
+
+|
+
+
+*编码解码工具 - 支持多种编码格式转换*
+
+ |
+
+
+
+*二维码工具 - 快速生成和识别二维码*
+
+ |
+
+
+|
+
+
+*个性化设置 - 支持工具排序、主题切换等*
+
+ |
+
+
+
+### 🚀 最新更新
+
+- **🤖 AI 智能助手**：集成 AI 助手，提供代码优化建议、方案设计、资料查找等功能
+- **📊 Mock 数据生成器**：快速生成各种测试数据，支持个人信息、商业数据、技术数据等多种类型
+- **🎨 海报制作工具**：内置海报制作功能，支持多种模板和自定义设计
+- **📈 图表制作工具**：支持多种图表类型，数据可视化更简单
+- **🌙 夜间模式**：支持深色主题，保护眼睛，提升夜间使用体验
+- **🔧 个性化排序**：支持自定义工具排序，打造专属工作台
+
+### 🛠️ 主要功能模块
+
+#### 📋 JSON 处理工具
+- **JSON 美化与校验**：一键格式化、校验、压缩、解压 JSON 数据，支持大文件处理
+- **JSON 差异对比**：支持两个 JSON 内容的自动键值比较，高亮显示差异点
+- **JSON 转 Excel**：快速将 JSON 数据转换为 Excel 格式，便于数据分析
+
+
+
+
+*JSON 自动格式化 - 智能识别并美化 JSON 数据*
+
+
+
+#### 🎨 代码处理工具
+- **代码美化**：支持 JavaScript、CSS、HTML、XML、SQL 等多种代码格式的美化
+- **代码压缩**：提供 HTML、JavaScript、CSS 代码压缩，优化网页加载速度
+- **正则表达式**：内置正则表达式测试工具，支持实时匹配和替换
+
+#### 🔗 接口调试工具
+- **简易 Postman**：提供接口调试功能，支持 GET/POST/HEAD 请求方式
+- **WebSocket 工具**：支持 WebSocket 连接测试，消息发送和结果分析
+- **接口 Mock**：快速生成 Mock 数据，支持多种数据格式
+
+#### 🖼️ 图像处理工具
+- **二维码生成与识别**：快速生成二维码，支持文本、链接、名片等多种内容类型
+- **图片转 Base64**：支持图片与 Base64 格式的相互转换
+- **网页截屏**：支持可视区域截屏、全网页滚动截屏
+- **页面取色**：直接在网页上采集任意元素的色值
+- **SVG 转换器**：支持 SVG 与图片格式的相互转换
+
+#### ⚡ 效率工具
+- **时间戳转换**：本地化时间与时间戳之间的相互转换，支持多时区
+- **随机密码生成**：支持指定长度和字符类型的密码生成
+- **便签笔记**：支持创建目录分类管理，支持一键导出/导入
+- **Markdown 转换**：支持 HTML 转 Markdown，支持 PDF 格式下载
+- **油猴工具**：内置网页脚本注入功能，支持自定义脚本
+
+## 🎯 适用场景
+
+- **前端开发**：JSON 处理、代码美化、接口调试、页面分析
+- **数据分析**：Excel 转 JSON、数据格式转换、图表制作
+- **UI/UX 设计**：页面取色、图像处理、海报制作
+- **办公效率**：便签笔记、时间转换、密码生成
+- **学习研究**：正则表达式、编码解码、WebSocket 测试
+
+## 📦 安装方式
+
+### 🌐 浏览器商店（推荐）
+
+| 浏览器 | 安装地址 | 评分 | 用户数 |
+|--------|----------|------|--------|
+| **Chrome** | [Chrome Web Store](https://chrome.google.com/webstore/detail/pkgccpejnmalmdinmhkkfafefagiiiad) | ⭐⭐⭐⭐⭐ 4.7 | 200K+ |
+| **Edge** | [Microsoft Edge Add-ons](https://microsoftedge.microsoft.com/addons/detail/fehelper%E5%89%8D%E7%AB%AF%E5%8A%A9%E6%89%8B/pkgccpejnmalmdinmhkkfafefagiiiad) | ⭐⭐⭐⭐⭐ 4.8 | 100K+ |
+| **Firefox** | [Firefox Add-ons](https://addons.mozilla.org/en-US/firefox/addon/fehelper-%E5%89%8D%E7%AB%AF%E5%8A%A9%E6%89%8B/) | ⭐⭐⭐⭐⭐ 4.9 | 全新发布 |
+
+### 🚀 无梯下载指南
+
+无法访问浏览器商店？没关系！我们为您提供完整的离线下载方案：
+
+| 方法 | 适用场景 | 下载地址 | 安装步骤 | 优势 |
+|------|----------|----------|----------|------|
+| **Chrome-Stats 镜像** | 国内用户首选 | [Chrome-Stats](https://chrome-stats.com/d/pkgccpejnmalmdinmhkkfafefagiiiad) | 1. 点击 "Download CRX file"
2. 打开 `chrome://extensions`
3. 开启"开发者模式"
4. 拖拽 .crx 文件到页面 | ✅ 国内直接访问
✅ 一键安装
✅ 官方版本 |
+| **ZIP 文件安装** | 需要源码版本 | [Chrome-Stats ZIP](https://chrome-stats.com/d/pkgccpejnmalmdinmhkkfafefagiiiad) | 1. 点击 "Download ZIP file"
2. 解压到本地文件夹
3. 开启"开发者模式"
4. 选择"加载已解压的扩展程序" | ✅ 可查看源码
✅ 支持自定义
✅ 学习开发 |
+| **GitHub 源码** | 开发者使用 | [GitHub 仓库](https://github.com/zxlie/FeHelper) | 1. `git clone` 克隆仓库
2. 打开 `chrome://extensions`
3. 开启"开发者模式"
4. 选择 apps 目录 | ✅ 最新代码
✅ 参与开发
✅ 社区贡献 |
+
+#### 📋 详细安装步骤
+
+
+
+|
+
+**方法一：CRX 文件安装（推荐）**
+
+1. 访问 [Chrome-Stats](https://chrome-stats.com/d/pkgccpejnmalmdinmhkkfafefagiiiad)
+2. 点击 "Download CRX file" 下载
+3. 在 Chrome 地址栏输入：`chrome://extensions`
+4. 开启右上角的"开发者模式"
+5. 将 .crx 文件拖拽到扩展页面
+6. 点击"添加扩展程序"完成安装
+
+ |
+
+
+**方法二：ZIP 文件安装**
+
+1. 在 Chrome-Stats 页面点击 "Download ZIP file"
+2. 将 ZIP 文件解压到本地文件夹
+3. 在 Chrome 地址栏输入：`chrome://extensions`
+4. 开启右上角的"开发者模式"
+5. 点击"加载已解压的扩展程序"
+6. 选择解压后的文件夹完成安装
+
+ |
+
+
+
+#### 🔧 开发者安装
+
+```bash
+# 克隆仓库
+git clone https://github.com/zxlie/FeHelper.git
+
+# 进入项目目录
+cd FeHelper
+
+# 在 Chrome 中加载扩展
+# 1. 打开 chrome://extensions/
+# 2. 开启"开发者模式"
+# 3. 点击"加载已解压的扩展程序"
+# 4. 选择 apps 目录
+```
+
+### 📱 其他平台
+
+- **微信小程序**：扫码即可使用，无需安装
+- **在线版本**：[fehelper.com](https://fehelper.com) 在线使用
+
+### ⚠️ 重要提示
+
+- Chrome 可能会提示"无法从此网站添加应用"，这是正常现象，选择继续即可
+- 安装后建议关闭"开发者模式"以避免警告提示
+- 扩展功能与商店版本完全一致，支持自动更新检查
+- 如遇安装问题，可在 [GitHub Issues](https://github.com/zxlie/FeHelper/issues) 区域反馈
+
+
+## 📊 项目统计
+
+| 指标 | 数值 |
+|------|------|
+| **开发历史** | 13+ 年 (2011-至今) |
+| **GitHub Stars** | 5.3K+ |
+| **GitHub Forks** | 1.3K+ |
+| **Chrome 用户** | 200K+ |
+| **提交次数** | 500+ |
+| **工具数量** | 30+ |
+| **支持浏览器** | Chrome, Edge, Firefox |
+
+
+## 🌟 社区活跃度
+
+- **📈 持续更新**：2023年至今已有 160+ 次提交
+- **🐛 问题响应**：平均 24 小时内响应 issue
+- **💡 功能建议**：欢迎提交 feature request
+- **🤝 贡献代码**：欢迎提交 Pull Request
+
+
+## 💰 FH$ 代币
+
+FeHelper 在 [GitFish](https://www.gitfish.dev/repo/zxlie/FeHelper) 上发布了 FH$ 代币，对虚拟货币感兴趣的用户可以关注：
+
+[](https://www.gitfish.dev/repo/zxlie/FeHelper)
+
+## 🤝 贡献指南
+
+我们欢迎社区的贡献！如果您有兴趣参与 FeHelper 的开发，请按照以下步骤进行：
+
+1. **Fork 本仓库**并克隆到本地
+2. **创建新分支**：`git checkout -b feature/YourFeature`
+3. **提交更改**：`git commit -m 'Add some feature'`
+4. **推送分支**：`git push origin feature/YourFeature`
+5. **创建 Pull Request**
+
+### 开发规范
+
+- 遵循 Chrome Extension Manifest V3 最佳实践
+- 保持代码风格一致，添加必要的注释
+- 新功能需要包含完整的 HTML、JS、CSS 文件
+- 在 `manifest.json` 中正确配置新模块
+
+## 📞 联系我们
+
+- **🌐 官网**：[fehelper.com](https://fehelper.com)
+- **📧 邮箱**：xianliezhao@foxmail.com
+- **💬 微信**：398824681
+- **🐛 问题反馈**：[GitHub Issues](https://github.com/zxlie/FeHelper/issues)
+- **💰 FH$ 代币**：[GitFish](https://www.gitfish.dev/repo/zxlie/FeHelper)
+
+## 📄 许可证
+
+本项目采用 [MIT License](LICENSE) 开源协议。
+
+---
+
+
+
+**⭐ 如果 FeHelper 对您有帮助，请给我们一个 Star！**
+
+[](https://star-history.com/#zxlie/FeHelper&Date)
+
+
\ No newline at end of file
diff --git a/apps/aiagent/fh.ai.js b/apps/aiagent/fh.ai.js
new file mode 100644
index 00000000..901c9174
--- /dev/null
+++ b/apps/aiagent/fh.ai.js
@@ -0,0 +1,119 @@
+import EncodeUtils from '../en-decode/endecode-lib.js';
+/**
+ * 用零一万物大模型来进行流式问答输出
+ */
+let AI = (() => {
+ /**
+ * 用 SiliconFlow 大模型（CoderVM）进行流式问答输出，支持多轮上下文对话
+ * @param {Array} messages 聊天历史数组，每项格式: {role: 'user'|'assistant', content: string}
+ * @param {function} receivingCallback 每次收到新内容时的回调，参数为 message 对象
+ * @param {string} apiKey 可选，API Key
+ * @example
+ * const messages = [
+ * { role: 'user', content: '你好' },
+ * { role: 'assistant', content: '你好，有什么可以帮您？' },
+ * { role: 'user', content: '帮我写个排序算法' }
+ * ];
+ * AI.askCoderLLM(messages, callback);
+ */
+ async function askCoderLLM(messages, receivingCallback, apiKey) {
+ // 默认插入system prompt
+ const systemPrompt = {
+ role: 'system',
+ content: '你是由FeHelper提供的，一个专为开发者服务的AI助手。' +
+ '你的目标是精准理解开发者的技术需求，并以最简洁、直接、专业的方式输出高质量代码，并且保证代码的完整性。' +
+ '请避免无关的解释和冗余描述，只输出开发者真正需要的代码和必要的技术要点说明。' +
+ '遇到不明确的需求时，优先追问关键细节，绝不输出与开发无关的内容。' +
+ '如果生成的是代码，一定要用```的markdown代码块包裹，并使用markdown语法渲染。'
+ };
+ let msgs;
+ if (typeof messages === 'string') {
+ // 单轮对话，自动组装为数组
+ msgs = [systemPrompt, { role: 'user', content: messages }];
+ } else if (Array.isArray(messages)) {
+ // 多轮对话，插入system prompt（如未包含）
+ const hasSystemPrompt = messages.some(m => m.role === 'system' && m.content === systemPrompt.content);
+ msgs = hasSystemPrompt ? messages : [systemPrompt, ...messages];
+ } else {
+ // 其他类型，降级为空对话
+ msgs = [systemPrompt];
+ }
+
+ const defaultKey = 'c2stamJ5eGlldmVmdmhnbnBnbGF3cmxlZ25uam9rY25kc3BpYndjZmh1d2Ntbm9jbmxp';
+ const url = 'https://api.siliconflow.cn/v1/chat/completions';
+ const options = {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${apiKey || EncodeUtils.base64Decode(defaultKey)}`
+ },
+ body: JSON.stringify({
+ "model": "Qwen/Qwen2.5-Coder-7B-Instruct",
+ "messages": msgs, // 直接传递多轮历史
+ "stream": true, // 开启流式输出
+ "max_tokens": 4096,
+ "enable_thinking": true,
+ "thinking_budget": 4096,
+ "min_p": 0.05,
+ "stop": [],
+ "temperature": 0.7,
+ "top_p": 0.7,
+ "top_k": 50,
+ "frequency_penalty": 0.5,
+ "n": 1,
+ "response_format": {
+ "type": "text"
+ }
+ })
+ };
+ try {
+ const response = await fetch(url, options);
+ if (!response.ok) {
+ throw new Error(`HTTP error! status: ${response.status}`);
+ }
+ // 处理流式返回（text/event-stream）
+ const reader = response.body.getReader();
+ const decoder = new TextDecoder('utf-8');
+ let buffer = '';
+ let done = false;
+ const msg = {id:'',content:''};
+ while (!done) {
+ const { value, done: readerDone } = await reader.read();
+ done = readerDone;
+ if (value) {
+ buffer += decoder.decode(value, { stream: true });
+ // 以换行分割，逐条处理
+ let lines = buffer.split('\n');
+ // 最后一行可能不完整，留到下次
+ buffer = lines.pop();
+ for (let line of lines) {
+ line = line.trim();
+ if (!line || !line.startsWith('data:')) continue;
+ let jsonStr = line.replace(/^data:/, '').trim();
+ if (jsonStr === '[DONE]') continue;
+ try {
+ let obj = JSON.parse(jsonStr);
+ if (obj.choices && obj.choices[0] && obj.choices[0].delta) {
+ msg.id = obj.id;
+ msg.created = obj.created;
+ msg.content += obj.choices[0].delta.content;
+ receivingCallback && receivingCallback(msg);
+ }
+ } catch (e) {
+ // 忽略解析失败的片段
+ }
+ }
+ }
+ }
+ receivingCallback && receivingCallback(null,true);
+ } catch (error) {
+ console.error('Error fetching coderVM stream:', error);
+ }
+ }
+
+ return {askCoderLLM};
+})();
+
+
+export default AI;
+
diff --git a/apps/aiagent/index.css b/apps/aiagent/index.css
new file mode 100644
index 00000000..cf782426
--- /dev/null
+++ b/apps/aiagent/index.css
@@ -0,0 +1,319 @@
+@import url("../static/css/bootstrap.min.css");
+@import url("../static/vendor/highlight/github.css");
+
+html,body {
+ background: #fff;
+}
+.wrapper {
+ width:auto;
+}
+
+.table {
+ font-size: 14px;
+}
+
+.mod-inputs {
+ padding: 20px;
+ background-color: #f5f5f5;
+ border-radius: 6px;
+ border: 1px solid #eee;
+}
+.x-res-item {
+ margin: 5px 0;
+}
+.box-prompt {
+ position:fixed;
+ bottom:10px;
+ left:10px;
+ right:10px;
+ padding:10px;
+ margin: 10px;
+ background-color: darkslategray;
+}
+.box-prompt .form-control {
+ height:100px;
+ padding:6px;
+}
+.box-result {
+ position: fixed;
+ bottom: 150px;
+ top: 70px;
+ left: 10px;
+ right: 10px;
+ margin: 10px;
+ background-color: #fafafa;
+ border-color: #ccc;
+ overflow: auto;
+}
+.btn-chat {
+ position:absolute;
+ top:76px;
+ right:10px;
+ height:44px;
+ width:50px;
+}
+.box-tips {
+ margin: 0 15px 0 0;
+}
+ul.x-demos {
+ margin: 30px 0 10px 0;
+ padding: 0;
+}
+ul.x-demos li {
+ position: relative;
+ display: flex;
+ flex-shrink: 0;
+ flex-grow: 0;
+ overflow: hidden;
+ box-sizing: border-box;
+ border-radius: 8px;
+ flex-direction: column;
+ padding: 12px;
+ background-image: linear-gradient(to right, rgba(248, 160, 255, 0.098), rgba(71, 185, 255, 0.098));
+ align-items: flex-start;
+ justify-content: flex-start;
+ margin: 0px 0px 8px;
+ width: 100%;
+ height: auto;
+ cursor: pointer;
+ -webkit-box-flex: 0;
+ -webkit-box-orient: vertical;
+ -webkit-box-direction: normal;
+ -webkit-box-align: start;
+ -webkit-box-pack: start;
+}
+ul.x-demos li:hover {
+ color:#f00;
+}
+.x-loading{
+ margin: 0 auto;
+ width: 200px;
+ position: absolute;
+ left: calc(50% - 100px);
+ top: calc(50% - 100px);
+}
+.x-loading-inline{
+ width: 60px;
+}
+.x-hr {
+ margin: 10px 0;
+}
+.box-message {
+ margin: 10px 15px 10px 0;
+ border:1px solid #eee;
+}
+.box-message table {
+ width: 100%;
+ table-layout: fixed;
+}
+.box-message table td{
+ padding: 10px 5px;
+ vertical-align: top;
+}
+.box-message .td-content {
+ word-break: break-all;
+ white-space: pre-wrap;
+ max-width: 100%;
+}
+.x-from-fh {
+ border: 1px solid #eee;
+ border-width: 1px 0 1px;
+ background: #f9f9f9;
+}
+.td-icon {
+ padding-right: 0 !important;
+}
+.td-icon img {
+ width:16px;
+}
+.td-icon.x-me img {
+ border: 1px solid #f00;
+ border-radius: 16px;
+}
+b.x-time {
+ font-weight: normal;
+ color: #999;
+}
+.x-xcontent {
+ margin-top: 6px;
+}
+.x-xcontent p {
+ margin:0 0 2px 0;
+}
+.x-toolbox {
+ font-size: 12px;
+ text-align: right;
+ float: right;
+ color: #48b;
+}
+.x-toolbox .x-line {
+ font-size: 12px;
+ margin-left: 10px;
+ color: #bbb;
+}
+.x-toolbox .x-tooltip:hover {
+ color: red;
+ cursor: pointer;
+}
+h3.panel-title {
+ position: relative;
+}
+.box-setting {
+ border: 1px solid #ccc;
+ border-radius: 4px;
+ background-color: #fff;
+ position: absolute;
+ top: 27px;
+ right: -16px;
+ z-index: 100;
+ padding: 5px;
+ font-size: 14px;
+ line-height: 26px;
+}
+.box-setting label {
+ font-weight: normal;
+ margin-left: 5px;
+ margin-right: 20px;
+}
+.box-setting .x-sure {
+ text-align: right;
+}
+.box-setting .x-sure button {
+ position: relative;
+ right: -30px;
+}
+
+#pageContainer fieldset {
+ padding: 10px;
+ margin: 10px;
+ border: 1px solid #ddd;
+}
+#pageContainer legend {
+ width: auto;
+ padding: 0 10px;
+ margin-bottom: 0px;
+ font-size: 14px;
+ color: #333;
+ border: 0;
+ border-bottom: 0;
+}
+.resp-error {
+ color:red;
+}
+.x-xcontent table {
+ width: auto;
+}
+.x-xcontent table th {
+ border: 1px solid #ccc;
+ text-align: center;
+ padding: 10px;
+ background: #eee;
+}
+.x-xcontent table td {
+ border: 1px solid #ccc;
+}
+.x-donate-link {
+ right: 210px;
+ top: 0px;
+}
+.panel-title>a.x-other-tools {
+ top: -2px;
+}
+
+.fh-history-sidebar {
+ position: fixed;
+ top: 0;
+ left: 0;
+ width: 280px;
+ height: 100vh;
+ background: #fff;
+ border-right: 1px solid #eee;
+ z-index: 10000;
+ box-shadow: 2px 0 8px rgba(0,0,0,0.04);
+ display: flex;
+ flex-direction: column;
+}
+.fh-history-header {
+ padding: 18px 16px 10px 16px;
+ font-size: 18px;
+ font-weight: bold;
+ border-bottom: 1px solid #eee;
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+}
+.fh-history-close {
+ background: none;
+ border: none;
+ font-size: 16px;
+ color: #888;
+ cursor: pointer;
+}
+.fh-history-list {
+ flex: 1;
+ overflow-y: auto;
+ padding: 12px 0 12px 0;
+}
+.fh-history-date {
+ font-size: 14px;
+ color: #888;
+ margin: 10px 0 4px 18px;
+}
+.fh-history-list ul {
+ list-style: none;
+ margin: 0 0 0 8px;
+ padding: 0;
+}
+.fh-history-list li {
+ padding: 8px 18px;
+ cursor: pointer;
+ border-radius: 6px;
+ transition: background 0.2s;
+ font-size: 15px;
+ color: #333;
+}
+.fh-history-list li:hover {
+ background: #f5f7fa;
+}
+.fh-history-theme {
+ font-weight: 500;
+ color: #222;
+}
+.fh-main-shrink {
+ margin-left: 280px !important;
+ transition: margin-left 0.2s;
+}
+
+.fh-nav-btn {
+ display: inline-block;
+ margin-left: 18px;
+ padding: 3px 14px 3px 10px;
+ border-radius: 18px;
+ background: #f5f7fa;
+ color: #333;
+ font-size: 12px;
+ font-weight: normal;
+ text-decoration: none;
+ transition: background 0.2s, color 0.2s;
+ border: 1px solid #e0e0e0;
+ box-shadow: 0 1px 2px rgba(0,0,0,0.03);
+ vertical-align: middle;
+}
+.fh-nav-btn:hover {
+ background: #e6f0ff;
+ color: #1976d2;
+ border-color: #b3d1ff;
+}
+.x-history-link .icon-clock {
+ color: #1976d2;
+}
+.x-newchat-link .icon-plus-circle {
+ color: #43a047;
+}
+td.td-icon {
+ width: 40px;
+ text-align: center;
+}
+td.td-content .x-xcontent.x-user-content {
+ white-space: pre-wrap;
+}
diff --git a/apps/aiagent/index.html b/apps/aiagent/index.html
new file mode 100644
index 00000000..654dad66
--- /dev/null
+++ b/apps/aiagent/index.html
@@ -0,0 +1,103 @@
+
+
+
+ AI（智能助手）
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/apps/aiagent/index.js b/apps/aiagent/index.js
new file mode 100644
index 00000000..ba945d10
--- /dev/null
+++ b/apps/aiagent/index.js
@@ -0,0 +1,449 @@
+/**
+ * ChatGPT工具
+ * @author zhaoxianlie
+ */
+
+import AI from './fh.ai.js';
+
+new Vue({
+ el: '#pageContainer',
+ data: {
+ prompt: '',
+ demos: [
+ '用Js写一个冒泡排序的Demo',
+ 'Js里的Fetch API是怎么用的',
+ '帮我写一个单网页版的俄罗斯方块游戏',
+ '我开发了一个浏览器插件，是专门为HR自动找简历的，现在请你帮我用SVG绘制一个插件的ICON，不需要问我细节，直接生成'
+ ],
+ initMessage: {
+ id:'id-test123',
+ sendTime:'2022/12/20 12:12:12',
+ message: '你好，可以告诉我你是谁吗？我该怎么和你沟通？',
+ respTime: '2022/12/20 12:12:13',
+ respContent: '你好，我是FeHelper智能助理，由OpenAI提供技术支持；你可以在下面的输入框向我提问，我会尽可能回答你~~~'
+ },
+ respResult:{
+ id: '',
+ sendTime:'',
+ message:'',
+ respTime:'',
+ respContent:''
+ },
+ currentSession: [],
+ history:[],
+ tempId:'',
+ hideDemo: false,
+ undergoing: false,
+ messages: [],
+ showHistoryPanel: false
+ },
+ computed: {
+ groupedHistory() {
+ // 按日期分组，主题为message前20字
+ const groups = {};
+ this.history.forEach(item => {
+ const date = item.sendTime ? item.sendTime.split(' ')[0] : '未知日期';
+ if (!groups[date]) groups[date] = [];
+ groups[date].push({
+ ...item,
+ theme: item.message ? item.message.slice(0, 20) : ''
+ });
+ });
+ return groups;
+ }
+ },
+ watch: {
+ history: {
+ handler(val) {
+ localStorage.setItem('fh-aiagent-history', JSON.stringify(val));
+ },
+ deep: true
+ }
+ },
+ mounted: function () {
+ this.$refs.prompt.focus();
+ this.hideDemo = !!(new URL(location.href)).searchParams.get('hideDemo');
+ // 加载本地历史
+ const local = localStorage.getItem('fh-aiagent-history');
+ if(local){
+ try {
+ this.history = JSON.parse(local);
+ } catch(e) {}
+ }
+ this.loadPatchHotfix();
+ },
+ methods: {
+
+ loadPatchHotfix() {
+ // 页面加载时自动获取并注入页面的补丁
+ chrome.runtime.sendMessage({
+ type: 'fh-dynamic-any-thing',
+ thing: 'fh-get-tool-patch',
+ toolName: 'aiagent'
+ }, patch => {
+ if (patch) {
+ if (patch.css) {
+ const style = document.createElement('style');
+ style.textContent = patch.css;
+ document.head.appendChild(style);
+ }
+ if (patch.js) {
+ try {
+ if (window.evalCore && window.evalCore.getEvalInstance) {
+ window.evalCore.getEvalInstance(window)(patch.js);
+ }
+ } catch (e) {
+ console.error('aiagent补丁JS执行失败', e);
+ }
+ }
+ }
+ });
+ },
+
+ // 这个代码，主要用来判断大模型返回的内容是不是包含完整的代码块
+ validateCodeBlocks(content) {
+ let backticksCount = 0;
+ let inCodeBlock = false;
+ let codeBlockStartIndex = -1;
+
+ for (let i = 0; i < content.length; i++) {
+ // 检查当前位置是否是三个连续的反引号
+ if (content.startsWith('```', i)) {
+ backticksCount++;
+ i += 2; // 跳过接下来的两个字符，因为它们也是反引号的一部分
+
+ // 如果我们遇到了奇数个反引号序列，那么我们进入了代码块
+ if (backticksCount % 2 !== 0) {
+ inCodeBlock = true;
+ codeBlockStartIndex = i - 2;
+ } else { // 否则，我们离开了代码块
+ inCodeBlock = false;
+ if (codeBlockStartIndex === -1 || codeBlockStartIndex > i) {
+ return false; // 这意味着有不匹配的反引号
+ }
+ codeBlockStartIndex = -1;
+ }
+ }
+ }
+
+ // 如果最终 backticksCount 是偶数，则所有代码块都正确关闭
+ return backticksCount % 2 === 0 && !inCodeBlock;
+ },
+
+ sendMessage(prompt){
+ if(this.undergoing) return;
+ if(this.respResult.id){
+ // 先存储上一轮对话到历史
+ this.history.push({
+ id: this.respResult.id,
+ sendTime: this.respResult.sendTime,
+ message: this.respResult.message,
+ respTime: this.respResult.respTime,
+ respContent: this.respResult.respContent
+ });
+ }
+
+ this.undergoing = true;
+ let sendTime = (new Date()).format('yyyy/MM/dd HH:mm:ss');
+ this.$nextTick(() => {
+ this.scrollToBottom();
+ });
+
+ this.tempId = '';
+ let respContent = '';
+
+ // 1. 先把用户输入 push 到 messages
+ this.messages.push({ role: 'user', content: prompt });
+ // 新增：用户消息push到currentSession
+ this.currentSession.push({
+ role: 'user',
+ id: 'user-' + Date.now(),
+ time: sendTime,
+ content: prompt
+ });
+
+ AI.askCoderLLM(this.messages, (respJson, done) => {
+ if(done){
+ this.undergoing = false;
+ if(this.respResult.id && this.respResult.respContent){
+ const tempDiv = document.createElement('div');
+ tempDiv.innerHTML = this.respResult.respContent;
+ const plainText = tempDiv.textContent || tempDiv.innerText || '';
+ this.messages.push({ role: 'assistant', content: plainText });
+ this.history.push({
+ id: this.respResult.id,
+ sendTime: this.respResult.sendTime,
+ message: this.respResult.message,
+ respTime: this.respResult.respTime,
+ respContent: this.respResult.respContent
+ });
+ }
+ this.$nextTick(() => {
+ document.querySelectorAll('.x-xcontent pre code').forEach((block) => {
+ hljs.highlightBlock(block);
+ insertCodeToolbar(block);
+ });
+ this.scrollToBottom();
+ });
+ return;
+ }
+ let id = respJson.id;
+ let rawContent = respJson.content || '';
+ // 检查多轮代码补全场景
+ const lastAssistantMsg = this.currentSession.slice().reverse().find(m => m.role === 'assistant');
+ const lastIsCodeBlock = lastAssistantMsg && /```\s*$/.test(lastAssistantMsg.content.trim());
+ const thisIsCodeBlock = /^```/.test(rawContent.trim());
+ if (lastIsCodeBlock && !thisIsCodeBlock) {
+ rawContent = '```js\n' + rawContent.trim() + '\n```';
+ }
+ respContent = rawContent;
+ if(!this.validateCodeBlocks(respContent)) {
+ respContent += '\n```';
+ }
+ respContent = marked(respContent);
+ if(this.tempId !== id) {
+ this.tempId = id;
+ let dateTime = new Date(respJson.created * 1000);
+ let respTime = dateTime.format('yyyy/MM/dd HH:mm:ss');
+ this.respResult = { id,sendTime,message:prompt,respTime,respContent };
+ // 新增：助手回复push到currentSession
+ this.currentSession.push({
+ role: 'assistant',
+ id,
+ time: respTime,
+ content: respContent
+ });
+ }else{
+ this.respResult.respContent = respContent;
+ // 更新最后一条助手消息内容
+ if(this.currentSession.length && this.currentSession[this.currentSession.length-1].role==='assistant'){
+ this.currentSession[this.currentSession.length-1].content = respContent;
+ }
+ }
+ this.$nextTick(() => this.scrollToBottom());
+ });
+ },
+
+ scrollToBottom(){
+ this.$refs.boxResult.scrollTop = this.$refs.boxResult.scrollHeight;
+ },
+ goChat(){
+ this.sendMessage(this.prompt);
+ this.$nextTick(() => this.prompt='');
+ },
+
+ openOptionsPage: function(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ chrome.runtime.openOptionsPage();
+ },
+
+ openDonateModal: function(event ){
+ event.preventDefault();
+ event.stopPropagation();
+ chrome.runtime.sendMessage({
+ type: 'fh-dynamic-any-thing',
+ thing: 'open-donate-modal',
+ params: { toolName: 'aiagent' }
+ });
+ },
+
+ loadHistory(item) {
+ // 渲染到主面板
+ this.respResult = {
+ id: item.id,
+ sendTime: item.sendTime,
+ message: item.message,
+ respTime: item.respTime,
+ respContent: item.respContent
+ };
+ this.showHistoryPanel = false;
+ this.$nextTick(() => this.scrollToBottom());
+ },
+
+ startNewChat(event) {
+ event && event.preventDefault();
+ this.messages = [];
+ this.respResult = {
+ id: '',
+ sendTime: '',
+ message: '',
+ respTime: '',
+ respContent: ''
+ };
+ this.currentSession = [];
+ this.showHistoryPanel = false;
+ this.$nextTick(() => {
+ this.$forceUpdate();
+ this.scrollToBottom();
+ });
+ },
+
+ onHistoryClick(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ this.showHistoryPanel = !this.showHistoryPanel;
+ },
+
+ onPromptKeydown(e) {
+ if (e.key === 'Enter') {
+ if (e.shiftKey) {
+ // 允许换行
+ return;
+ } else {
+ // 阻止默认换行，发送消息
+ e.preventDefault();
+ this.goChat();
+ }
+ }
+ }
+ }
+
+});
+
+// 工具函数：复制和运行
+function copyCode(code) {
+ if (navigator.clipboard) {
+ navigator.clipboard.writeText(code);
+ } else {
+ const textarea = document.createElement('textarea');
+ textarea.value = code;
+ document.body.appendChild(textarea);
+ textarea.select();
+ document.execCommand('copy');
+ document.body.removeChild(textarea);
+ }
+}
+
+// 新增：为代码块插入工具栏
+function insertCodeToolbar(block) {
+ // 检查是否已插入按钮，避免重复
+ if (block.parentNode.querySelector('.fh-code-toolbar')) return;
+
+ // 创建工具栏
+ const toolbar = document.createElement('div');
+ toolbar.className = 'fh-code-toolbar';
+ toolbar.style.cssText = 'position:absolute;bottom:6px;right:12px;z-index:10;display:flex;gap:8px;';
+
+ // 复制按钮
+ const btnCopy = document.createElement('button');
+ btnCopy.innerText = '复制';
+ btnCopy.className = 'fh-btn-copy';
+ btnCopy.style.cssText = 'padding:2px 8px;font-size:12px;cursor:pointer;';
+ btnCopy.onclick = (e) => {
+ e.stopPropagation();
+ copyCode(block.innerText);
+ // 复制成功反馈
+ const oldText = btnCopy.innerText;
+ btnCopy.innerText = '已复制';
+ btnCopy.disabled = true;
+ setTimeout(() => {
+ btnCopy.innerText = oldText;
+ btnCopy.disabled = false;
+ }, 1000);
+ };
+
+ // 运行按钮
+ const lang = (block.className || '').toLowerCase();
+ let btnRun = document.createElement('button');
+ btnRun.className = 'fh-btn-run';
+ btnRun.style.cssText = 'padding:2px 8px;font-size:12px;cursor:pointer;';
+ let shouldAppendBtnRun = true;
+ if (lang.includes('lang-javascript') || lang.includes('lang-js')) {
+ btnRun.innerText = 'Console运行';
+ btnRun.onclick = (e) => {
+ e.stopPropagation();
+ copyCode(block.innerText);
+ btnRun.innerText = '已复制到剪贴板';
+ btnRun.disabled = true;
+ setTimeout(() => {
+ btnRun.innerText = 'Console运行';
+ btnRun.disabled = false;
+ }, 1200);
+ showToast('代码已复制到剪贴板，请按F12打开开发者工具，切换到Console粘贴回车即可运行！');
+ };
+ } else if (lang.includes('lang-html')) {
+ btnRun.innerText = '下载并运行';
+ btnRun.onclick = (e) => {
+ e.stopPropagation();
+ const blob = new Blob([block.innerText], {type: 'text/html'});
+ const url = URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.href = url;
+ a.download = 'fehelper-demo.html';
+ document.body.appendChild(a);
+ a.click();
+ document.body.removeChild(a);
+ URL.revokeObjectURL(url);
+ btnRun.innerText = '已下载';
+ btnRun.disabled = true;
+ setTimeout(() => {
+ btnRun.innerText = '下载并运行';
+ btnRun.disabled = false;
+ }, 1200);
+ showToast('HTML文件已下载，请双击打开即可运行！');
+ };
+ } else if (lang.includes('lang-xml') || lang.includes('lang-svg')) {
+ // 检查内容是否为svg
+ const codeText = block.innerText.trim();
+ if (/^$/.test(codeText)) {
+ btnRun.innerText = '点击预览';
+ btnRun.onclick = (e) => {
+ e.stopPropagation();
+ // 弹窗预览svg
+ const modal = document.createElement('div');
+ modal.style.cssText = 'position:fixed;left:0;top:0;width:100vw;height:100vh;background:rgba(0,0,0,0.5);z-index:999999;display:flex;align-items:center;justify-content:center;';
+ const inner = document.createElement('div');
+ inner.style.cssText = 'background:#fff;width:400px;height:400px;border-radius:10px;box-shadow:0 2px 16px rgba(0,0,0,0.18);position:relative;display:flex;align-items:center;justify-content:center;';
+ const closeBtn = document.createElement('button');
+ closeBtn.innerText = '×';
+ closeBtn.style.cssText = 'position:absolute;top:8px;right:12px;width:32px;height:32px;font-size:22px;line-height:28px;background:transparent;border:none;cursor:pointer;color:#888;z-index:2;';
+ closeBtn.onclick = () => document.body.removeChild(modal);
+ const img = document.createElement('img');
+ img.src = 'data:image/svg+xml;base64,' + btoa(unescape(encodeURIComponent(codeText)));
+ img.alt = 'SVG预览';
+ img.style.cssText = 'max-width:90%;max-height:90%;display:block;border:1px solid #eee;background:#fafbfc;';
+ inner.appendChild(closeBtn);
+ inner.appendChild(img);
+ modal.appendChild(inner);
+ document.body.appendChild(modal);
+ };
+ } else {
+ btnRun.remove();
+ shouldAppendBtnRun = false;
+ }
+ } else {
+ btnRun.remove();
+ shouldAppendBtnRun = false;
+ }
+
+ toolbar.appendChild(btnCopy);
+ if (shouldAppendBtnRun) {
+ toolbar.appendChild(btnRun);
+ }
+
+ // 让pre相对定位，插入工具栏到底部
+ const pre = block.parentNode;
+ pre.style.position = 'relative';
+ pre.appendChild(toolbar);
+}
+
+// 页面内Toast提示
+function showToast(msg) {
+ let toast = document.createElement('div');
+ toast.className = 'fh-toast';
+ toast.innerText = msg;
+ toast.style.cssText = `
+ position:fixed;left:50%;top:80px;transform:translateX(-50%);
+ background:rgba(0,0,0,0.85);color:#fff;padding:10px 24px;
+ border-radius:6px;font-size:16px;z-index:99999;box-shadow:0 2px 8px rgba(0,0,0,0.2);
+ transition:opacity 0.3s;opacity:1;
+ `;
+ document.body.appendChild(toast);
+ setTimeout(() => {
+ toast.style.opacity = '0';
+ setTimeout(() => document.body.removeChild(toast), 300);
+ }, 1800);
+}
+
+
diff --git a/apps/background/awesome.js b/apps/background/awesome.js
new file mode 100644
index 00000000..68e0e0bd
--- /dev/null
+++ b/apps/background/awesome.js
@@ -0,0 +1,365 @@
+/**
+ * 工具更新
+ * @type {{download}}
+ */
+import toolMap from './tools.js';
+
+let Awesome = (() => {
+
+ let manifest = chrome.runtime ? chrome.runtime.getManifest() : {};
+
+ const SERVER_SITE = manifest.homepage_url;
+ const URL_TOOL_TPL = `${SERVER_SITE}/#TOOL-NAME#/index.html`;
+ const TOOL_NAME_TPL = 'DYNAMIC_TOOL:#TOOL-NAME#';
+ const TOOL_CONTENT_SCRIPT_TPL = 'DYNAMIC_TOOL:CS:#TOOL-NAME#';
+ const TOOL_CONTENT_SCRIPT_CSS_TPL = 'DYNAMIC_TOOL:CS:CSS:#TOOL-NAME#';
+ const TOOL_MENU_TPL = 'DYNAMIC_MENU:#TOOL-NAME#';
+
+ /**
+ * 管理本地存储
+ */
+ let StorageMgr = (() => {
+
+ // 获取chrome.storage.local中的内容，返回Promise，可直接await
+ let get = keyArr => {
+ return new Promise((resolve, reject) => {
+ chrome.storage.local.get(keyArr, result => {
+ resolve(typeof keyArr === 'string' ? result[keyArr] : result);
+ });
+ });
+ };
+
+ let set = (items, values) => {
+ return new Promise((resolve, reject) => {
+ if (typeof items === 'string') {
+ let tmp = {};
+ tmp[items] = values;
+ items = tmp;
+ }
+ chrome.storage.local.set(items, () => {
+ resolve();
+ });
+ });
+ };
+
+ let remove = keyArr => {
+ return new Promise((resolve, reject) => {
+ keyArr = [].concat(keyArr);
+ chrome.storage.local.remove(keyArr, () => {
+ resolve();
+ });
+ });
+ };
+
+ return {get, set, remove};
+ })();
+
+ /**
+ * 检测工具是否已被成功安装
+ * @param toolName 工具名称
+ * @param detectMenu 是否进一步检测Menu的设置情况
+ * @returns {Promise}
+ */
+ let detectInstall = (toolName, detectMenu) => {
+
+ let menuKey = TOOL_MENU_TPL.replace('#TOOL-NAME#', toolName);
+ let toolKey = TOOL_NAME_TPL.replace('#TOOL-NAME#', toolName);
+
+ return Promise.all([StorageMgr.get(toolKey), StorageMgr.get(menuKey)]).then(values => {
+ let toolInstalled = !!values[0];
+ // 系统预置的功能，是强制 installed 状态的
+ if(toolMap[toolName] && toolMap[toolName].systemInstalled) {
+ toolInstalled = true;
+ }
+ if (detectMenu) {
+ return toolInstalled && String(values[1]) === '1';
+ }
+ return toolInstalled;
+ });
+ };
+
+ let log = (txt) => {
+ // console.log(String(new Date(new Date() * 1 - (new Date().getTimezoneOffset()) * 60 * 1000).toJSON()).replace(/T/i, ' ').replace(/Z/i, '') + '>', txt);
+ };
+
+ /**
+ * 安装/更新工具，支持显示安装进度
+ * @param toolName
+ * @param fnProgress
+ * @returns {Promise}
+ */
+ let install = (toolName, fnProgress) => {
+ return new Promise((resolve, reject) => {
+ // 存储html文件
+ StorageMgr.set(TOOL_NAME_TPL.replace('#TOOL-NAME#', toolName), new Date().getTime());
+ log(toolName + '工具html模板安装/更新成功！');
+ resolve();
+ });
+ };
+
+ let offLoad = (toolName) => {
+ let items = [];
+ items.push(TOOL_NAME_TPL.replace('#TOOL-NAME#', toolName));
+ items.push(TOOL_CONTENT_SCRIPT_TPL.replace('#TOOL-NAME#', toolName));
+ items.push(TOOL_CONTENT_SCRIPT_CSS_TPL.replace('#TOOL-NAME#', toolName));
+
+ // 删除所有静态文件
+ chrome.storage.local.get(null, allDatas => {
+ if (allDatas) {
+ StorageMgr.remove(Object.keys(allDatas).filter(key => String(key).startsWith(`../${toolName}/`)));
+ }
+ });
+
+ log(toolName + ' 卸载成功！');
+
+ return StorageMgr.remove(items);
+ };
+
+ /**
+ * 有些工具其实已经卸载过了，但是本地还有冗余的静态文件，都需要统一清理一遍
+ */
+ let gcLocalFiles = () => getAllTools().then(tools => {
+ if (!tools) return;
+ Object.keys(tools).forEach(tool => {
+ if (!tools[tool] || !tools[tool]._devTool && !tools[tool].installed) {
+ offLoad(tool);
+ }
+ });
+ });
+
+ let getAllTools = async () => {
+
+ // 获取本地开发的插件，也拼接进来
+ try {
+ const DEV_TOOLS_MY_TOOLS = 'DEV-TOOLS:MY-TOOLS';
+ let _tools = await StorageMgr.get(DEV_TOOLS_MY_TOOLS);
+ let localDevTools = JSON.parse(_tools || '{}');
+ Object.keys(localDevTools).forEach(tool => {
+ toolMap[tool] = localDevTools[tool];
+ });
+ } catch (e) {
+ }
+
+ let tools = Object.keys(toolMap);
+ let promises = [];
+ tools.forEach(tool => {
+ promises = promises.concat([detectInstall(tool), detectInstall(tool, true)])
+ });
+ return Promise.all(promises).then(values => {
+ (values || []).forEach((v, i) => {
+ let tool = tools[Math.floor(i / 2)];
+ let key = i % 2 === 0 ? 'installed' : 'menu';
+ toolMap[tool][key] = v;
+ // 本地工具，还需要看是否处于开启状态
+ if (toolMap[tool].hasOwnProperty('_devTool')) {
+ toolMap[tool][key] = toolMap[tool][key] && toolMap[tool]._enable;
+ }
+ });
+
+ return toolMap;
+ });
+ };
+
+ /**
+ * 检查看本地已安装过哪些工具 - 性能优化版本
+ * @returns {Promise}
+ */
+ let getInstalledTools = async () => {
+ try {
+ // 一次性获取所有存储数据，避免多次访问
+ const allStorageData = await new Promise((resolve, reject) => {
+ chrome.storage.local.get(null, result => {
+ resolve(result || {});
+ });
+ });
+
+ // 获取本地开发的插件
+ const DEV_TOOLS_MY_TOOLS = 'DEV-TOOLS:MY-TOOLS';
+ let localDevTools = {};
+ try {
+ localDevTools = JSON.parse(allStorageData[DEV_TOOLS_MY_TOOLS] || '{}');
+ Object.keys(localDevTools).forEach(tool => {
+ toolMap[tool] = localDevTools[tool];
+ });
+ } catch (e) {
+ // 忽略解析错误
+ }
+
+ let installedTools = {};
+
+ // 遍历所有工具，从存储数据中检查安装状态
+ Object.keys(toolMap).forEach(toolName => {
+ const toolKey = TOOL_NAME_TPL.replace('#TOOL-NAME#', toolName);
+ const menuKey = TOOL_MENU_TPL.replace('#TOOL-NAME#', toolName);
+
+ // 检查工具是否已安装
+ let toolInstalled = !!allStorageData[toolKey];
+ // 系统预置的功能，是强制 installed 状态的
+ if (toolMap[toolName] && toolMap[toolName].systemInstalled) {
+ toolInstalled = true;
+ }
+
+ // 检查菜单状态
+ let menuInstalled = String(allStorageData[menuKey]) === '1';
+
+ // 本地工具，还需要看是否处于开启状态
+ if (toolMap[toolName].hasOwnProperty('_devTool')) {
+ toolInstalled = toolInstalled && toolMap[toolName]._enable;
+ menuInstalled = menuInstalled && toolMap[toolName]._enable;
+ }
+
+ // 只收集已安装的工具
+ if (toolInstalled) {
+ installedTools[toolName] = {
+ ...toolMap[toolName],
+ installed: true,
+ menu: menuInstalled,
+ installTime: parseInt(allStorageData[toolKey]) || 0
+ };
+ }
+ });
+
+ // 按安装时间排序
+ const sortedToolNames = Object.keys(installedTools).sort((a, b) => {
+ return installedTools[a].installTime - installedTools[b].installTime;
+ });
+
+ let sortedToolMap = {};
+ sortedToolNames.forEach(toolName => {
+ sortedToolMap[toolName] = installedTools[toolName];
+ });
+
+ return sortedToolMap;
+ } catch (error) {
+ console.error('getInstalledTools error:', error);
+ // 发生错误时返回空对象，避免popup完全无法加载
+ return {};
+ }
+ };
+
+ /**
+ * 获取工具的content-script
+ * @param toolName
+ * @param cssMode
+ */
+ let getContentScript = (toolName, cssMode) => {
+ return StorageMgr.get(cssMode ? TOOL_CONTENT_SCRIPT_CSS_TPL.replace('#TOOL-NAME#', toolName)
+ : TOOL_CONTENT_SCRIPT_TPL.replace('#TOOL-NAME#', toolName));
+ };
+
+ /**
+ * 获取工具的html模板
+ * @param toolName
+ * @returns {*}
+ */
+ let getToolTpl = (toolName) => StorageMgr.get(TOOL_NAME_TPL.replace('#TOOL-NAME#', toolName));
+
+ /**
+ * 从服务器检查，看本地已安装的工具，有哪些又已经升级过了
+ * @param tool
+ */
+ let checkUpgrade = (tool) => {
+ let getOnline = (toolName) => fetch(URL_TOOL_TPL.replace('#TOOL-NAME#', toolName)).then(resp => resp.text());
+ let getOffline = (toolName) => StorageMgr.get(TOOL_NAME_TPL.replace('#TOOL-NAME#', toolName));
+ return Promise.all([getOnline(tool), getOffline(tool)]).then(values => {
+ let onlineData = _tplHandler(tool, values[0]);
+ let local = values[1];
+ return local !== onlineData.html;
+ });
+ };
+
+ /**
+ * 管理右键菜单
+ * @param toolName
+ * @param action 具体动作install/offload/get
+ * @returns {Promise}
+ */
+ let menuMgr = (toolName, action) => {
+ let menuKey = TOOL_MENU_TPL.replace('#TOOL-NAME#', toolName);
+ switch (action) {
+ case 'get':
+ return StorageMgr.get(menuKey);
+ case 'offload':
+ // 必须用setItem模式，而不是removeItem，要处理 0/1/null三种结果
+ log(toolName + ' 卸载成功！');
+ return StorageMgr.set(menuKey, 0);
+ case 'install':
+ log(toolName + ' 安装成功！');
+ return StorageMgr.set(menuKey, 1);
+ }
+ };
+
+
+ /**
+ * 采集客户端信息并发送给background
+ */
+ let collectAndSendClientInfo = () => {
+ try {
+ const nav = navigator;
+ const screenInfo = window.screen;
+ const lang = nav.language || nav.userLanguage || '';
+ const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || '';
+ const ua = nav.userAgent;
+ const platform = nav.platform;
+ const vendor = nav.vendor;
+ const colorDepth = screenInfo.colorDepth;
+ const screenWidth = screenInfo.width;
+ const screenHeight = screenInfo.height;
+ const deviceMemory = nav.deviceMemory || '';
+ const hardwareConcurrency = nav.hardwareConcurrency || '';
+ const connection = nav.connection || nav.mozConnection || nav.webkitConnection || {};
+ const screenOrientation = screenInfo.orientation ? screenInfo.orientation.type : '';
+ const touchSupport = ('ontouchstart' in window) || (nav.maxTouchPoints > 0);
+ let memoryJSHeapSize = '';
+ if (window.performance && window.performance.memory) {
+ memoryJSHeapSize = window.performance.memory.jsHeapSizeLimit;
+ }
+ const clientInfo = {
+ language: lang,
+ timezone,
+ userAgent: ua,
+ platform,
+ vendor,
+ colorDepth,
+ screenWidth,
+ screenHeight,
+ deviceMemory,
+ hardwareConcurrency,
+ networkType: connection.effectiveType || '',
+ downlink: connection.downlink || '',
+ rtt: connection.rtt || '',
+ online: nav.onLine,
+ touchSupport,
+ cookieEnabled: nav.cookieEnabled,
+ doNotTrack: nav.doNotTrack,
+ appVersion: nav.appVersion,
+ appName: nav.appName,
+ product: nav.product,
+ vendorSub: nav.vendorSub,
+ screenOrientation,
+ memoryJSHeapSize
+ };
+ chrome.runtime.sendMessage({ type: 'clientInfo', data: clientInfo });
+ } catch (e) {
+ // 忽略采集异常
+ }
+ };
+
+ return {
+ StorageMgr,
+ detectInstall,
+ install,
+ offLoad,
+ getInstalledTools,
+ menuMgr,
+ checkUpgrade,
+ getContentScript,
+ getToolTpl,
+ gcLocalFiles,
+ getAllTools,
+ collectAndSendClientInfo
+ }
+})();
+
+export default Awesome;
+
diff --git a/apps/background/background.js b/apps/background/background.js
new file mode 100644
index 00000000..505eeb3f
--- /dev/null
+++ b/apps/background/background.js
@@ -0,0 +1,882 @@
+/**
+ * FeJson后台运行程序
+ * @author zhaoxianlie
+ */
+
+
+import MSG_TYPE from '../static/js/common.js';
+import Settings from '../options/settings.js';
+import Menu from './menu.js';
+import Awesome from './awesome.js';
+import InjectTools from './inject-tools.js';
+import Monkey from './monkey.js';
+import Statistics from './statistics.js';
+
+
+let BgPageInstance = (function () {
+
+ let FeJson = {
+ notifyTimeoutId: -1
+ };
+
+ // 黑名单页面
+ let blacklist = [
+ /^https:\/\/chrome\.google\.com/
+ ];
+
+ // 全局缓存最新的客户端信息
+ let FH_CLIENT_INFO = {};
+
+ /**
+ * 文本格式，可以设置一个图标和标题
+ * @param {Object} options
+ * @config {string} type notification的类型，可选值：html、text
+ * @config {string} icon 图标
+ * @config {string} title 标题
+ * @config {string} message 内容
+ */
+ let notifyText = function (options) {
+ let notifyId = 'FeJson-notify-id';
+
+ clearTimeout(FeJson.notifyTimeoutId);
+ if (options.closeImmediately) {
+ return chrome.notifications.clear(notifyId);
+ }
+
+ if (!options.icon) {
+ options.icon = "static/img/fe-48.png";
+ }
+ if (!options.title) {
+ options.title = "温馨提示";
+ }
+ chrome.notifications.create(notifyId, {
+ type: 'basic',
+ title: options.title,
+ iconUrl: chrome.runtime.getURL(options.icon),
+ message: options.message
+ });
+
+ FeJson.notifyTimeoutId = setTimeout(() => {
+ chrome.notifications.clear(notifyId);
+ }, parseInt(options.autoClose || 3000, 10));
+
+ };
+
+ // 像页面注入css脚本
+ let _injectContentCss = function(tabId,toolName,isDevTool){
+ if(isDevTool){
+ Awesome.getContentScript(toolName, true)
+ .then(css => {
+ InjectTools.inject(tabId, { css })
+ });
+ }else{
+ InjectTools.inject(tabId, {files: [`${toolName}/content-script.css`]});
+ }
+ };
+
+
+ // 往当前页面直接注入脚本，不再使用content-script的配置了
+ let _injectContentScripts = function (tabId) {
+
+ // FH工具脚本注入
+ Awesome.getInstalledTools().then(tools => {
+
+ // 注入js
+ let jsTools = Object.keys(tools)
+ .filter(tool => !tools[tool]._devTool
+ && (tools[tool].contentScriptJs || tools[tool].contentScript));
+ let jsCodes = [];
+ jsTools.forEach((t, i) => {
+ let func = `window['${t.replace(/-/g, '')}ContentScript']`;
+ jsCodes.push(`(()=>{let func=${func};func&&func();})()`);
+ });
+ let jsFiles = jsTools.map(tool => `${tool}/content-script.js`);
+ InjectTools.inject(tabId, {files: jsFiles,js: jsCodes.join(';')});
+ });
+
+ // 其他开发者自定义工具脚本注入======For FH DevTools
+ Awesome.getInstalledTools().then(tools => {
+ let list = Object.keys(tools).filter(tool => tools[tool]._devTool);
+
+ // 注入js脚本
+ list.filter(tool => (tools[tool].contentScriptJs || tools[tool].contentScript))
+ .map(tool => Awesome.getContentScript(tool).then(js => {
+ InjectTools.inject(tabId, { js });
+ }));
+ });
+ };
+
+ /**
+ * 打开打赏弹窗
+ * @param {string} toolName - 工具名称
+ */
+ chrome.gotoDonateModal = function (toolName) {
+ chrome.tabs.query({currentWindow: true}, function (tabs) {
+
+ Settings.getOptions((opts) => {
+ let isOpened = false;
+ let tabId;
+ let reg = new RegExp("^chrome.*\\/options\\/index.html\\?donate_from=" + toolName + "$", "i");
+ for (let i = 0, len = tabs.length; i < len; i++) {
+ if (reg.test(tabs[i].url)) {
+ isOpened = true;
+ tabId = tabs[i].id;
+ break;
+ }
+ }
+
+ if (!isOpened) {
+ let url = `/options/index.html?donate_from=${toolName}`;
+ chrome.tabs.create({ url,active: true });
+ } else {
+ chrome.tabs.update(tabId, {highlighted: true}).then(tab => {
+ chrome.tabs.reload(tabId);
+ });
+ }
+ // 记录工具使用
+ Statistics.recordToolUsage('donate',{from: toolName});
+
+ });
+
+ });
+ };
+
+ /**
+ * 动态运行工具
+ * @param configs
+ * @config tool 工具名称
+ * @config withContent 默认携带的内容
+ * @config query 请求参数
+ * @config noPage 无页面模式
+ * @constructor
+ */
+ chrome.DynamicToolRunner = async function (configs) {
+
+ let tool = configs.tool || configs.page;
+ let withContent = configs.withContent;
+ let activeTab = null;
+ let query = configs.query;
+
+ // 如果是noPage模式，则表名只完成content-script的工作，直接发送命令即可
+ if (configs.noPage) {
+ let toolFunc = tool.replace(/-/g, '');
+ chrome.tabs.query({active: true, currentWindow: true}, tabs => {
+ let found = tabs.some(tab => {
+ if (/^(http(s)?|file):\/\//.test(tab.url) && blacklist.every(reg => !reg.test(tab.url))) {
+ let codes = `window['${toolFunc}NoPage'] && window['${toolFunc}NoPage'](${JSON.stringify(tab)});`;
+ InjectTools.inject(tab.id, {js: codes});
+ return true;
+ }
+ return false;
+ });
+ if (!found) {
+ notifyText({
+ message: '抱歉，此工具无法在当前页面使用！'
+ });
+ }
+ });
+ return;
+ }
+
+ chrome.tabs.query({currentWindow: true}, function (tabs) {
+
+ activeTab = tabs.filter(tab => tab.active)[0];
+
+ // 如果是二维码工具，且没有传入内容，则使用当前页面的URL
+ if (tool === 'qr-code' && !withContent && activeTab) {
+ withContent = activeTab.url;
+ }
+
+ Settings.getOptions((opts) => {
+ let isOpened = false;
+ let tabId;
+
+ // 允许在新窗口打开
+ if (String(opts['FORBID_OPEN_IN_NEW_TAB']) === 'true') {
+ let reg = new RegExp("^chrome.*\\/" + tool + "\\/index.html" + (query ? "\\?" + query : '') + "$", "i");
+ for (let i = 0, len = tabs.length; i < len; i++) {
+ if (reg.test(tabs[i].url)) {
+ isOpened = true;
+ tabId = tabs[i].id;
+ break;
+ }
+ }
+ }
+
+ if (!isOpened) {
+ let url = `/${tool}/index.html` + (query ? "?" + query : '');
+ chrome.tabs.create({
+ url,
+ active: true
+ }).then(tab => { FeJson[tab.id] = { content: withContent }; });
+ } else {
+ chrome.tabs.update(tabId, {highlighted: true}).then(tab => {
+ FeJson[tab.id] = { content: withContent };
+ chrome.tabs.reload(tabId);
+ });
+ }
+
+ });
+
+ });
+ };
+
+ /**
+ * 动态在icon处显示提示
+ * @param tips
+ * @private
+ */
+ let _animateTips = (tips) => {
+ setTimeout(() => {
+ chrome.action.setBadgeText({text: tips});
+ setTimeout(() => {
+ chrome.action.setBadgeText({text: ''});
+ }, 2000);
+ }, 3000);
+ };
+
+ /**
+ * 插件图标点击后的默认动作
+ * @param request
+ * @param sender
+ * @param callback
+ */
+ let browserActionClickedHandler = function (request, sender, callback) {
+ // 获取当前唯一安装的工具并直接打开
+ Awesome.getInstalledTools().then(tools => {
+ const installedTools = Object.keys(tools).filter(tool => tools[tool].installed);
+ if (installedTools.length === 1) {
+ const singleTool = installedTools[0];
+ chrome.DynamicToolRunner({
+ tool: singleTool,
+ noPage: !!tools[singleTool].noPage
+ });
+
+ // 记录工具使用
+ Statistics.recordToolUsage(singleTool);
+ } else {
+ // 备用方案：如果检测失败，打开JSON格式化工具
+ chrome.DynamicToolRunner({
+ tool: MSG_TYPE.JSON_FORMAT
+ });
+
+ // 记录工具使用
+ Statistics.recordToolUsage(MSG_TYPE.JSON_FORMAT);
+ }
+ }).catch(error => {
+ console.error('获取工具列表失败，使用默认工具:', error);
+ // 出错时的备用方案
+ chrome.DynamicToolRunner({
+ tool: MSG_TYPE.JSON_FORMAT
+ });
+
+ // 记录工具使用
+ Statistics.recordToolUsage(MSG_TYPE.JSON_FORMAT);
+ });
+ };
+
+ /**
+ * 更新browser action的点击动作
+ * @param action install / upgrade / offload
+ * @param showTips 是否notify
+ * @param menuOnly 只管理Menu
+ * @private
+ */
+ let _updateBrowserAction = function (action, showTips, menuOnly) {
+ if (!menuOnly) {
+ // 对于卸载操作，添加一个小延迟确保存储操作完成
+ const delay = action === 'offload' ? 100 : 0;
+
+ setTimeout(() => {
+ // 如果有安装过工具，则显示Popup模式
+ Awesome.getInstalledTools().then(tools => {
+ // 计算已安装的工具数量
+ const installedTools = Object.keys(tools).filter(tool => tools[tool].installed);
+ const installedCount = installedTools.length;
+
+ if (installedCount > 1) {
+ // 多个工具：显示popup
+ chrome.action.setPopup({ popup: '/popup/index.html' });
+ // 移除点击监听器（如果存在）
+ if (chrome.action.onClicked.hasListener(browserActionClickedHandler)) {
+ chrome.action.onClicked.removeListener(browserActionClickedHandler);
+ }
+ } else if (installedCount === 1) {
+ // 只有一个工具：直接打开工具，不显示popup
+ chrome.action.setPopup({ popup: '' });
+
+ // 添加点击监听器
+ if (!chrome.action.onClicked.hasListener(browserActionClickedHandler)) {
+ chrome.action.onClicked.addListener(browserActionClickedHandler);
+ }
+ } else {
+ // 没有安装任何工具：显示popup（让用户去安装工具）
+ chrome.action.setPopup({ popup: '/popup/index.html' });
+ // 移除点击监听器（如果存在）
+ if (chrome.action.onClicked.hasListener(browserActionClickedHandler)) {
+ chrome.action.onClicked.removeListener(browserActionClickedHandler);
+ }
+ }
+ });
+ }, delay);
+
+ if (action === 'offload') {
+ _animateTips('-1');
+ } else if(!!action) {
+ _animateTips('+1');
+ }
+ } else {
+ // 重绘菜单
+ Menu.rebuild();
+ }
+
+ if (showTips) {
+ let actionTxt = '';
+ switch (action) {
+ case 'install':
+ actionTxt = '工具已「安装」成功，并已添加到弹出下拉列表，点击FeHelper图标可正常使用！';
+ break;
+ case 'offload':
+ actionTxt = '工具已「卸载」成功，并已从弹出下拉列表中移除！';
+ break;
+ case 'menu-install':
+ actionTxt = '已将此工具快捷方式加入到「右键菜单」中！';
+ break;
+ case 'menu-offload':
+ actionTxt = '已将此工具快捷方式从「右键菜单」中移除！';
+ break;
+ default:
+ actionTxt = '恭喜，操作成功！';
+ }
+ notifyText({
+ message: actionTxt,
+ autoClose: 2500
+ });
+ }
+ };
+
+
+ // 捕获当前页面可视区域
+ let _captureVisibleTab = function (callback) {
+ chrome.tabs.captureVisibleTab(null, {format: 'png', quality: 100}, uri => {
+ callback && callback(uri);
+ });
+ };
+
+ let _addScreenShotByPages = function(params,callback){
+ chrome.tabs.captureVisibleTab(null, {format: 'png', quality: 100}, uri => {
+ callback({ params, uri });
+ });
+ };
+
+ let _showScreenShotResult = function(data){
+ // 确保截图数据完整有效
+ if (!data || !data.screenshots || !data.screenshots.length) {
+ return;
+ }
+
+ chrome.DynamicToolRunner({
+ tool: 'screenshot',
+ withContent: data
+ });
+ };
+
+ let _colorPickerCapture = function(params) {
+ chrome.tabs.query({active: true, currentWindow: true}, function (tabs) {
+ chrome.tabs.captureVisibleTab(null, {format: 'png'}, function (dataUrl) {
+ let js = `window.colorpickerNoPage(${JSON.stringify({
+ setPickerImage: true,
+ pickerImage: dataUrl
+ })})`;
+ InjectTools.inject(tabs[0].id, { js });
+ });
+ });
+ };
+
+ let _codeBeautify = function(params){
+ Awesome.StorageMgr.get('JS_CSS_PAGE_BEAUTIFY').then(val => {
+ if(val !== '0') {
+ let js = `window._codebutifydetect_('${params.fileType}')`;
+ InjectTools.inject(params.tabId, { js });
+ // 记录工具使用
+ Statistics.recordToolUsage('code-beautify');
+ }
+ });
+ };
+
+ /**
+ * 接收来自content_scripts发来的消息
+ */
+ let _addExtensionListener = function () {
+
+ _updateBrowserAction();
+
+ chrome.runtime.onMessage.addListener(function (request, sender, callback) {
+ // 如果发生了错误，就啥都别干了
+ if (chrome.runtime.lastError) {
+ return true;
+ }
+
+ // 动态安装工具或者卸载工具，需要更新browserAction
+ if (request.type === MSG_TYPE.DYNAMIC_TOOL_INSTALL_OR_OFFLOAD) {
+ _updateBrowserAction(request.action, request.showTips, request.menuOnly);
+ callback && callback();
+ }
+ // 截屏
+ else if (request.type === MSG_TYPE.CAPTURE_VISIBLE_PAGE) {
+ _captureVisibleTab(callback);
+ // 记录工具使用
+ Statistics.recordToolUsage('screenshot');
+ }
+ // 直接处理content-script.js中的截图请求
+ else if (request.type === 'fh-screenshot-capture-visible') {
+ _captureVisibleTab(callback);
+ // 记录工具使用
+ Statistics.recordToolUsage('screenshot');
+ }
+ // 打开动态工具页面
+ else if (request.type === MSG_TYPE.OPEN_DYNAMIC_TOOL) {
+ chrome.DynamicToolRunner(request);
+ // 记录工具使用
+ if (request.page) {
+ Statistics.recordToolUsage(request.page);
+ }
+ callback && callback();
+ }
+ // 打开其他页面
+ else if (request.type === MSG_TYPE.OPEN_PAGE) {
+ chrome.DynamicToolRunner({
+ tool: request.page
+ });
+ // 记录工具使用
+ if (request.page) {
+ Statistics.recordToolUsage(request.page);
+ }
+ callback && callback();
+ }
+ // 任何事件，都可以通过这个钩子来完成
+ else if (request.type === MSG_TYPE.DYNAMIC_ANY_THING) {
+ switch(request.thing){
+ // 插件选项保存成功提示
+ case 'save-options':
+ notifyText({
+ message: '配置修改已生效，请继续使用!',
+ autoClose: 2000
+ });
+ break;
+ // 触发网页截图功能
+ case 'trigger-screenshot':
+ handleTriggerScreenshot(request.tabId);
+ break;
+ // 获取JSON格式化工具的配置选项
+ case 'request-jsonformat-options':
+ requestJsonformatOptions(request.params, callback);
+ return true; // 这个返回true是非常重要的！！！要不然callback会拿不到结果
+ // 保存JSON格式化工具的配置选项
+ case 'save-jsonformat-options':
+ saveJsonformatOptions(request.params, callback);
+ return true;
+ // 切换JSON格式化工具栏显示状态
+ case 'toggle-jsonformat-options':
+ toggleJsonformatOptions(callback);
+ return true; // 这个返回true是非常重要的！！！要不然callback会拿不到结果
+ // 代码美化功能
+ case 'code-beautify':
+ _codeBeautify(request.params);
+ break;
+ // 关闭代码美化功能
+ case 'close-beautify':
+ handleCloseBeautify();
+ break;
+ // 二维码解码功能
+ case 'qr-decode':
+ handleQrDecode(request.params.uri);
+ break;
+ // 请求页面内容数据
+ case 'request-page-content':
+ handleRequestPageContent(request);
+ break;
+ // 设置页面性能时序数据
+ case 'set-page-timing-data':
+ handleSetPageTimingData(request.wpoInfo);
+ break;
+ // 颜色拾取器截图功能
+ case 'color-picker-capture':
+ _colorPickerCapture(request.params);
+ // 记录工具使用
+ Statistics.recordToolUsage('color-picker');
+ break;
+ // 分页截图功能
+ case 'add-screen-shot-by-pages':
+ _addScreenShotByPages(request.params,callback);
+ // 记录工具使用
+ Statistics.recordToolUsage('screenshot');
+ return true;
+ // 页面截图完成处理
+ case 'page-screenshot-done':
+ _showScreenShotResult(request.params);
+ break;
+ // 启动页面脚本注入（油猴功能）
+ case 'request-monkey-start':
+ Monkey.start(request.params);
+ break;
+ // 注入内容脚本CSS样式
+ case 'inject-content-css':
+ _injectContentCss(sender.tab.id,request.tool,!!request.devTool);
+ break;
+ // 打开插件选项页面
+ case 'open-options-page':
+ chrome.runtime.openOptionsPage();
+ break;
+ // 打开打赏弹窗
+ case 'open-donate-modal':
+ chrome.gotoDonateModal(request.params.toolName);
+ break;
+ // 加载本地脚本文件
+ case 'load-local-script':
+ loadLocalScript(request.script, callback);
+ return true; // 异步响应需要返回true
+ // 工具使用统计埋点
+ case 'statistics-tool-usage':
+ // 埋点：自动触发json-format-auto
+ Statistics.recordToolUsage(request.params.tool_name,request.params);
+ break;
+ // 获取热修复脚本
+ case 'fetch-hotfix-json':
+ fetchHotfixJson(callback);
+ return true; // 异步响应必须返回true
+ // 获取插件补丁数据
+ case 'fetch-fehelper-patchs':
+ fetchFehelperPatchs(callback);
+ return true;
+ // 获取指定工具的补丁
+ case 'fh-get-tool-patch':
+ getToolPatch(request.toolName, callback);
+ return true;
+ }
+ callback && callback(request.params);
+ } else {
+ callback && callback();
+ }
+
+ return true;
+ });
+
+
+ // 每开一个窗口，都向内容脚本注入一个js，绑定tabId
+ chrome.tabs.onUpdated.addListener(function (tabId, changeInfo, tab) {
+ if (String(changeInfo.status).toLowerCase() === "complete") {
+ if(/^(http(s)?|file):\/\//.test(tab.url) && blacklist.every(reg => !reg.test(tab.url))){
+ InjectTools.inject(tabId, { js: `window.__FH_TAB_ID__=${tabId};` });
+ _injectContentScripts(tabId);
+ }
+ }
+ });
+
+ // 安装与更新
+ chrome.runtime.onInstalled.addListener(({reason, previousVersion}) => {
+ switch (reason) {
+ case 'install':
+ chrome.runtime.openOptionsPage();
+ // 记录新安装用户
+ Statistics.recordInstallation();
+ break;
+ case 'update':
+ _animateTips('+++1');
+ // 记录更新安装
+ Statistics.recordUpdate(previousVersion);
+ if (previousVersion === '2019.12.2415') {
+ notifyText({
+ message: '历尽千辛万苦，FeHelper已升级到最新版本，可以到插件设置页去安装旧版功能了！',
+ autoClose: 5000
+ });
+ }
+
+ // 从V2020.02.1413版本开始，本地的数据存储大部分迁移至chrome.storage.local
+ // 这里需要对老版本升级过来的情况进行强制数据迁移
+ let getAbsNum = num => parseInt(num.split(/\./).map(n => n.padStart(4, '0')).join(''), 10);
+ // let preVN = getAbsNum(previousVersion);
+ // let minVN = getAbsNum('2020.02.1413');
+ // if (preVN < minVN) {
+ // Awesome.makeStorageUnlimited();
+ // setTimeout(() => chrome.runtime.reload(), 1000 * 5);
+ // }
+ break;
+ }
+ });
+
+ // 卸载
+ chrome.runtime.setUninstallURL(chrome.runtime.getManifest().homepage_url);
+ };
+
+ /**
+ * 检查插件更新
+ * @private
+ */
+ let _checkUpdate = function () {
+ setTimeout(() => {
+ // 检查是否为 Firefox 浏览器，Firefox 不支持 requestUpdateCheck API
+ if (chrome.runtime.requestUpdateCheck && navigator.userAgent.indexOf("Firefox") === -1) {
+ chrome.runtime.requestUpdateCheck((status) => {
+ if (status === "update_available") {
+ chrome.runtime.reload();
+ }
+ });
+ }
+ }, 1000 * 30);
+ };
+
+ /**
+ * 初始化
+ */
+ let _init = function () {
+ console.log(`[FeHelper] Background初始化开始 - ${new Date().toLocaleString()}`);
+ console.log(`[FeHelper] 扩展版本: ${chrome.runtime.getManifest().version}`);
+ console.log(`[FeHelper] Service Worker启动原因: ${chrome.runtime.getContexts ? 'Context API可用' : '传统模式'}`);
+
+ _checkUpdate();
+ _addExtensionListener();
+
+ // 初始化统计功能
+ Statistics.init();
+
+ Menu.rebuild();
+
+ // 定期清理冗余的垃圾
+ setTimeout(() => {
+ Awesome.gcLocalFiles();
+ }, 1000 * 10);
+
+ console.log(`[FeHelper] Background初始化完成 - ${new Date().toLocaleString()}`);
+ };
+
+ /**
+ * 触发截图工具的执行
+ * @param {number} tabId - 标签页ID
+ */
+ function _triggerScreenshotTool(tabId) {
+ // 先尝试直接发送消息给content script
+ chrome.tabs.sendMessage(tabId, {
+ type: 'fh-screenshot-start'
+ }).then(() => {
+ // 成功触发
+ }).catch(() => {
+ // 如果发送消息失败，使用noPage模式
+ chrome.DynamicToolRunner({
+ tool: 'screenshot',
+ noPage: true
+ });
+ });
+ }
+
+ // 监听options页面传递的客户端信息
+ chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
+ if (request && request.type === 'clientInfo' && request.data) {
+ FH_CLIENT_INFO = request.data;
+ }
+ });
+
+ // 处理从popup触发的截图请求
+ function handleTriggerScreenshot(tabId) {
+ if (tabId) {
+ _triggerScreenshotTool(tabId);
+ } else {
+ chrome.DynamicToolRunner({
+ tool: 'screenshot',
+ noPage: true
+ });
+ }
+ // 记录工具使用
+ Statistics.recordToolUsage('screenshot');
+ }
+
+ // 请求JSON格式化选项配置
+ function requestJsonformatOptions(params, callback) {
+ Awesome.StorageMgr.get(params).then(result => {
+ Object.keys(result).forEach(key => {
+ if (['MAX_JSON_KEYS_NUMBER', 'JSON_FORMAT_THEME'].includes(key)) {
+ result[key] = parseInt(result[key]);
+ } else {
+ result[key] = (""+result[key] !== 'false');
+ }
+ });
+ callback && callback(result);
+ });
+ }
+
+ // 保存JSON格式化选项配置
+ function saveJsonformatOptions(params, callback) {
+ Awesome.StorageMgr.set(params).then(() => {
+ callback && callback();
+ });
+ // 记录工具使用
+ Statistics.recordToolUsage('save-jsonformat-options');
+ }
+
+ // 切换JSON格式化选项显示状态
+ function toggleJsonformatOptions(callback) {
+ Awesome.StorageMgr.get('JSON_TOOL_BAR_ALWAYS_SHOW').then(result => {
+ let show = result !== false;
+ Awesome.StorageMgr.set('JSON_TOOL_BAR_ALWAYS_SHOW',!show).then(() => {
+ callback && callback(!show);
+ });
+ });
+ // 记录工具使用
+ Statistics.recordToolUsage('json-format');
+ }
+
+ // 关闭代码美化功能
+ function handleCloseBeautify() {
+ Awesome.StorageMgr.set('JS_CSS_PAGE_BEAUTIFY',0);
+ // 记录工具使用
+ Statistics.recordToolUsage('code-beautify-close');
+ }
+
+ // 处理二维码解码
+ function handleQrDecode(uri) {
+ chrome.DynamicToolRunner({
+ withContent: uri,
+ tool: 'qr-code',
+ query: `mode=decode`
+ });
+ // 记录工具使用
+ Statistics.recordToolUsage('qr-code');
+ }
+
+ // 处理页面内容请求
+ function handleRequestPageContent(request) {
+ request.params = FeJson[request.tabId];
+ delete FeJson[request.tabId];
+ }
+
+ // 处理页面性能数据设置
+ function handleSetPageTimingData(wpoInfo) {
+ chrome.DynamicToolRunner({
+ tool: 'page-timing',
+ withContent: wpoInfo
+ });
+ // 记录工具使用
+ Statistics.recordToolUsage('page-timing');
+ }
+
+ // 获取指定工具的补丁（css/js）
+ function getToolPatch(toolName, callback) {
+ // 如果没有提供toolName，直接返回空补丁
+ if (!toolName) {
+ callback && callback({ css: '', js: '' });
+ return;
+ }
+
+ let version = String(chrome.runtime.getManifest().version).split('.').map(n => parseInt(n)).join('.');
+ const storageKey = `FH_PATCH_HOTFIX_${version}`;
+ chrome.storage.local.get(storageKey, result => {
+ const patchs = result[storageKey];
+ if (patchs && patchs[toolName]) {
+ const { css, js } = patchs[toolName];
+ callback && callback({ css, js });
+ } else {
+ callback && callback({ css: '', js: '' });
+ }
+ });
+ }
+
+ // 加载本地脚本，处理加载JSON格式化相关脚本的请求
+ function loadLocalScript(scriptUrl, callback) {
+ fetch(scriptUrl)
+ .then(response => response.text())
+ .then(scriptContent => {
+ callback && callback(scriptContent);
+ })
+ .catch(error => {
+ console.error('加载脚本失败:', error);
+ callback && callback(null);
+ });
+ }
+
+ // 获取热修复脚本，代理请求 hotfix.json，解决CORS问题
+ function fetchHotfixJson(callback) {
+ fetch('https://fehelper.com/static/js/hotfix.json?v=' + Date.now())
+ .then(response => response.text())
+ .then(scriptContent => {
+ callback && callback({ success: true, content: scriptContent });
+ })
+ .catch(error => {
+ callback && callback({ success: false, error: error.message });
+ });
+ }
+
+ // 检查并获取补丁（带频率控制）
+ function checkAndFetchPatchs() {
+ const PATCH_CHECK_INTERVAL = 5 * 60 * 1000; // 5min
+ const STORAGE_KEY = 'FH_LAST_PATCH_CHECK';
+
+ chrome.storage.local.get(STORAGE_KEY, (result) => {
+ const lastCheck = result[STORAGE_KEY] || 0;
+ const now = Date.now();
+
+ if (now - lastCheck > PATCH_CHECK_INTERVAL) {
+ console.log(`[FeHelper] 距离上次检查已超过5min，开始检查热更新...`);
+
+ fetchFehelperPatchs((result) => {
+ if (result && result.success) {
+ console.log(`[FeHelper] 自动热更新成功，版本: v${result.version}`);
+ } else if (result && result.notFound) {
+ console.log(`[FeHelper] 当前版本暂无热更新补丁`);
+ } else {
+ console.log(`[FeHelper] 自动热更新检查失败:`, result?.error);
+ }
+
+ // 更新最后检查时间
+ chrome.storage.local.set({ [STORAGE_KEY]: now });
+ });
+ } else {
+ const nextCheck = new Date(lastCheck + PATCH_CHECK_INTERVAL);
+ console.log(`[FeHelper] 距离上次检查不足5min，下次检查时间: ${nextCheck.toLocaleString()}`);
+ }
+ });
+ }
+
+ // 获取FeHelper热修复补丁
+ function fetchFehelperPatchs(callback) {
+ let version = String(chrome.runtime.getManifest().version).split('.').map(n => parseInt(n)).join('.');
+ let patchUrl = `https://fehelper.com/v1/fh-patchs/v${version}.json`;
+
+ // 先检测文件是否存在（使用HEAD请求）
+ fetch(patchUrl, { method: 'HEAD' })
+ .then(response => {
+ if (response.ok) {
+ // 文件存在，进行正常的fetch操作
+ return fetch(`${patchUrl}?t=${Date.now()}`)
+ .then(resp => {
+ if (!resp.ok) {
+ throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+ }
+ return resp.json();
+ })
+ .then(data => {
+ const patchs = data.patchs || data;
+ const storageData = {};
+ storageData[`FH_PATCH_HOTFIX_${version}`] = patchs;
+ chrome.storage.local.set(storageData, () => {
+ console.log(`[FeHelper] 成功获取版本 v${version} 的热修复补丁`);
+ callback && callback({ success: true, version });
+ });
+ });
+ } else {
+ // 文件不存在
+ console.log(`[FeHelper] 服务器上不存在版本 v${version} 的补丁文件`);
+ callback && callback({ success: false, error: '补丁文件不存在', notFound: true });
+ }
+ })
+ .catch(e => {
+ callback && callback({ success: false, error: '没有需要修复的补丁' });
+ });
+ }
+
+ return {
+ pageCapture: _captureVisibleTab,
+ init: _init
+ };
+})();
+
+BgPageInstance.init();
\ No newline at end of file
diff --git a/apps/background/crx-download.js b/apps/background/crx-download.js
new file mode 100644
index 00000000..a11655d6
--- /dev/null
+++ b/apps/background/crx-download.js
@@ -0,0 +1,147 @@
+/**
+ * FeHelper：从chrome webstore下载extension文件的工具
+ * @author zhaoxianlie
+ */
+
+import MSG_TYPE from '../static/js/common.js';
+
+export default (function () {
+
+ let FeJson = {notifyTimeoutId:-1};
+ /**
+ * 文本格式，可以设置一个图标和标题
+ * @param {Object} options
+ * @config {string} type notification的类型，可选值：html、text
+ * @config {string} icon 图标
+ * @config {string} title 标题
+ * @config {string} message 内容
+ */
+ let notifyText = function (options) {
+ let notifyId = 'FeJson-notify-id';
+ if(typeof options === 'string') {
+ options = {message: options};
+ }
+ clearTimeout(FeJson.notifyTimeoutId);
+ if (options.closeImmediately) {
+ return chrome.notifications.clear(notifyId);
+ }
+
+ if (!options.icon) {
+ options.icon = "static/img/fe-48.png";
+ }
+ if (!options.title) {
+ options.title = "温馨提示";
+ }
+ chrome.notifications.create(notifyId, {
+ type: 'basic',
+ title: options.title,
+ iconUrl: chrome.runtime.getURL(options.icon),
+ message: options.message
+ });
+
+ FeJson.notifyTimeoutId = setTimeout(() => {
+ chrome.notifications.clear(notifyId);
+ }, parseInt(options.autoClose || 3000, 10));
+
+ };
+
+ /**
+ * 检测Google chrome服务能不能访问，在2s内检测心跳
+ * @param success
+ * @param failure
+ */
+ let detectGoogleDotCom = function (success, failure) {
+ Promise.race([
+ fetch('https://clients2.google.com/service/update2/crx'),
+ new Promise(function (resolve, reject) {
+ setTimeout(() => reject(new Error('request timeout')), 2000)
+ })])
+ .then((data) => {
+ success && success();
+ }).catch(() => {
+ failure && failure();
+ });
+ };
+
+ /**
+ * 从google官方渠道下载chrome扩展
+ * @param crxId 需要下载的extension id
+ * @param crxName 扩展名称
+ * @param callback 下载动作结束后的回调
+ */
+ let downloadCrxFileByCrxId = function (crxId, crxName, callback) {
+ detectGoogleDotCom(() => {
+ // google可以正常访问，则正常下载
+ let url = "https://clients2.google.com/service/update2/crx?response=redirect&acceptformat=crx2,crx3&x=id%3D"
+ + crxId + "%26uc&prodversion=" + navigator.userAgent.split("Chrome/")[1].split(" ")[0];
+ if (!chrome.downloads) {
+ let a = document.createElement('a');
+ a.href = url;
+ a.download = crxName || (crxId + '.crx');
+ (document.body || document.documentElement).appendChild(a);
+ a.click();
+ a.remove();
+ } else {
+ chrome.downloads.download({
+ url: url,
+ filename: crxName || crxId,
+ conflictAction: 'overwrite',
+ saveAs: true
+ }, function (downloadId) {
+ if (chrome.runtime.lastError) {
+ notifyText('抱歉，下载失败！错误信息：' + chrome.runtime.lastError.message);
+ }
+ });
+ }
+ }, () => {
+ // google不能正常访问
+ callback ? callback() : notifyText('抱歉，下载失败！');
+ });
+
+ };
+
+ /**
+ * 从chrome webstore下载crx文件
+ * 在chrome extension详情页使用
+ */
+ let downloadCrxFileFromWebStoreDetailPage = function (callback) {
+
+ chrome.tabs.query({active: true, currentWindow: true}, function (tabs) {
+ let tab = tabs[0];
+ let crxId = tab.url.split("/")[6].split('?')[0];
+ let crxName = tab.title.split(" - Chrome")[0] + ".crx";
+ crxName = crxName.replace(/[&\/\\:"*<>|?]/g, '');
+
+ downloadCrxFileByCrxId(crxId, crxName, callback);
+ });
+ };
+
+ /**
+ * 通过右键菜单下载或者分享crx
+ * @param tab
+ * @private
+ */
+ let _downloadCrx = function (tab) {
+ let isWebStoreDetailPage = tab.url.indexOf('https://chrome.google.com/webstore/detail/') === 0;
+ if (isWebStoreDetailPage) {
+ // 如果是某个chrome extension的详情页面了，直接下载当前crx文件
+ downloadCrxFileFromWebStoreDetailPage(() => {
+ notifyText('下载失败，可能是当前网络无法访问Google站点！');
+ });
+ } else {
+ // 否则，下载FeHelper并分享出去
+ let crxId = MSG_TYPE.STABLE_EXTENSION_ID;
+ let crxName = chrome.runtime.getManifest().name + '-latestVersion.crx';
+
+ downloadCrxFileByCrxId(crxId, crxName, () => {
+ chrome.tabs.create({
+ url: MSG_TYPE.DOWNLOAD_FROM_GITHUB
+ });
+ });
+ }
+ };
+
+ return {
+ downloadCrx: _downloadCrx
+ };
+})();
diff --git a/apps/background/inject-tools.js b/apps/background/inject-tools.js
new file mode 100644
index 00000000..ffada1aa
--- /dev/null
+++ b/apps/background/inject-tools.js
@@ -0,0 +1,74 @@
+import Settings from '../options/settings.js';
+
+export default (() => {
+ /**
+ * 如果tabId指定的tab还存在，就正常注入脚本
+ * @param tabId 需要注入脚本的tabId
+ * @param codeConfig 需要注入的代码
+ * @param callback 注入代码后的callback
+ */
+ let injectScriptIfTabExists = function (tabId, codeConfig, callback) {
+ chrome.tabs.query({currentWindow: true}, (tabs) => {
+ tabs.some(tab => {
+ if (tab.id !== tabId) return false;
+ Settings.getOptions((opts) => {
+
+ if (!codeConfig.hasOwnProperty('allFrames')) {
+ codeConfig.allFrames = String(opts['CONTENT_SCRIPT_ALLOW_ALL_FRAMES']) === 'true';
+ }
+
+ codeConfig.js = 'try{' + codeConfig.js + ';}catch(e){};';
+ // 有文件就注入文件
+ if(codeConfig.files && codeConfig.files.length){
+ // 注入样式
+ if(codeConfig.files.join(',').indexOf('.css') > -1) {
+ chrome.scripting.insertCSS({
+ target: {tabId, allFrames: codeConfig.allFrames},
+ files: codeConfig.files
+ }, function () {
+ callback && callback.apply(this, arguments);
+ });
+ }
+ // 注入js
+ else {
+ chrome.scripting.executeScript({
+ target: {tabId, allFrames: codeConfig.allFrames},
+ files: codeConfig.files
+ }, function () {
+ chrome.scripting.executeScript({
+ target: {tabId, allFrames: codeConfig.allFrames},
+ func: function(code){try{evalCore.getEvalInstance(window)(code)}catch(x){}},
+ args: [codeConfig.js]
+ }, function () {
+ callback && callback.apply(this, arguments);
+ });
+ });
+ }
+ }else if(codeConfig.css){
+ // 注入css样式
+ chrome.scripting.executeScript({
+ target: {tabId, allFrames: codeConfig.allFrames},
+ css:codeConfig.css
+ }, function () {
+ callback && callback.apply(this, arguments);
+ });
+ }else{
+ // 注入js脚本
+ chrome.scripting.executeScript({
+ target: {tabId, allFrames: codeConfig.allFrames},
+ func: function(code){try{evalCore.getEvalInstance(window)(code)}catch(x){}},
+ args: [codeConfig.js]
+ }, function () {
+ callback && callback.apply(this, arguments);
+ });
+ }
+
+ });
+
+ return true;
+ });
+ });
+ };
+
+ return { inject: injectScriptIfTabExists };
+})();
diff --git a/apps/background/menu.js b/apps/background/menu.js
new file mode 100644
index 00000000..55af2292
--- /dev/null
+++ b/apps/background/menu.js
@@ -0,0 +1,236 @@
+/**
+ * FeHelper 右键菜单管理
+ * @type {{manage}}
+ * @author zhaoxianlie
+ */
+
+import CrxDownloader from './crx-download.js';
+import Awesome from './awesome.js';
+import toolMap from './tools.js';
+import Settings from '../options/settings.js';
+
+export default (function () {
+
+ let FeJson = {
+ contextMenuId:"fhm_main"
+ };
+
+ // 邮件菜单配置项
+ let defaultMenuOptions = {
+ 'download-crx': {
+ icon: '♥',
+ text: '插件下载分享',
+ onClick: function (info, tab) {
+ CrxDownloader.downloadCrx(tab);
+ }
+ },
+ 'fehelper-setting': {
+ icon: '❂',
+ text: 'FeHelper设置',
+ onClick: function (info, tab) {
+ chrome.runtime.openOptionsPage();
+ }
+ }
+ };
+
+ // 初始化菜单配置
+ let _initMenuOptions = (() => {
+
+ Object.keys(toolMap).forEach(tool => {
+ // context-menu
+ switch (tool) {
+ case 'json-format':
+ toolMap[tool].menuConfig[0].onClick = function (info, tab) {
+ chrome.scripting.executeScript({
+ target: {tabId:tab.id,allFrames:false},
+ args: [info.selectionText || ''],
+ func: (text) => text
+ }, resp => chrome.DynamicToolRunner({
+ tool, withContent: resp[0].result
+ }));
+ };
+ break;
+
+ case 'code-beautify':
+ case 'en-decode':
+ toolMap[tool].menuConfig[0].onClick = function (info, tab) {
+ chrome.scripting.executeScript({
+ target: {tabId:tab.id,allFrames:false},
+ args: [info.linkUrl || info.srcUrl || info.selectionText || info.pageUrl || ''],
+ func: (text) => text
+ }, resp => chrome.DynamicToolRunner({
+ tool, withContent: resp[0].result
+ }));
+ };
+ break;
+
+ case 'qr-code':
+ toolMap[tool].menuConfig[0].onClick = function (info, tab) {
+ chrome.scripting.executeScript({
+ target: {tabId:tab.id,allFrames:false},
+ args: [info.linkUrl || info.srcUrl || info.selectionText || info.pageUrl || tab.url || ''],
+ func: (text) => text
+ }, resp => chrome.DynamicToolRunner({
+ tool, withContent: resp[0].result
+ }));
+ };
+ toolMap[tool].menuConfig[1].onClick = function (info, tab) {
+ chrome.scripting.executeScript({
+ target: {tabId:tab.id,allFrames:false},
+ args: [info.srcUrl || ''],
+ func: (text) => {
+ try {
+ if (typeof window.qrcodeContentScript === 'function') {
+ let qrcode = window.qrcodeContentScript();
+ if (typeof qrcode.decode === 'function') {
+ qrcode.decode(text);
+ return 1;
+ }
+ }
+ } catch (e) {
+ return 0;
+ }
+ }
+ });
+ };
+ break;
+
+ default:
+ toolMap[tool].menuConfig[0].onClick = function (info, tab) {
+ chrome.DynamicToolRunner({
+ tool, withContent: tool === 'image-base64' ? info.srcUrl : ''
+ })
+ };
+ break;
+ }
+ });
+ })();
+
+ /**
+ * 创建一个menu 菜单
+ * @param toolName
+ * @param menuList
+ * @returns {boolean}
+ * @private
+ */
+ let _createItem = (toolName, menuList) => {
+ menuList && menuList.forEach && menuList.forEach(menu => {
+
+ // 确保每次创建出来的是一个新的主菜单，防止onClick事件冲突
+ let menuItemId = 'fhm_c' + escape(menu.text).replace(/\W/g,'') + new Date*1;
+
+ chrome.contextMenus.create({
+ id: menuItemId,
+ title: menu.icon + ' ' + menu.text,
+ contexts: menu.contexts || ['all'],
+ parentId: FeJson.contextMenuId
+ });
+
+ chrome.contextMenus.onClicked.addListener(((tool,mId,mFunc) => (info, tab) => {
+ if(info.menuItemId === mId) {
+ if(mFunc) {
+ mFunc(info,tab);
+ }else{
+ chrome.DynamicToolRunner({ tool });
+ }
+ }
+ })(toolName,menuItemId,menu.onClick));
+ });
+ };
+
+
+ /**
+ * 绘制一条分割线
+ * @private
+ */
+ let _createSeparator = function () {
+ chrome.contextMenus.create({
+ id: 'fhm_s' + Math.ceil(Math.random()*10e9),
+ type: 'separator',
+ parentId: FeJson.contextMenuId
+ });
+ };
+
+ /**
+ * 创建扩展专属的右键菜单
+ */
+ let _initMenus = function () {
+ _removeContextMenu(() => {
+ let id = chrome.contextMenus.create({
+ id: FeJson.contextMenuId ,
+ title: "FeHelper",
+ contexts: ['page', 'selection', 'editable', 'link', 'image'],
+ documentUrlPatterns: ['http://*/*', 'https://*/*', 'file://*/*']
+ });
+
+ // 绘制用户安装的菜单，放在前面
+ Awesome.getInstalledTools().then(tools => {
+ let allMenus = Object.keys(tools).filter(tool => tools[tool].installed && tools[tool].menu);
+ let onlineTools = allMenus.filter(tool => tool !== 'devtools' && !tools[tool].hasOwnProperty('_devTool'));
+ let devTools = allMenus.filter(tool => tool === 'devtools' || tools[tool].hasOwnProperty('_devTool'));
+
+ // 绘制FH提供的工具菜单
+ onlineTools.forEach(tool => _createItem(tool, tools[tool].menuConfig));
+ // 如果有本地工具的菜单需要绘制，则需要加一条分割线
+ devTools.length && _createSeparator();
+ // 绘制本地工具的菜单
+ devTools.forEach(tool => {
+ // 说明是自定义工具 构造menuConfig
+ if(!tools[tool].menuConfig) {
+ tools[tool].menuConfig = [{
+ icon: tools[tool].icon,
+ text: tools[tool].name,
+ onClick: (info, tab) => {
+ chrome.DynamicToolRunner({
+ page: 'dynamic',
+ noPage: !!tools[tool].noPage,
+ query: `tool=${tool}`
+ });
+ !!tools[tool].noPage && setTimeout(window.close, 200);
+ }
+ }];
+ }
+ _createItem(tool, tools[tool].menuConfig)
+ });
+ });
+
+ // 绘制两个系统提供的菜单，放到最后
+ let sysMenu = ['download-crx', 'fehelper-setting'];
+ let arrPromises = sysMenu.map(menu => Awesome.menuMgr(menu, 'get'));
+ Promise.all(arrPromises).then(values => {
+ let needDraw = String(values[0]) === '1' || String(values[1]) !== '0';
+
+ // 绘制一条分割线
+ _createSeparator();
+
+ // 绘制菜单
+ String(values[0]) === '1' && _createItem(sysMenu[0], [defaultMenuOptions[sysMenu[0]]]);
+ String(values[1]) !== '0' && _createItem(sysMenu[1], [defaultMenuOptions[sysMenu[1]]]);
+ });
+ });
+ };
+
+ /**
+ * 移除扩展专属的右键菜单
+ */
+ let _removeContextMenu = function (callback) {
+ chrome.contextMenus.removeAll(callback);
+ };
+
+ /**
+ * 创建或移除扩展专属的右键菜单
+ */
+ let _createOrRemoveContextMenu = function () {
+ Settings.getOptions((opts) => {
+ if (String(opts['OPT_ITEM_CONTEXTMENUS']) !== 'false') {
+ _initMenus();
+ } else {
+ _removeContextMenu();
+ }
+ });
+ };
+
+ return {
+ rebuild: _createOrRemoveContextMenu
+ };
+})();
diff --git a/apps/background/monkey.js b/apps/background/monkey.js
new file mode 100644
index 00000000..d994d9e5
--- /dev/null
+++ b/apps/background/monkey.js
@@ -0,0 +1,102 @@
+import InjectTools from './inject-tools.js';
+import Statistics from './statistics.js';
+
+export default (() => {
+ let start = (params) => {
+ try {
+ const PAGE_MONKEY_LOCAL_STORAGE_KEY = 'PAGE-MODIFIER-LOCAL-STORAGE-KEY';
+
+ let handler = monkeys => {
+ monkeys.filter(cm => !cm.mDisabled).forEach(cm => {
+ let result = null;
+ let matched = cm.mPattern.match(/^\/(.*)\/(.*)?$/);
+ if (matched && ( !matched[2] || matched[2] && !/[^igm]*/i.test(matched[2]))) {
+ // 正则，直接匹配
+ cm.mPattern = new RegExp(matched[1], matched[2] || "");
+ result = cm.mPattern.test(params.url) && cm;
+ } else if (cm.mPattern.indexOf('*') > -1) {
+ if (cm.mPattern.startsWith('*://')) {
+ cm.mPattern = cm.mPattern.replace('*://', '(http|https|file)://');
+ } else if (cm.mPattern.indexOf('://') < 0) {
+ cm.mPattern = '(http|https|file)://' + cm.mPattern;
+ }
+
+ // 通配符，则转换为正则再匹配
+ cm.mPattern = new RegExp('^' + cm.mPattern.replace(/\./g,'\\.').replace(/\//g, '\\/').replace(/\*/g, '.*').replace(/\?/g, '\\?') + '$');
+ result = cm.mPattern.test(params.url) && cm;
+ } else {
+ // 绝对地址，直接比对
+ let arr = [cm.mPattern, `${cm.mPattern}/`];
+ if (!cm.mPattern.startsWith('http://') && !cm.mPattern.startsWith('https://')) {
+ arr = arr.concat([`http://${cm.mPattern}`, `http://${cm.mPattern}/`,
+ `https://${cm.mPattern}`, `https://${cm.mPattern}/`]);
+ }
+ if (arr.includes(params.url)) {
+ result = cm;
+ }
+ }
+
+ if (result) {
+ let scripts = '(' + ((monkey) => {
+ let injectFunc = () => {
+ // 执行脚本
+ try{evalCore.getEvalInstance(window)(monkey.mScript)}catch(x){}
+
+ parseInt(monkey.mRefresh) && setTimeout(() => {
+ location.reload(true);
+ }, parseInt(monkey.mRefresh) * 1000);
+ };
+
+ window._fhImportJs = js => {
+ return fetch(js).then(resp => resp.text()).then(jsText => {
+ if(window.evalCore && window.evalCore.getEvalInstance){
+ return window.evalCore.getEvalInstance(window)(jsText);
+ }
+ let el = document.createElement('script');
+ el.textContent = jsText;
+ document.head.appendChild(el);
+ });
+ };
+
+ let jsFiles = (monkey.mRequireJs || '').split(/[\s,，]+/).filter(js => js.length);
+ if (jsFiles.length) {
+ let arrPromise = Array.from(new Set(jsFiles)).map(js => window._fhImportJs(js));
+ Promise.all(arrPromise).then(injectFunc);
+ } else {
+ injectFunc();
+ }
+ }).toString() + `)(${JSON.stringify(result)})`;
+ InjectTools.inject(params.tabId, {js: scripts, allFrames: false});
+ }
+ });
+ };
+
+ chrome.storage.local.get(PAGE_MONKEY_LOCAL_STORAGE_KEY, (resps) => {
+ let cacheMonkeys, storageMode = false;
+ if ((!resps || !resps[PAGE_MONKEY_LOCAL_STORAGE_KEY]) && typeof localStorage !== 'undefined') {
+ cacheMonkeys = localStorage.getItem(PAGE_MONKEY_LOCAL_STORAGE_KEY) || '[]';
+ storageMode = true;
+ } else {
+ cacheMonkeys = resps[PAGE_MONKEY_LOCAL_STORAGE_KEY] || '[]';
+ }
+
+ if(params && params.url){
+ handler(JSON.parse(cacheMonkeys));
+ }
+
+ // 本地存储的内容，需要全部迁移到chrome.storage.local中，以确保unlimitedStorage
+ if (storageMode) {
+ let storageData = {};
+ storageData[PAGE_MONKEY_LOCAL_STORAGE_KEY] = cacheMonkeys;
+ chrome.storage.local.set(storageData);
+ }
+ });
+
+ } catch (e) {
+ console.log('monkey error',e);
+ }
+ return true;
+ };
+
+ return {start};
+})();
diff --git a/apps/background/statistics.js b/apps/background/statistics.js
new file mode 100644
index 00000000..cf4e0a9b
--- /dev/null
+++ b/apps/background/statistics.js
@@ -0,0 +1,427 @@
+/**
+ * FeHelper数据统计模块
+ * @author fehelper
+ */
+
+import Awesome from './awesome.js';
+
+// 数据上报服务器地址
+let manifest = chrome.runtime.getManifest();
+let SERVER_TRACK_URL = '';
+if (manifest.name && manifest.name.endsWith('-Dev')) {
+ // SERVER_TRACK_URL = 'http://localhost:3001/api/track';
+ SERVER_TRACK_URL = 'https://chrome.fehelper.com/api/track';
+} else {
+ SERVER_TRACK_URL = 'https://chrome.fehelper.com/api/track';
+}
+
+// 用户ID存储键名
+const USER_ID_KEY = 'FH_USER_ID';
+// 上次使用日期存储键名
+const LAST_ACTIVE_DATE_KEY = 'FH_LAST_ACTIVE_DATE';
+// 用户日常使用数据存储键名
+const USER_USAGE_DATA_KEY = 'FH_USER_USAGE_DATA';
+
+// 记录background启动时间
+const FH_TIME_OPENED = Date.now();
+
+let Statistics = (function() {
+
+ // 用户唯一标识
+ let userId = '';
+
+ // 今天的日期字符串 YYYY-MM-DD
+ let todayStr = new Date().toISOString().split('T')[0];
+
+ // 本地存储的使用数据
+ let usageData = {
+ dailyUsage: {}, // 按日期存储的使用记录
+ tools: {} // 各工具的使用次数
+ };
+
+ /**
+ * 生成唯一的用户ID
+ * @returns {string} 用户ID
+ */
+ const generateUserId = () => {
+ return 'fh_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+ };
+
+ /**
+ * 获取或创建用户ID
+ * @returns {Promise} 用户ID
+ */
+ const getUserId = async () => {
+ if (userId) return userId;
+
+ try {
+ const result = await Awesome.StorageMgr.get(USER_ID_KEY);
+ if (result) {
+ userId = result;
+ } else {
+ userId = generateUserId();
+ await Awesome.StorageMgr.set(USER_ID_KEY, userId);
+ }
+ return userId;
+ } catch (error) {
+ console.error('获取用户ID失败:', error);
+ return generateUserId(); // 失败时生成临时ID
+ }
+ };
+
+ /**
+ * 加载本地存储的使用数据
+ * @returns {Promise}
+ */
+ const loadUsageData = async () => {
+ try {
+ const data = await Awesome.StorageMgr.get(USER_USAGE_DATA_KEY);
+ if (data) {
+ usageData = JSON.parse(data);
+ }
+ } catch (error) {
+ console.error('加载使用数据失败:', error);
+ }
+ };
+
+ /**
+ * 保存使用数据到本地存储
+ * @returns {Promise}
+ */
+ const saveUsageData = async () => {
+ try {
+ await Awesome.StorageMgr.set(USER_USAGE_DATA_KEY, JSON.stringify(usageData));
+ } catch (error) {
+ console.error('保存使用数据失败:', error);
+ }
+ };
+
+ /**
+ * 获取客户端详细信息（仅background可用字段，兼容service worker环境，字段与服务端一致）
+ * @returns {Object}
+ */
+ const getClientInfo = async () => {
+ const nav = self.navigator || {};
+ // 只采集服务端需要的字段
+ return {
+ userAgent: nav.userAgent || '',
+ language: nav.language || '',
+ platform: nav.platform || '',
+ extensionVersion: chrome.runtime.getManifest().version
+ };
+ };
+
+ /**
+ * 判断是否允许统计
+ * @returns {Promise} true=允许，false=禁止
+ */
+ const isStatisticsAllowed = async () => {
+ try {
+ const forbid = await Awesome.StorageMgr.get('FORBID_STATISTICS');
+ return !(forbid === true || forbid === 'true');
+ } catch (e) {
+ return true;
+ }
+ };
+
+ /**
+ * 使用自建服务器发送事件数据
+ * @param {string} eventName - 事件名称
+ * @param {Object} params - 事件参数
+ */
+ const sendToServer = async (eventName, params = {}) => {
+ return ''; // 暂时关闭统计
+ if (!(await isStatisticsAllowed())) return;
+ const uid = await getUserId();
+ const clientInfo = await getClientInfo();
+ // 只保留服务端 TrackSchema 需要的字段
+ const payload = {
+ event: eventName,
+ userId: uid,
+ ...clientInfo
+ };
+ // 只允许 TrackSchema 里的字段
+ const allowedFields = [
+ 'tool_name', 'extensionVersion', 'browser', 'browserVersion', 'os', 'osVersion', 'IP', 'language', 'platform'
+ ];
+ for (const key of allowedFields) {
+ if (params[key] !== undefined) {
+ payload[key] = params[key];
+ }
+ }
+ try {
+ fetch(SERVER_TRACK_URL, {
+ method: 'POST',
+ body: JSON.stringify(payload),
+ headers: {
+ 'Content-Type': 'application/json'
+ },
+ keepalive: true
+ }).catch(e => console.log('自建统计服务器发送失败:', e));
+ } catch (error) {
+ console.log('自建统计发送失败:', error);
+ }
+ };
+
+ /**
+ * 记录每日活跃用户
+ * @returns {Promise}
+ */
+ const recordDailyActiveUser = async () => {
+ try {
+ // 获取上次活跃日期
+ const lastActiveDate = await Awesome.StorageMgr.get(LAST_ACTIVE_DATE_KEY);
+
+ // 如果今天还没有记录，则记录今天的活跃
+ if (lastActiveDate !== todayStr) {
+ await Awesome.StorageMgr.set(LAST_ACTIVE_DATE_KEY, todayStr);
+
+ // 确保该日期的记录存在
+ if (!usageData.dailyUsage[todayStr]) {
+ usageData.dailyUsage[todayStr] = {
+ date: todayStr,
+ tools: {}
+ };
+ }
+
+ // 发送每日活跃记录到自建服务器
+ sendToServer('daily_active_user', {
+ date: todayStr
+ });
+ }
+ } catch (error) {
+ console.error('记录日活跃用户失败:', error);
+ }
+ };
+
+ /**
+ * 记录插件安装事件
+ */
+ const recordInstallation = async () => {
+ sendToServer('extension_installed');
+ };
+
+ /**
+ * 记录插件更新事件
+ * @param {string} previousVersion - 更新前的版本
+ */
+ const recordUpdate = async (previousVersion) => {
+ sendToServer('extension_updated', {
+ previous_version: previousVersion
+ });
+ };
+
+ /**
+ * 记录插件卸载事件
+ */
+ const recordUninstall = async () => {
+ sendToServer('extension_uninstall');
+ };
+
+ /**
+ * 记录工具使用情况
+ * @param {string} toolName - 工具名称
+ */
+ const recordToolUsage = async (toolName, params = {}) => {
+ // 确保今天的记录存在
+ if (!usageData.dailyUsage[todayStr]) {
+ usageData.dailyUsage[todayStr] = {
+ date: todayStr,
+ tools: {}
+ };
+ }
+
+ // 增加工具使用计数
+ if (!usageData.tools[toolName]) {
+ usageData.tools[toolName] = 0;
+ }
+ usageData.tools[toolName]++;
+
+ // 增加今天该工具的使用计数
+ if (!usageData.dailyUsage[todayStr].tools[toolName]) {
+ usageData.dailyUsage[todayStr].tools[toolName] = 0;
+ }
+ usageData.dailyUsage[todayStr].tools[toolName]++;
+
+ // 保存使用数据
+ await saveUsageData();
+
+ // 发送工具使用记录到自建服务器
+ sendToServer('tool_used', {
+ tool_name: toolName,
+ date: todayStr,
+ ...params
+ });
+ };
+
+ /**
+ * 定期发送使用摘要数据
+ */
+ const scheduleSyncStats = () => {
+ // 每周发送一次摘要数据
+ const ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
+ setInterval(async () => {
+ // 发送工具使用排名
+ const toolRanking = Object.entries(usageData.tools)
+ .sort((a, b) => b[1] - a[1])
+ .slice(0, 5)
+ .map(([name, count]) => ({name, count}));
+
+ sendToServer('usage_summary', {
+ top_tools: JSON.stringify(toolRanking)
+ });
+
+ // 清理过旧的日期数据（保留30天数据）
+ const now = new Date();
+ const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+ const thirtyDaysAgoStr = thirtyDaysAgo.toISOString().split('T')[0];
+
+ Object.keys(usageData.dailyUsage).forEach(date => {
+ if (date < thirtyDaysAgoStr) {
+ delete usageData.dailyUsage[date];
+ }
+ });
+
+ // 保存清理后的数据
+ await saveUsageData();
+ }, ONE_WEEK);
+ };
+
+ /**
+ * 初始化统计模块
+ */
+ const init = async () => {
+ await getUserId();
+ await loadUsageData();
+ await recordDailyActiveUser();
+ scheduleSyncStats();
+ };
+
+ /**
+ * 获取最近使用的工具（按最近使用时间倒序，默认最近10个）
+ * @param {number} limit - 返回的最大数量
+ * @returns {Promise} 工具名称数组
+ */
+ const getRecentUsedTools = async (limit = 10) => {
+ // 确保数据已加载
+ await loadUsageData();
+ // 收集所有日期，按新到旧排序
+ const dates = Object.keys(usageData.dailyUsage).sort((a, b) => b.localeCompare(a));
+ const toolSet = [];
+ for (const date of dates) {
+ const tools = Object.keys(usageData.dailyUsage[date].tools || {});
+ for (const tool of tools) {
+ if (!toolSet.includes(tool)) {
+ toolSet.push(tool);
+ if (toolSet.length >= limit) {
+ return toolSet;
+ }
+ }
+ }
+ }
+ return toolSet;
+ };
+
+ /**
+ * 获取DashBoard统计数据
+ * @returns {Promise 
FeHelper：AI（智能助手）
+ ❤ 打赏鼓励
+ 探索更多实用工具 工具市场
+
+ 历史对话
+
+
+ 开启新对话
+
+ 