├── .dev.vars.template
├── .github
└── workflows
│ └── release.yml
├── .gitignore
├── LICENSE
├── README.md
├── package.json
├── pnpm-lock.yaml
├── public
├── favicon.ico
├── index.css
├── index.html
├── index.js
├── logo.svg
└── og.svg
├── scripts
├── backup.go
├── banner.go
├── build.bat
├── build.sh
├── config.go
├── cron.go
├── go.mod
├── install.go
├── log.go
├── main.go
├── menu.go
├── network.go
├── types.go
├── uninstall.go
└── utils.go
├── src
├── constants.ts
├── env.d.ts
├── index.ts
├── scheduled.ts
├── services
│ ├── __tests__
│ │ └── hosts.test.ts
│ └── hosts.ts
└── types.ts
├── tsconfig.json
├── vitest.config.ts
└── wrangler.toml
/.dev.vars.template:
--------------------------------------------------------------------------------
1 | [vars]
2 | API_KEY = ""
3 |
--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
1 | name: Release Go Binaries
2 |
3 | on:
4 | push:
5 | tags:
6 | - "v*"
7 |
8 | jobs:
9 | release:
10 | name: Release
11 | runs-on: ubuntu-latest
12 | permissions:
13 | contents: write # 添加写入权限
14 |
15 | steps:
16 | - name: Checkout code
17 | uses: actions/checkout@v4
18 |
19 | - name: Set up Go
20 | uses: actions/setup-go@v4
21 | with:
22 | go-version: "1.22" # Updated to latest stable version
23 |
24 | - name: Build binaries
25 | working-directory: ./scripts
26 | run: |
27 | # Windows 版本
28 | GOOS=windows GOARCH=amd64 go build -ldflags="-s -w -X main.Version=${GITHUB_REF_NAME}" -o ../github-hosts.windows-amd64.exe .
29 | GOOS=windows GOARCH=386 go build -ldflags="-s -w -X main.Version=${GITHUB_REF_NAME}" -o ../github-hosts.windows-386.exe .
30 |
31 | # macOS 版本
32 | GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w -X main.Version=${GITHUB_REF_NAME}" -o ../github-hosts.darwin-amd64 .
33 | GOOS=darwin GOARCH=arm64 go build -ldflags="-s -w -X main.Version=${GITHUB_REF_NAME}" -o ../github-hosts.darwin-arm64 .
34 |
35 | # Linux 版本
36 | GOOS=linux GOARCH=amd64 go build -ldflags="-s -w -X main.Version=${GITHUB_REF_NAME}" -o ../github-hosts.linux-amd64 .
37 | GOOS=linux GOARCH=386 go build -ldflags="-s -w -X main.Version=${GITHUB_REF_NAME}" -o ../github-hosts.linux-386 .
38 | GOOS=linux GOARCH=arm64 go build -ldflags="-s -w -X main.Version=${GITHUB_REF_NAME}" -o ../github-hosts.linux-arm64 .
39 |
40 | cd .. # Return to root directory for zip operations
41 |
42 | # 创建 ZIP 包（包含二进制文件）
43 | zip -j github-hosts.windows-amd64.zip github-hosts.windows-amd64.exe
44 | zip -j github-hosts.windows-386.zip github-hosts.windows-386.exe
45 | zip -j github-hosts.darwin-amd64.zip github-hosts.darwin-amd64
46 | zip -j github-hosts.darwin-arm64.zip github-hosts.darwin-arm64
47 | zip -j github-hosts.linux-amd64.zip github-hosts.linux-amd64
48 | zip -j github-hosts.linux-386.zip github-hosts.linux-386
49 | zip -j github-hosts.linux-arm64.zip github-hosts.linux-arm64
50 |
51 | - name: Create Release
52 | uses: softprops/action-gh-release@v2
53 | with:
54 | files: |
55 | github-hosts.windows-amd64.exe
56 | github-hosts.windows-386.exe
57 | github-hosts.darwin-amd64
58 | github-hosts.darwin-arm64
59 | github-hosts.linux-amd64
60 | github-hosts.linux-386
61 | github-hosts.linux-arm64
62 | github-hosts.windows-amd64.zip
63 | github-hosts.windows-386.zip
64 | github-hosts.darwin-amd64.zip
65 | github-hosts.darwin-arm64.zip
66 | github-hosts.linux-amd64.zip
67 | github-hosts.linux-386.zip
68 | github-hosts.linux-arm64.zip
69 | draft: true
70 | prerelease: false
71 | generate_release_notes: true
72 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # prod
2 | dist/
3 |
4 | # dev
5 | .yarn/
6 | !.yarn/releases
7 | .vscode/*
8 | !.vscode/launch.json
9 | !.vscode/*.code-snippets
10 | .idea/workspace.xml
11 | .idea/usage.statistics.xml
12 | .idea/shelf
13 |
14 | # deps
15 | node_modules/
16 | .wrangler
17 |
18 | # env
19 | .env
20 | .env.production
21 | .dev.vars
22 |
23 |
24 | # logs
25 | logs/
26 | *.log
27 | npm-debug.log*
28 | yarn-debug.log*
29 | yarn-error.log*
30 | pnpm-debug.log*
31 | lerna-debug.log*
32 |
33 | # misc
34 | .DS_Store
35 | .idea
36 |
37 | build
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2024 TinsFox
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
github-hosts
4 |
GitHub 访问加速，解决 GitHub 访问慢的问题。使用 Cloudflare Workers 和公共 DNS API 来获取 IP 地址。
5 |
📝 项目介绍
54 | GitHub 访问加速，解决 GitHub 访问慢的问题。使用 Cloudflare Workers 和公共 DNS API 来获取 IP 地址。
55 | 感谢 GitHub520 提供的灵感。
56 |
57 | 🚀 特点
58 |
59 | - 使用 Cloudflare Workers 部署，无需服务器
60 | - 使用 Cloudflare DNS (1.1.1.1) 和 Google DNS 进行域名解析
61 | - 使用 Cloudflare KV 存储数据，确保高可用性
62 | - 提供 REST API 接口
63 | - 每 60 分钟自动更新一次 DNS 记录
64 |
65 |
66 | 💻 使用方法
67 | 1. 命令行工具（推荐）
68 |
69 | MacOS 用户
70 | sudo curl -fsSL https://github.com/TinsFox/github-hosts/releases/download/v0.0.1/github-hosts.darwin-arm64 -o github-hosts && sudo chmod +x ./github-hosts && ./github-hosts
71 |
72 |
73 |
⚠️ Windows 与 Linux 的脚本还没有经过测试，遇到问题请提 issue
74 |
Windows 用户
77 | 在管理员权限的 PowerShell 中执行：
78 | irm https://github.com/TinsFox/github-hosts/releases/download/v0.0.1/github-hosts.windows-amd64.exe | iex
79 |
80 | Linux 用户
81 | sudo curl -fsSL https://github.com/TinsFox/github-hosts/releases/download/v0.0.1/github-hosts.linux-amd64 -o github-hosts && sudo chmod +x ./github-hosts && ./github-hosts
82 |
83 | 更多版本请查看 Release 页面
84 |
85 | 2. 使用 SwitchHosts 工具
86 |
87 | - 下载并安装 SwitchHosts
88 | - 添加规则：
89 |
90 | - 方案名：GitHub Hosts
91 | - 类型：远程
92 | - URL：https://github-hosts.tinsfox.com/hosts
93 | - 自动更新：1 小时
94 |
95 |
96 |
97 |
98 | 当前 hosts 内容
99 |
100 |
101 |
正在加载 hosts 内容...
102 |
3. 手动更新
105 |
106 | - 获取 hosts：访问 https://github-hosts.tinsfox.com/hosts
107 | - 更新本地 hosts 文件：
108 |
109 | - Windows：
C:\Windows\System32\drivers\etc\hosts
110 | - MacOS/Linux：
/etc/hosts
111 |
112 |
113 | - 刷新 DNS：
114 |
115 | - Windows：
ipconfig /flushdns
116 | - MacOS：
sudo killall -HUP mDNSResponder
117 | - Linux：
sudo systemd-resolve --flush-caches
118 |
119 |
120 |
121 |
122 | ❓ 常见问题
123 | 权限问题
124 |
125 | - Windows：需要以管理员身份运行
126 | - MacOS/Linux：需要 sudo 权限
127 |
128 |
129 | 定时任务未生效
130 |
131 | - Windows：检查任务计划程序中的 "GitHub Hosts Updater"
132 | - MacOS/Linux：使用
crontab -l 检查
133 |
134 |
135 | 更新失败
136 |
137 | - 检查日志：
~/.github-hosts/logs/update.log
138 | - 确保网络连接和文件权限正常
139 |
140 |
141 | 🔧 API 接口文档
142 |
143 |
144 | | 接口 |
145 | 方法 |
146 | 描述 |
147 |
148 |
149 | | /hosts |
150 | GET |
151 | 获取 hosts 文件内容 |
152 |
153 |
154 | | /hosts.json |
155 | GET |
156 | 获取 JSON 格式的数据 |
157 |
158 |
159 | | /{domain} |
160 | GET |
161 | 获取指定域名的实时 DNS 解析结果 |
162 |
163 |
164 | | /reset |
165 | POST |
166 | 清空缓存并重新获取所有数据（需要 API Key） |
167 |
168 |
169 |
170 | 📦 源码
171 | 本项目完全开源，欢迎访问 GitHub 仓库
172 |
173 |
176 |
177 |
178 |
179 |
180 |
--------------------------------------------------------------------------------
/public/index.js:
--------------------------------------------------------------------------------
1 | // 获取当前页面的基础 URL
2 | const baseUrl = window.location.origin
3 |
4 | function escapeHtml(str) {
5 | const div = document.createElement("div")
6 | div.textContent = str
7 | return div.innerHTML
8 | }
9 |
10 | async function copyToClipboard(btn) {
11 | try {
12 | const hostsElement = document.getElementById("hosts")
13 | await navigator.clipboard.writeText(hostsElement.textContent)
14 |
15 | const originalText = btn.textContent
16 | btn.textContent = "已复制"
17 |
18 | setTimeout(() => {
19 | btn.textContent = originalText
20 | }, 1000)
21 | } catch (err) {
22 | console.error("复制失败:", err)
23 | }
24 | }
25 |
26 | async function loadHosts() {
27 | const hostsElement = document.getElementById("hosts")
28 | // 如果元素不存在，直接返回
29 | if (!hostsElement) return
30 |
31 | try {
32 | const response = await fetch(`${baseUrl}/hosts`)
33 | if (!response.ok) throw new Error("Failed to load hosts")
34 | const hostsContent = await response.text()
35 | hostsElement.textContent = hostsContent
36 | } catch (error) {
37 | hostsElement.textContent = "加载 hosts 内容失败，请稍后重试"
38 | console.error("Error loading hosts:", error)
39 | }
40 | }
41 |
42 | function setupEventListeners() {
43 | document.querySelectorAll(".copy-btn").forEach((btn) => {
44 | btn.addEventListener("click", () => copyToClipboard(btn))
45 | })
46 |
47 | document.addEventListener("click", (e) => {
48 | if (e.target.classList.contains("response-collapse-btn")) {
49 | toggleCollapse(e.target)
50 | }
51 |
52 | if (e.target.closest(".response-area.collapsed")) {
53 | const collapseBtn = e.target
54 | .closest(".response-area")
55 | .querySelector(".response-collapse-btn")
56 | if (collapseBtn) {
57 | toggleCollapse(collapseBtn)
58 | }
59 | }
60 | })
61 | }
62 |
63 | // 确保 DOM 完全加载后再执行
64 | document.addEventListener("DOMContentLoaded", () => {
65 | loadHosts()
66 | setupEventListeners()
67 | })
68 |
--------------------------------------------------------------------------------
/public/logo.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/public/og.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/scripts/backup.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | "path/filepath"
7 | "sort"
8 | "strings"
9 | "time"
10 | )
11 |
12 | // listBackups 获取备份文件列表
13 | func (app *App) listBackups() ([]string, error) {
14 | files, err := os.ReadDir(app.backupDir)
15 | if err != nil {
16 | return nil, err
17 | }
18 |
19 | var backups []string
20 | for _, file := range files {
21 | if !file.IsDir() && strings.HasPrefix(file.Name(), "hosts_") {
22 | backups = append(backups, file.Name())
23 | }
24 | }
25 | return backups, nil
26 | }
27 |
28 | // listBackupsWithDetails 显示备份列表详情
29 | func (app *App) listBackupsWithDetails() error {
30 | backups, err := app.listBackups()
31 | if err != nil {
32 | return err
33 | }
34 |
35 | if len(backups) == 0 {
36 | app.logWithLevel(INFO, "没有找到备份文件")
37 | return nil
38 | }
39 |
40 | fmt.Println("\n可用的备份文件：")
41 | fmt.Println("序号\t备份时间\t\t文件大小")
42 | fmt.Println("----------------------------------------")
43 |
44 | // 按时间排序
45 | sort.Slice(backups, func(i, j int) bool {
46 | return backups[i] > backups[j] // 降序排列
47 | })
48 |
49 | for i, backup := range backups {
50 | path := filepath.Join(app.backupDir, backup)
51 | info, err := os.Stat(path)
52 | if err != nil {
53 | continue
54 | }
55 | timeStr := strings.TrimPrefix(backup, "hosts_")
56 | timeStr = strings.TrimSuffix(timeStr, filepath.Ext(timeStr))
57 | fmt.Printf("%d\t%s\t%.2f KB\n", i+1, timeStr, float64(info.Size())/1024)
58 | }
59 | return nil
60 | }
61 |
62 | // createNewBackup 创建新的备份
63 | func (app *App) createNewBackup() error {
64 | app.logWithLevel(INFO, "创建新的备份...")
65 | if err := app.backupHosts(); err != nil {
66 | return err
67 | }
68 | app.logWithLevel(SUCCESS, "备份创建成功")
69 | return nil
70 | }
71 |
72 | // backupHosts 备份当前 hosts 文件
73 | func (app *App) backupHosts() error {
74 | timestamp := time.Now().Format("20060102_150405")
75 | backupPath := filepath.Join(app.backupDir, fmt.Sprintf("hosts_%s", timestamp))
76 |
77 | input, err := os.ReadFile(hostsFile)
78 | if err != nil {
79 | return err
80 | }
81 |
82 | return os.WriteFile(backupPath, input, 0644)
83 | }
84 |
85 | // restoreBackupMenu 显示恢复备份菜单
86 | func (app *App) restoreBackupMenu() error {
87 | backups, err := app.listBackups()
88 | if err != nil {
89 | return err
90 | }
91 |
92 | if len(backups) == 0 {
93 | app.logWithLevel(INFO, "没有可用的备份文件")
94 | return nil
95 | }
96 |
97 | if err := app.listBackupsWithDetails(); err != nil {
98 | return err
99 | }
100 |
101 | fmt.Print("\n请选择要恢复的备份序号（0 取消）: ")
102 | var choice int
103 | fmt.Scanf("%d", &choice)
104 |
105 | if choice == 0 {
106 | return nil
107 | }
108 |
109 | if choice < 1 || choice > len(backups) {
110 | return fmt.Errorf("无效的选择")
111 | }
112 |
113 | // 确认恢复
114 | fmt.Print("确定要恢复这个备份吗？这将覆盖当前的 hosts 文件 [y/N]: ")
115 | var confirm string
116 | fmt.Scanf("%s", &confirm)
117 |
118 | if strings.ToLower(confirm) != "y" {
119 | app.logWithLevel(INFO, "已取消恢复操作")
120 | return nil
121 | }
122 |
123 | backupFile := filepath.Join(app.backupDir, backups[choice-1])
124 | return app.restoreBackup(backupFile)
125 | }
126 |
127 | // deleteBackupMenu 显示删除备份菜单
128 | func (app *App) deleteBackupMenu() error {
129 | backups, err := app.listBackups()
130 | if err != nil {
131 | return err
132 | }
133 |
134 | if len(backups) == 0 {
135 | app.logWithLevel(INFO, "没有可用的备份文件")
136 | return nil
137 | }
138 |
139 | if err := app.listBackupsWithDetails(); err != nil {
140 | return err
141 | }
142 |
143 | fmt.Print("\n请选择要删除的备份序号（0 取消）: ")
144 | var choice int
145 | fmt.Scanf("%d", &choice)
146 |
147 | if choice == 0 {
148 | return nil
149 | }
150 |
151 | if choice < 1 || choice > len(backups) {
152 | return fmt.Errorf("无效的选择")
153 | }
154 |
155 | // 确认删除
156 | fmt.Print("确定要删除这个备份吗？此操作不可恢复 [y/N]: ")
157 | var confirm string
158 | fmt.Scanf("%s", &confirm)
159 |
160 | if strings.ToLower(confirm) != "y" {
161 | app.logWithLevel(INFO, "已取消删除操作")
162 | return nil
163 | }
164 |
165 | backupFile := filepath.Join(app.backupDir, backups[choice-1])
166 | if err := os.Remove(backupFile); err != nil {
167 | return fmt.Errorf("删除备份失败: %w", err)
168 | }
169 |
170 | app.logWithLevel(SUCCESS, "备份已删除")
171 | return nil
172 | }
173 |
174 | // restoreBackup 恢复指定的备份文件
175 | func (app *App) restoreBackup(backupFile string) error {
176 | // 先创建当前 hosts 文件的备份
177 | if err := app.backupHosts(); err != nil {
178 | return fmt.Errorf("创建当前 hosts 备份失败: %w", err)
179 | }
180 |
181 | // 读取备份文件
182 | content, err := os.ReadFile(backupFile)
183 | if err != nil {
184 | return fmt.Errorf("读取备份文件失败: %w", err)
185 | }
186 |
187 | // 写入到 hosts 文件
188 | if err := os.WriteFile(hostsFile, content, 0644); err != nil {
189 | return fmt.Errorf("恢复 hosts 文件失败: %w", err)
190 | }
191 |
192 | // 刷新 DNS 缓存
193 | if err := app.flushDNSCache(); err != nil {
194 | app.logWithLevel(WARNING, "DNS 缓存刷新失败: %v", err)
195 | }
196 |
197 | app.logWithLevel(SUCCESS, "hosts 文件已恢复")
198 | return nil
199 | }
200 |
--------------------------------------------------------------------------------
/scripts/banner.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | const banner = `
4 | _______ __ __ __ __ __ __
5 | / ____(_) /_/ /_ __ __/ /_ / /_ ____ / /_/ /______
6 | / / __/ / __/ __ \/ / / / __ \/ __ \/ __ \/ __/ __/ ___/
7 | / /_/ / / /_/ / / / /_/ / / / / /_/ / /_/ / /_/ /_(__ )
8 | \____/_/\__/_/ /_/\__,_/_/ /_/\____/\____/\__/\__/____/
9 | GitHub Hosts Manager - https://github.com/TinsFox/github-hosts
10 | Version: 1.0.0
11 | 加速访问 GitHub
12 | `
13 |
--------------------------------------------------------------------------------
/scripts/build.bat:
--------------------------------------------------------------------------------
1 | @echo off
2 | setlocal enabledelayedexpansion
3 |
4 | :: 切换到脚本所在目录
5 | cd /d "%~dp0"
6 |
7 | :: 版本号
8 | set VERSION=1.0.0
9 |
10 | :: 构建目录
11 | set BUILD_DIR=..\build
12 | set BINARY_NAME=github-hosts
13 |
14 | :: 清理构建目录
15 | echo 清理构建目录...
16 | if exist %BUILD_DIR% rd /s /q %BUILD_DIR%
17 | mkdir %BUILD_DIR%
18 |
19 | :: 定义支持的平台
20 | set PLATFORMS=^
21 | darwin/amd64^
22 | darwin/arm64^
23 | linux/amd64^
24 | linux/arm64^
25 | windows/amd64
26 |
27 | :: 遍历平台进行构建
28 | for %%p in (%PLATFORMS%) do (
29 | for /f "tokens=1,2 delims=/" %%a in ("%%p") do (
30 | set GOOS=%%a
31 | set GOARCH=%%b
32 |
33 | :: 构建输出文件名
34 | set OUTPUT=%BUILD_DIR%\%BINARY_NAME%_!GOOS!_!GOARCH!
35 | if "!GOOS!"=="windows" set OUTPUT=!OUTPUT!.exe
36 |
37 | echo 正在构建 !GOOS!/!GOARCH!...
38 |
39 | :: 执行构建
40 | set GOOS=!GOOS!
41 | set GOARCH=!GOARCH!
42 | go build -o "!OUTPUT!" -ldflags="-s -w -X main.Version=%VERSION%" .
43 |
44 | if !errorlevel! equ 0 (
45 | echo √ 构建成功: !OUTPUT!
46 | ) else (
47 | echo × 构建失败: !GOOS!/!GOARCH!
48 | )
49 | )
50 | )
51 |
52 | :: 创建压缩包
53 | echo 创建压缩包...
54 | cd %BUILD_DIR%
55 | for %%f in (*) do (
56 | if exist "%%f" (
57 | tar -czf "%%f.tar.gz" "%%f"
58 | del "%%f"
59 | echo √ 已创建: %%f.tar.gz
60 | )
61 | )
62 | cd ..
63 |
64 | echo 构建完成！
65 | dir /b %BUILD_DIR%
66 |
67 | endlocal
--------------------------------------------------------------------------------
/scripts/build.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | # 定义颜色
4 | RED='\033[0;31m'
5 | GREEN='\033[0;32m'
6 | YELLOW='\033[1;33m'
7 | NC='\033[0m' # No Color
8 |
9 | # 切换到 scripts 目录
10 | cd "$(dirname "$0")"
11 |
12 | # 检查 go.mod 文件
13 | if [ ! -f "go.mod" ]; then
14 | echo -e "${YELLOW}初始化 Go 模块...${NC}"
15 | go mod init github.com/TinsFox/github-hosts/scripts
16 | go mod tidy
17 | fi
18 |
19 | # 版本号
20 | VERSION="1.0.0"
21 |
22 | # 构建目录
23 | BUILD_DIR="../build"
24 | BINARY_NAME="github-hosts"
25 |
26 | # 支持的平台
27 | PLATFORMS=(
28 | "darwin/amd64"
29 | "darwin/arm64"
30 | "linux/amd64"
31 | "linux/arm64"
32 | "windows/amd64"
33 | )
34 |
35 | # 清理构建目录
36 | echo -e "${YELLOW}清理构建目录...${NC}"
37 | rm -rf $BUILD_DIR
38 | mkdir -p $BUILD_DIR
39 |
40 | # 遍历平台进行构建
41 | for PLATFORM in "${PLATFORMS[@]}"; do
42 | # 分割平台信息
43 | IFS='/' read -r -a array <<< "$PLATFORM"
44 | GOOS="${array[0]}"
45 | GOARCH="${array[1]}"
46 |
47 | # 构建输出文件名
48 | OUTPUT="$BUILD_DIR/${BINARY_NAME}_${GOOS}_${GOARCH}"
49 | if [ "$GOOS" = "windows" ]; then
50 | OUTPUT="${OUTPUT}.exe"
51 | fi
52 |
53 | echo -e "${YELLOW}正在构建 $GOOS/$GOARCH...${NC}"
54 |
55 | # 执行构建
56 | GOOS=$GOOS GOARCH=$GOARCH go build -o "$OUTPUT" -ldflags="-s -w -X main.Version=$VERSION" .
57 |
58 | if [ $? -eq 0 ]; then
59 | echo -e "${GREEN}✓ 构建成功: $OUTPUT${NC}"
60 | else
61 | echo -e "${RED}✗ 构建失败: $GOOS/$GOARCH${NC}"
62 | fi
63 | done
64 |
65 | # 创建压缩包
66 | echo -e "${YELLOW}创建压缩包...${NC}"
67 | cd $BUILD_DIR
68 | for FILE in *; do
69 | if [ -f "$FILE" ]; then
70 | tar -czf "${FILE}.tar.gz" "$FILE"
71 | echo -e "${GREEN}✓ 已创建: ${FILE}.tar.gz${NC}"
72 | fi
73 | done
74 | cd ..
75 |
76 | echo -e "${GREEN}构建完成！${NC}"
77 |
--------------------------------------------------------------------------------
/scripts/config.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "os"
7 | "os/exec"
8 | "path/filepath"
9 | "runtime"
10 | "time"
11 | )
12 |
13 | // toggleAutoUpdate 切换自动更新状态
14 | func (app *App) toggleAutoUpdate() error {
15 | config, err := app.loadConfig()
16 | if err != nil {
17 | return fmt.Errorf("读取配置失败: %w", err)
18 | }
19 |
20 | currentStatus := map[bool]string{true: "开启", false: "关闭"}[config.AutoUpdate]
21 | targetStatus := map[bool]string{true: "关闭", false: "开启"}[config.AutoUpdate]
22 |
23 | fmt.Printf("\n当前自动更新已%s，是否%s？[y/N]: ", currentStatus, targetStatus)
24 |
25 | var response string
26 | fmt.Scanf("%s", &response)
27 |
28 | if response != "y" && response != "Y" {
29 | app.logWithLevel(INFO, "保持当前状态不变")
30 | return nil
31 | }
32 |
33 | // 更新配置
34 | config.AutoUpdate = !config.AutoUpdate
35 | if err := app.updateConfig(config.UpdateInterval, config.AutoUpdate); err != nil {
36 | return fmt.Errorf("更新配置失败: %w", err)
37 | }
38 |
39 | if config.AutoUpdate {
40 | // 开启自动更新时，设置定时任务
41 | if err := app.setupCron(config.UpdateInterval); err != nil {
42 | app.logWithLevel(ERROR, "设置定时任务失败: %v", err)
43 | // 回滚配置
44 | config.AutoUpdate = false
45 | app.updateConfig(config.UpdateInterval, false)
46 | return fmt.Errorf("设置定时任务失败: %w", err)
47 | }
48 | app.logWithLevel(SUCCESS, "自动更新已开启，更新间隔为 %d 分钟", config.UpdateInterval)
49 | } else {
50 | // 关闭自动更新时，移除定时任务
51 | if runtime.GOOS == "darwin" {
52 | exec.Command("launchctl", "bootout", "system/com.github.hosts").Run()
53 | os.Remove(darwinPlistPath)
54 | } else if runtime.GOOS == "windows" {
55 | exec.Command("schtasks", "/delete", "/tn", windowsTaskName, "/f").Run()
56 | } else {
57 | os.Remove(linuxCronPath)
58 | }
59 | app.logWithLevel(SUCCESS, "自动更新已关闭")
60 | }
61 |
62 | return nil
63 | }
64 |
65 | // changeUpdateInterval 修改更新间隔
66 | func (app *App) changeUpdateInterval() error {
67 | config, err := app.loadConfig()
68 | if err != nil {
69 | return fmt.Errorf("读取配置失败: %w", err)
70 | }
71 |
72 | fmt.Println("\n请选择新的更新间隔：")
73 | fmt.Println("1. 每 30 分钟")
74 | fmt.Println("2. 每 60 分钟")
75 | fmt.Println("3. 每 120 分钟")
76 |
77 | var choice int
78 | fmt.Scanf("%d", &choice)
79 |
80 | var interval int
81 | switch choice {
82 | case 1:
83 | interval = 30
84 | case 2:
85 | interval = 60
86 | case 3:
87 | interval = 120
88 | default:
89 | return fmt.Errorf("无效的选项")
90 | }
91 |
92 | // 更新配置
93 | if err := app.updateConfig(interval, config.AutoUpdate); err != nil {
94 | return fmt.Errorf("更新配置失败: %w", err)
95 | }
96 |
97 | // 如果启用了自动更新，则更新定时任务
98 | if config.AutoUpdate {
99 | if err := app.setupCron(interval); err != nil {
100 | return fmt.Errorf("更新定时任务失败: %w", err)
101 | }
102 | }
103 |
104 | app.logWithLevel(SUCCESS, "更新间隔已修改为 %d 分钟", interval)
105 | return nil
106 | }
107 |
108 | // exportConfigToFile 导出配置到文件
109 | func (app *App) exportConfigToFile() error {
110 | exportPath := filepath.Join(app.baseDir, fmt.Sprintf("config_export_%s.json", time.Now().Format("20060102_150405")))
111 |
112 | data, err := os.ReadFile(app.configFile)
113 | if err != nil {
114 | return fmt.Errorf("读取配置失败: %w", err)
115 | }
116 |
117 | if err := os.WriteFile(exportPath, data, 0644); err != nil {
118 | return fmt.Errorf("导出配置失败: %w", err)
119 | }
120 |
121 | app.logWithLevel(SUCCESS, "配置已导出到: %s", exportPath)
122 | return nil
123 | }
124 |
125 | // importConfigFromFile 从文件导入配置
126 | func (app *App) importConfigFromFile() error {
127 | fmt.Print("请输入配置文件路径: ")
128 | var path string
129 | fmt.Scanf("%s", &path)
130 |
131 | data, err := os.ReadFile(path)
132 | if err != nil {
133 | return fmt.Errorf("读取配置文件失败: %w", err)
134 | }
135 |
136 | var config Config
137 | if err := json.Unmarshal(data, &config); err != nil {
138 | return fmt.Errorf("配置文件格式无效: %w", err)
139 | }
140 |
141 | if err := os.WriteFile(app.configFile, data, 0644); err != nil {
142 | return fmt.Errorf("更新配置失败: %w", err)
143 | }
144 |
145 | app.logWithLevel(SUCCESS, "配置导入成功")
146 | return nil
147 | }
148 |
--------------------------------------------------------------------------------
/scripts/cron.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | "os/exec"
7 | "path/filepath"
8 | "runtime"
9 | "text/template"
10 | )
11 |
12 | // setupCron 根据操作系统设置定时任务
13 | func (app *App) setupCron(interval int) error {
14 | // 创建更新脚本
15 | scriptPath := filepath.Join(app.baseDir, "update.sh")
16 | if runtime.GOOS == "windows" {
17 | scriptPath = filepath.Join(app.baseDir, "update.bat")
18 | }
19 |
20 | if err := app.createUpdateScript(scriptPath); err != nil {
21 | return fmt.Errorf("创建更新脚本失败: %w", err)
22 | }
23 |
24 | // 根据操作系统选择不同的定时任务实现
25 | switch runtime.GOOS {
26 | case "darwin":
27 | return app.setupDarwinCron(interval, scriptPath)
28 | case "linux":
29 | return app.setupLinuxCron(interval, scriptPath)
30 | case "windows":
31 | return app.setupWindowsCron(interval, scriptPath)
32 | default:
33 | return fmt.Errorf("不支持的操作系统: %s", runtime.GOOS)
34 | }
35 | }
36 |
37 | // createUpdateScript 创建更新脚本
38 | func (app *App) createUpdateScript(path string) error {
39 | var content string
40 | if runtime.GOOS == "windows" {
41 | // Windows 批处理脚本
42 | content = `@echo off
43 | echo [%date% %time%] 开始更新 hosts 文件... >> "{{.LogDir}}\update.log"
44 |
45 | :: 清理已存在的 GitHub Hosts 内容
46 | powershell -Command "& {(Get-Content '{{.HostsFile}}') -notmatch '===== GitHub Hosts (Start|End) =====' | Set-Content '{{.HostsFile}}.tmp'}"
47 | move /Y "{{.HostsFile}}.tmp" "{{.HostsFile}}"
48 |
49 | :: 获取新的 hosts 内容
50 | echo # ===== GitHub Hosts Start ===== >> "{{.HostsFile}}"
51 | powershell -Command "& {(New-Object System.Net.WebClient).DownloadString('{{.HostsAPI}}')}" >> "{{.HostsFile}}"
52 | echo # ===== GitHub Hosts End ===== >> "{{.HostsFile}}"
53 |
54 | :: 刷新 DNS 缓存
55 | ipconfig /flushdns
56 |
57 | echo [%date% %time%] 更新完成 >> "{{.LogDir}}\update.log"
58 | `
59 | } else {
60 | // Unix 系统脚本
61 | content = `#!/bin/bash
62 | LOG_FILE="{{.LogDir}}/update_$(date +%Y%m%d).log"
63 | TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
64 |
65 | log() {
66 | echo "[$TIMESTAMP] $1" >> "$LOG_FILE"
67 | }
68 |
69 | log "开始更新 hosts 文件..."
70 |
71 | # 清理已存在的 GitHub Hosts 内容
72 | sed -i.bak '/# ===== GitHub Hosts Start =====/,/# ===== GitHub Hosts End =====/d' {{.HostsFile}}
73 |
74 | # 获取新的 hosts 内容
75 | echo "# ===== GitHub Hosts Start =====" >> {{.HostsFile}}
76 | curl -fsSL {{.HostsAPI}} >> {{.HostsFile}}
77 | echo "# ===== GitHub Hosts End =====" >> {{.HostsFile}}
78 |
79 | # 刷新 DNS 缓存
80 | if [ "$(uname)" == "Darwin" ]; then
81 | killall -HUP mDNSResponder
82 | log "已刷新 MacOS DNS 缓存"
83 | else
84 | if systemd-resolve --flush-caches > /dev/null 2>&1; then
85 | log "已刷新 Linux DNS 缓存"
86 | elif systemctl restart systemd-resolved > /dev/null 2>&1; then
87 | log "已重启 systemd-resolved 服务"
88 | fi
89 | fi
90 |
91 | log "更新完成"
92 | `
93 | }
94 |
95 | // 准备模板数据
96 | data := struct {
97 | LogDir string
98 | HostsFile string
99 | HostsAPI string
100 | }{
101 | LogDir: app.logDir,
102 | HostsFile: hostsFile,
103 | HostsAPI: hostsAPI,
104 | }
105 |
106 | // 解析并执行模板
107 | tmpl, err := template.New("script").Parse(content)
108 | if err != nil {
109 | return err
110 | }
111 |
112 | f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0755)
113 | if err != nil {
114 | return err
115 | }
116 | defer f.Close()
117 |
118 | return tmpl.Execute(f, data)
119 | }
120 |
121 | // setupWindowsCron 设置 Windows 计划任务
122 | func (app *App) setupWindowsCron(interval int, scriptPath string) error {
123 | // 删除已存在的任务
124 | exec.Command("schtasks", "/delete", "/tn", windowsTaskName, "/f").Run()
125 |
126 | // 创建新任务
127 | cmd := exec.Command("schtasks", "/create", "/tn", windowsTaskName,
128 | "/tr", scriptPath,
129 | "/sc", "minute",
130 | "/mo", fmt.Sprintf("%d", interval),
131 | "/ru", "SYSTEM",
132 | "/f")
133 |
134 | if output, err := cmd.CombinedOutput(); err != nil {
135 | return fmt.Errorf("创建计划任务失败: %s, %v", string(output), err)
136 | }
137 |
138 | return nil
139 | }
140 |
141 | // setupDarwinCron 设置 macOS 定时任务
142 | func (app *App) setupDarwinCron(interval int, scriptPath string) error {
143 | // 先尝试卸载已存在的服务
144 | exec.Command("launchctl", "bootout", "system/com.github.hosts").Run()
145 | // 删除旧的 plist 文件
146 | os.Remove(darwinPlistPath)
147 |
148 | content := fmt.Sprintf(`
149 |
150 |
151 |
152 | Label
153 | com.github.hosts
154 | ProgramArguments
155 |
156 | /bin/bash
157 | %s
158 |
159 | StartInterval
160 | %d
161 | RunAtLoad
162 |
163 |
164 | `, scriptPath, interval*60)
165 |
166 | // 写入新的 plist 文件
167 | if err := os.WriteFile(darwinPlistPath, []byte(content), 0644); err != nil {
168 | return fmt.Errorf("写入 plist 文件失败: %w", err)
169 | }
170 |
171 | // 加载新的服务
172 | cmd := exec.Command("launchctl", "bootstrap", "system", darwinPlistPath)
173 | if output, err := cmd.CombinedOutput(); err != nil {
174 | return fmt.Errorf("加载服务失败: %v, 输出: %s", err, string(output))
175 | }
176 |
177 | return nil
178 | }
179 |
180 | // setupLinuxCron 设置 Linux 定时任务
181 | func (app *App) setupLinuxCron(interval int, scriptPath string) error {
182 | var schedule string
183 | switch interval {
184 | case 30:
185 | schedule = "*/30 * * * *"
186 | case 60:
187 | schedule = "0 * * * *"
188 | case 120:
189 | schedule = "0 */2 * * *"
190 | default:
191 | return fmt.Errorf("无效的时间间隔: %d", interval)
192 | }
193 |
194 | content := fmt.Sprintf("%s root %s > %s/update.log 2>&1\n",
195 | schedule, scriptPath, app.logDir)
196 |
197 | if err := os.WriteFile(linuxCronPath, []byte(content), 0644); err != nil {
198 | return fmt.Errorf("写入 cron 文件失败: %w", err)
199 | }
200 |
201 | // 重启 cron 服务
202 | if err := exec.Command("systemctl", "restart", "cron").Run(); err != nil {
203 | return fmt.Errorf("重启 cron 服务失败: %w", err)
204 | }
205 |
206 | return nil
207 | }
208 |
--------------------------------------------------------------------------------
/scripts/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/TinsFox/github-hosts/scripts
2 |
3 | go 1.21
4 |
--------------------------------------------------------------------------------
/scripts/install.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "io"
7 | "net/http"
8 | "os"
9 | "path/filepath"
10 | "strings"
11 | "time"
12 | )
13 |
14 | func (app *App) installMenu() error {
15 | app.logWithLevel(INFO, "检查系统状态...")
16 |
17 | // 首先检查是否已存在 hosts 数据
18 | content, err := os.ReadFile(hostsFile)
19 | if err == nil && strings.Contains(string(content), "GitHub Hosts") {
20 | // 已存在 GitHub Hosts 数据，询问是否更新
21 | fmt.Print("\n检测到已存在 GitHub Hosts 数据，是否要更新？[Y/n]: ")
22 | var updateResponse string
23 | fmt.Scanf("%s", &updateResponse)
24 |
25 | if updateResponse == "n" || updateResponse == "N" {
26 | app.logWithLevel(INFO, "已取消更新操作")
27 | return nil
28 | }
29 |
30 | // 用户选择更新，直接执行更新操作
31 | if err := app.updateHosts(); err != nil {
32 | app.logWithLevel(ERROR, "更新 hosts 失败: %v", err)
33 | return fmt.Errorf("更新 hosts 失败: %w", err)
34 | }
35 | app.logWithLevel(SUCCESS, "hosts 文件更新完成")
36 | return nil
37 | }
38 |
39 | // 不存在 GitHub Hosts 数据，执行完整的安装流程
40 | app.logWithLevel(INFO, "开始安装配置向导...")
41 |
42 | // 1. 选择是否开启自动更新
43 | var autoUpdate bool = true // 默认开启
44 | fmt.Print("\n是否开启自动更新？[Y/n]: ")
45 | var response string
46 | fmt.Scanf("%s", &response)
47 |
48 | var interval int = 60 // 默认 60 分钟
49 | if response == "n" || response == "N" {
50 | autoUpdate = false
51 | app.logWithLevel(INFO, "已禁用自动更新")
52 | } else {
53 | app.logWithLevel(INFO, "已启用自动更新")
54 |
55 | fmt.Println("\n请选择更新间隔：")
56 | fmt.Println("1. 每 30 分钟")
57 | fmt.Println("2. 每 60 分钟")
58 | fmt.Println("3. 每 120 分钟")
59 | fmt.Print("请输入选项 (1-3): ")
60 |
61 | var choice int
62 | fmt.Scanf("%d", &choice)
63 |
64 | switch choice {
65 | case 1:
66 | interval = 30
67 | case 2:
68 | interval = 60
69 | case 3:
70 | interval = 120
71 | default:
72 | app.logWithLevel(ERROR, "无效的选项，将使用默认间隔（60分钟）")
73 | interval = 60
74 | }
75 | app.logWithLevel(INFO, "选择的更新间隔: %d 分钟", interval)
76 | }
77 |
78 | app.logWithLevel(INFO, "开始执行安装流程...")
79 |
80 | // 1. Setup directories
81 | app.logWithLevel(INFO, "第 1/4 步: 创建必要的目录结构")
82 | if err := app.setupDirectories(); err != nil {
83 | app.logWithLevel(ERROR, "创建目录失败: %v", err)
84 | return fmt.Errorf("创建目录失败: %w", err)
85 | }
86 | app.logWithLevel(SUCCESS, "目录创建完成")
87 | app.logWithLevel(INFO, " - 基础目录: %s", app.baseDir)
88 | app.logWithLevel(INFO, " - 配置文件: %s", app.configFile)
89 | app.logWithLevel(INFO, " - 备份目录: %s", app.backupDir)
90 | app.logWithLevel(INFO, " - 日志目录: %s", app.logDir)
91 |
92 | // 2. Update config
93 | app.logWithLevel(INFO, "第 2/4 步: 更新配置文件")
94 | if err := app.updateConfig(interval, autoUpdate); err != nil {
95 | app.logWithLevel(ERROR, "更新配置失败: %v", err)
96 | return fmt.Errorf("更新配置失败: %w", err)
97 | }
98 | app.logWithLevel(SUCCESS, "配置文件更新完成")
99 |
100 | // 3. Update hosts
101 | app.logWithLevel(INFO, "第 3/4 步: 更新 hosts 文件")
102 | if err := app.updateHosts(); err != nil {
103 | app.logWithLevel(ERROR, "更新 hosts 失败: %v", err)
104 | return fmt.Errorf("更新 hosts 失败: %w", err)
105 | }
106 | app.logWithLevel(SUCCESS, "hosts 文件更新完成")
107 |
108 | // 4. Setup cron
109 | if autoUpdate {
110 | app.logWithLevel(INFO, "第 4/4 步: 设置定时更新任务")
111 | if err := app.setupCron(interval); err != nil {
112 | app.logWithLevel(ERROR, "设置定时任务失败: %v", err)
113 | return fmt.Errorf("设置定时任务失败: %w", err)
114 | }
115 | app.logWithLevel(SUCCESS, "定时任务设置完成")
116 | } else {
117 | app.logWithLevel(INFO, "已跳过定时任务设置（自动更新已禁用）")
118 | }
119 |
120 | // 显示安装完成信息
121 | app.logWithLevel(SUCCESS, "安装完成！")
122 | app.logWithLevel(INFO, "系统配置信息：")
123 | if autoUpdate {
124 | app.logWithLevel(INFO, " • 更新间隔: 每 %d 分钟", interval)
125 | }
126 | app.logWithLevel(INFO, " • 自动更新: %s", map[bool]string{true: "已启用", false: "已禁用"}[autoUpdate])
127 | app.logWithLevel(INFO, " • 配置文件: %s", app.configFile)
128 | app.logWithLevel(INFO, " • 日志文件: %s", filepath.Join(app.logDir, "update.log"))
129 | app.logWithLevel(INFO, " • 备份目录: %s", app.backupDir)
130 |
131 | // 显示当前 hosts 文件内容
132 | app.logWithLevel(INFO, "\n当前 hosts 文件内容：")
133 | fmt.Println("----------------------------------------")
134 | content, err = os.ReadFile(hostsFile)
135 | if err != nil {
136 | app.logWithLevel(ERROR, "读取 hosts 文件失败: %v", err)
137 | } else {
138 | fmt.Println(string(content))
139 | }
140 | fmt.Println("----------------------------------------")
141 |
142 | // 自动执行网络连接测试
143 | app.logWithLevel(INFO, "\n开始测试网络连接...")
144 | if err := app.testConnection(); err != nil {
145 | app.logWithLevel(WARNING, "网络连接测试出现问题: %v", err)
146 | }
147 |
148 | return nil
149 | }
150 |
151 | func (app *App) setupDirectories() error {
152 | dirs := []string{app.baseDir, app.backupDir, app.logDir}
153 | for _, dir := range dirs {
154 | if err := os.MkdirAll(dir, 0755); err != nil {
155 | return err
156 | }
157 | }
158 | return nil
159 | }
160 |
161 | func (app *App) updateConfig(interval int, autoUpdate bool) error {
162 | config := Config{
163 | UpdateInterval: interval,
164 | LastUpdate: time.Now().UTC(),
165 | Version: "1.0.0",
166 | AutoUpdate: autoUpdate,
167 | }
168 |
169 | data, err := json.MarshalIndent(config, "", " ")
170 | if err != nil {
171 | return err
172 | }
173 |
174 | return os.WriteFile(app.configFile, data, 0644)
175 | }
176 |
177 | func (app *App) updateHosts() error {
178 | app.logWithLevel(INFO, "开始备份当前 hosts 文件")
179 | if err := app.backupHosts(); err != nil {
180 | return fmt.Errorf("backup failed: %w", err)
181 | }
182 | app.logWithLevel(SUCCESS, "hosts 文件备份完成")
183 |
184 | // 先清理已存在的 GitHub Hosts 内容
185 | app.logWithLevel(INFO, "清理已存在的 GitHub Hosts 内容")
186 | if err := app.cleanHostsFile(); err != nil {
187 | return fmt.Errorf("清理已存在内容失败: %w", err)
188 | }
189 | app.logWithLevel(SUCCESS, "已清理旧的 hosts 内容")
190 |
191 | app.logWithLevel(INFO, "正在从服务器获取最新 hosts 数据")
192 | resp, err := http.Get(hostsAPI)
193 | if err != nil {
194 | return fmt.Errorf("failed to download hosts: %w", err)
195 | }
196 | defer resp.Body.Close()
197 |
198 | if resp.StatusCode != http.StatusOK {
199 | return fmt.Errorf("server returned status code: %d", resp.StatusCode)
200 | }
201 |
202 | content, err := io.ReadAll(resp.Body)
203 | if err != nil {
204 | return fmt.Errorf("failed to read response: %w", err)
205 | }
206 | app.logWithLevel(SUCCESS, "成功获取最新 hosts 数据")
207 |
208 | app.logWithLevel(INFO, "正在更新本地 hosts 文件")
209 | f, err := os.OpenFile(hostsFile, os.O_APPEND|os.O_WRONLY, 0644)
210 | if err != nil {
211 | return fmt.Errorf("failed to open hosts file: %w", err)
212 | }
213 | defer f.Close()
214 |
215 | // 添加开始标记和更新时间
216 | startMarker := fmt.Sprintf("\n# ===== GitHub Hosts Start ===== \n# (Updated: %s)\n",
217 | time.Now().Format("2006-01-02 15:04:05"))
218 | if _, err := f.WriteString(startMarker); err != nil {
219 | return fmt.Errorf("failed to write start marker: %w", err)
220 | }
221 |
222 | // 写入 hosts 内容
223 | if _, err := f.Write(content); err != nil {
224 | return fmt.Errorf("failed to write hosts content: %w", err)
225 | }
226 |
227 | // 添加结束标记
228 | endMarker := "# ===== GitHub Hosts End =====\n"
229 | if _, err := f.WriteString(endMarker); err != nil {
230 | return fmt.Errorf("failed to write end marker: %w", err)
231 | }
232 |
233 | app.logWithLevel(SUCCESS, "hosts 文件更新成功")
234 |
235 | app.logWithLevel(INFO, "正在刷新 DNS 缓存")
236 | if err := app.flushDNSCache(); err != nil {
237 | app.logWithLevel(WARNING, "DNS 缓存刷新失败: %v", err)
238 | } else {
239 | app.logWithLevel(SUCCESS, "DNS 缓存刷新完成")
240 | }
241 |
242 | return nil
243 | }
244 |
--------------------------------------------------------------------------------
/scripts/log.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | "path/filepath"
7 | "time"
8 | )
9 |
10 | // logWithLevel 输出带有级别的日志，并同时写入日志文件
11 | // writeToFile 参数控制是否写入日志文件，默认为 true
12 | func (app *App) logWithLevel(level LogLevel, format string, args ...interface{}) {
13 | app.logWithLevelOpt(level, true, format, args...)
14 | }
15 |
16 | // logWithLevelOpt 输出带有级别的日志，可选择是否写入日志文件
17 | func (app *App) logWithLevelOpt(level LogLevel, writeToFile bool, format string, args ...interface{}) {
18 | var prefix string
19 | switch level {
20 | case INFO:
21 | prefix = "ℹ️ "
22 | case SUCCESS:
23 | prefix = "✅ "
24 | case WARNING:
25 | prefix = "⚠️ "
26 | case ERROR:
27 | prefix = "❌ "
28 | }
29 |
30 | timestamp := time.Now().Format("2006-01-02 15:04:05")
31 | message := fmt.Sprintf(format, args...)
32 | logLine := fmt.Sprintf("%s[%s] %s\n", prefix, timestamp, message)
33 |
34 | // 输出到控制台
35 | fmt.Print(logLine)
36 |
37 | // 如果不需要写入文件，直接返回
38 | if !writeToFile {
39 | return
40 | }
41 |
42 | // 写入到日志文件
43 | logFile := filepath.Join(app.logDir, fmt.Sprintf("update_%s.log", time.Now().Format("20060102")))
44 |
45 | // 确保日志目录存在
46 | if err := os.MkdirAll(app.logDir, 0755); err != nil {
47 | fmt.Printf("❌ 创建日志目录失败: %v\n", err)
48 | return
49 | }
50 |
51 | // 以追加模式打开日志文件
52 | f, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
53 | if err != nil {
54 | fmt.Printf("❌ 打开日志文件失败: %v\n", err)
55 | return
56 | }
57 | defer f.Close()
58 |
59 | // 写入日志
60 | if _, err := f.WriteString(logLine); err != nil {
61 | fmt.Printf("❌ 写入日志失败: %v\n", err)
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/scripts/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "log"
7 | "os"
8 | "os/exec"
9 | "path/filepath"
10 | "runtime"
11 | "strings"
12 | )
13 |
14 | // checkAndElevateSudo 检查权限并在需要时提权
15 | func checkAndElevateSudo() error {
16 | // Windows 系统使用不同的权限检查方式
17 | if runtime.GOOS == "windows" {
18 | // 检查是否以管理员权限运行
19 | isAdmin, err := isWindowsAdmin()
20 | if err != nil {
21 | return fmt.Errorf("检查 Windows 权限失败: %w", err)
22 | }
23 |
24 | if !isAdmin {
25 | fmt.Println("需要管理员权限来修改 hosts 文件")
26 | fmt.Println("请右键点击程序，选择'以管理员身份运行'")
27 |
28 | // 获取当前可执行文件的路径
29 | exe, err := os.Executable()
30 | if err != nil {
31 | return fmt.Errorf("获取程序路径失败: %w", err)
32 | }
33 |
34 | // 使用 runas 命令提权运行
35 | cmd := exec.Command("powershell", "Start-Process", exe, "-Verb", "RunAs")
36 | if err := cmd.Run(); err != nil {
37 | return fmt.Errorf("提权失败: %w", err)
38 | }
39 |
40 | // 退出当前的非管理员进程
41 | os.Exit(0)
42 | }
43 | return nil
44 | }
45 |
46 | // Unix 系统的权限检查
47 | if os.Geteuid() == 0 {
48 | return nil
49 | }
50 |
51 | // 检查命令是否以 sudo 运行
52 | sudoUID := os.Getenv("SUDO_UID")
53 | if sudoUID != "" {
54 | return nil
55 | }
56 |
57 | fmt.Println("需要管理员权限来修改 hosts 文件")
58 | fmt.Println("请输入 sudo 密码：")
59 |
60 | // 获取当前可执行文件的路径
61 | exe, err := os.Executable()
62 | if err != nil {
63 | return fmt.Errorf("获取程序路径失败: %w", err)
64 | }
65 |
66 | // 构建使用 sudo 运行的命令
67 | cmd := exec.Command("sudo", "-S", exe)
68 |
69 | // 将当前程序的标准输入输出连接到新进程
70 | cmd.Stdin = os.Stdin
71 | cmd.Stdout = os.Stdout
72 | cmd.Stderr = os.Stderr
73 |
74 | // 运行提权后的程序
75 | if err := cmd.Run(); err != nil {
76 | return fmt.Errorf("提权失败: %w", err)
77 | }
78 |
79 | // 退出当前的非 root 进程
80 | os.Exit(0)
81 | return nil
82 | }
83 |
84 | // isWindowsAdmin 检查当前进程是否具有管理员权限
85 | func isWindowsAdmin() (bool, error) {
86 | if runtime.GOOS != "windows" {
87 | return false, fmt.Errorf("不是 Windows 系统")
88 | }
89 |
90 | // 创建一个测试文件在系统目录
91 | testPath := filepath.Join(os.Getenv("windir"), ".test")
92 | err := os.WriteFile(testPath, []byte("test"), 0644)
93 | if err == nil {
94 | // 如果成功创建，则删除测试文件
95 | os.Remove(testPath)
96 | return true, nil
97 | }
98 |
99 | // 如果创建失败，检查是否是权限问题
100 | if os.IsPermission(err) {
101 | return false, nil
102 | }
103 |
104 | return false, err
105 | }
106 |
107 | // clearScreen 清空控制台
108 | func clearScreen() {
109 | switch runtime.GOOS {
110 | case "windows":
111 | cmd := exec.Command("cmd", "/c", "cls")
112 | cmd.Stdout = os.Stdout
113 | cmd.Run()
114 | default: // linux, darwin, etc
115 | cmd := exec.Command("clear")
116 | cmd.Stdout = os.Stdout
117 | cmd.Run()
118 | }
119 | }
120 |
121 | func main() {
122 | // 检查权限并在需要时提权
123 | if err := checkAndElevateSudo(); err != nil {
124 | fmt.Printf("错误: %v\n", err)
125 | fmt.Println("请使用管理员权限运行此程序")
126 | os.Exit(1)
127 | }
128 |
129 | clearScreen() // 启动时先清屏
130 | fmt.Println(banner)
131 |
132 | app, err := NewApp()
133 | if err != nil {
134 | log.Fatalf("初始化失败: %v", err)
135 | }
136 |
137 | for {
138 | // 显示安装状态
139 | installed, _ := app.checkInstallStatus()
140 | app.displayInstallStatus()
141 |
142 | fmt.Println("\n[基础功能]")
143 | fmt.Println("1. 安装/更新")
144 | if installed {
145 | fmt.Println("2. 卸载程序")
146 | fmt.Println("3. 查看 hosts 内容")
147 |
148 | fmt.Println("\n[自动更新]")
149 | // 动态显示自动更新选项
150 | config, err := app.loadConfig()
151 | if err == nil {
152 | if config.AutoUpdate {
153 | fmt.Println("4. 关闭自动更新")
154 | } else {
155 | fmt.Println("4. 开启自动更新")
156 | }
157 | } else {
158 | fmt.Println("4. 切换自动更新")
159 | }
160 | fmt.Println("5. 修改更新间隔")
161 |
162 | fmt.Println("\n[系统工具]")
163 | fmt.Println("6. 测试网络连接")
164 | fmt.Println("7. 检查系统状态")
165 | fmt.Println("8. 查看更新日志")
166 | fmt.Println("9. 打开配置目录")
167 | fmt.Println("10. 系统诊断")
168 | }
169 |
170 | fmt.Println("\n[系统]")
171 | fmt.Println("11. 打开 hosts 文件")
172 |
173 | fmt.Println("\n[关于]")
174 | fmt.Println("12. 🐙 访问项目主页")
175 |
176 | fmt.Println("\n0. 退出程序")
177 | fmt.Printf("\n请输入选项 (0-12 或 q 退出): ")
178 |
179 | // 读取用户输入
180 | var input string
181 | fmt.Scanln(&input)
182 |
183 | // 检查是否是退出命令
184 | if input == "q" || input == "Q" {
185 | fmt.Println("感谢使用，再见！")
186 | return
187 | }
188 |
189 | // 转换输入为数字
190 | var choice int
191 | _, err := fmt.Sscanf(input, "%d", &choice)
192 | if err != nil {
193 | fmt.Println("无效的选项，请重试")
194 | waitForEnter()
195 | continue
196 | }
197 |
198 | // 在未安装状态下限制某些选项的访问
199 | if !installed && (choice >= 2 && choice <= 10) {
200 | fmt.Println("\n❌ 请先安装程序才能使用该功能")
201 | waitForEnter()
202 | continue
203 | }
204 |
205 | switch choice {
206 | case 1: // 安装/更新
207 | if err := app.installMenu(); err != nil {
208 | log.Printf("安装失败: %v", err)
209 | }
210 | waitForEnter()
211 | case 2: // 卸载
212 | if !installed {
213 | continue
214 | }
215 | if err := app.uninstall(); err != nil {
216 | log.Printf("卸载失败: %v", err)
217 | }
218 | waitForEnter()
219 | case 3: // 查看 hosts
220 | if err := app.showHostsContent(); err != nil {
221 | log.Printf("查看 hosts 内容失败: %v", err)
222 | }
223 | waitForEnter()
224 | case 4: // 切换自动更新
225 | if err := app.toggleAutoUpdate(); err != nil {
226 | log.Printf("切换自动更新失败: %v", err)
227 | }
228 | waitForEnter()
229 | case 5: // 修改更新间隔
230 | if err := app.changeUpdateInterval(); err != nil {
231 | log.Printf("修改更新间隔失败: %v", err)
232 | }
233 | waitForEnter()
234 | case 6: // 测试网络连接
235 | if err := app.testConnection(); err != nil {
236 | log.Printf("网络测试失败: %v", err)
237 | }
238 | waitForEnter()
239 | case 7: // 检查系统状态
240 | if err := app.checkStatus(); err != nil {
241 | log.Printf("状态检查失败: %v", err)
242 | }
243 | waitForEnter()
244 | case 8: // 查看更新日志
245 | if err := app.showUpdateLogs(); err != nil {
246 | log.Printf("查看日志失败: %v", err)
247 | }
248 | waitForEnter()
249 | case 9: // 打开配置目录
250 | if err := app.openConfigDir(); err != nil {
251 | log.Printf("打开配置目录失败: %v", err)
252 | }
253 | waitForEnter()
254 | case 10: // 系统诊断
255 | if err := app.runDiagnostics(); err != nil {
256 | log.Printf("系统诊断失败: %v", err)
257 | }
258 | waitForEnter()
259 | case 11: // 打开 hosts 文件
260 | if err := app.openHostsFile(); err != nil {
261 | log.Printf("打开 hosts 文件失败: %v", err)
262 | }
263 | waitForEnter()
264 | case 12: // 访问项目主页
265 | if err := app.openGitHubRepo(); err != nil {
266 | log.Printf("打开项目主页失败: %v", err)
267 | }
268 | waitForEnter()
269 | case 0: // 退出
270 | fmt.Println("感谢使用，再见！")
271 | return
272 | default:
273 | fmt.Println("无效的选项，请重试")
274 | waitForEnter()
275 | }
276 | }
277 | }
278 |
279 | // NewApp 创建新的应用实例
280 | func NewApp() (*App, error) {
281 | homeDir, err := os.UserHomeDir()
282 | if err != nil {
283 | return nil, fmt.Errorf("failed to get home directory: %w", err)
284 | }
285 |
286 | baseDir := filepath.Join(homeDir, ".github-hosts")
287 | app := &App{
288 | baseDir: baseDir,
289 | configFile: filepath.Join(baseDir, "config.json"),
290 | backupDir: filepath.Join(baseDir, "backups"),
291 | logDir: filepath.Join(baseDir, "logs"),
292 | logger: log.New(os.Stdout, "", log.LstdFlags),
293 | }
294 |
295 | return app, nil
296 | }
297 |
298 | // openGitHubRepo 打开项目主页
299 | func (app *App) openGitHubRepo() error {
300 | repoURL := "https://github.com/TinsFox/github-hosts"
301 | var cmd *exec.Cmd
302 |
303 | switch runtime.GOOS {
304 | case "darwin":
305 | cmd = exec.Command("open", repoURL)
306 | case "linux":
307 | cmd = exec.Command("xdg-open", repoURL)
308 | case "windows":
309 | cmd = exec.Command("cmd", "/c", "start", repoURL)
310 | default:
311 | return fmt.Errorf("不支持的操作系统: %s", runtime.GOOS)
312 | }
313 |
314 | if err := cmd.Run(); err != nil {
315 | return fmt.Errorf("打开浏览器失败: %w", err)
316 | }
317 |
318 | app.logWithLevel(SUCCESS, "已在浏览器中打开项目主页")
319 | return nil
320 | }
321 |
322 | // loadConfig 加载配置文件
323 | func (app *App) loadConfig() (*Config, error) {
324 | data, err := os.ReadFile(app.configFile)
325 | if err != nil {
326 | return nil, err
327 | }
328 |
329 | var config Config
330 | if err := json.Unmarshal(data, &config); err != nil {
331 | return nil, err
332 | }
333 |
334 | return &config, nil
335 | }
336 |
337 | // waitForEnter 等待用户按回车并重新显示界面
338 | func waitForEnter() {
339 | fmt.Print("\n按回车键继续...")
340 | fmt.Scanln() // 等待用户按下回车键
341 | clearScreen() // 清空控制台
342 | fmt.Println(banner) // 重新显示 banner
343 | }
344 |
345 | // checkInstallStatus 检查程序安装状态
346 | func (app *App) checkInstallStatus() (bool, *InstallStatus) {
347 | status := &InstallStatus{
348 | IsInstalled: false,
349 | AutoUpdate: false,
350 | UpdateInterval: 0,
351 | LastUpdate: "",
352 | Version: "v1.0.0", // 当前程序版本
353 | }
354 |
355 | // 检查配置文件是否存在
356 | config, err := app.loadConfig()
357 | if err == nil && config != nil {
358 | status.IsInstalled = true
359 | status.AutoUpdate = config.AutoUpdate
360 | status.UpdateInterval = config.UpdateInterval
361 |
362 | // 获取最后更新时间
363 | if stat, err := os.Stat(app.configFile); err == nil {
364 | status.LastUpdate = stat.ModTime().Format("2006-01-02 15:04:05")
365 | }
366 | }
367 |
368 | return status.IsInstalled, status
369 | }
370 |
371 | // displayInstallStatus 显示安装状态
372 | func (app *App) displayInstallStatus() {
373 | installed, status := app.checkInstallStatus()
374 |
375 | fmt.Println("\n=== 系统状态 ===")
376 | if installed {
377 | fmt.Println("📦 安装状态: ✅ 已安装")
378 | fmt.Printf("🔄 自动更新: %s\n", formatBool(status.AutoUpdate))
379 | if status.AutoUpdate {
380 | fmt.Printf("⏱️ 更新间隔: %d 小时\n", status.UpdateInterval)
381 | }
382 | fmt.Printf("🕒 上次更新: %s\n", status.LastUpdate)
383 | fmt.Printf("📌 程序版本: %s\n", status.Version)
384 |
385 | // 检查 hosts 文件中的 GitHub 记录数量
386 | count, _ := app.countGitHubHosts()
387 | fmt.Printf("📝 GitHub Hosts 记录数: %d\n", count)
388 | } else {
389 | fmt.Println("📦 安装状态: ❌ 未安装")
390 | fmt.Println("💡 提示: 请选择选项 1 进行安装")
391 | }
392 | fmt.Println(strings.Repeat("-", 30))
393 | }
394 |
395 | // formatBool 格式化布尔值显示
396 | func formatBool(b bool) string {
397 | if b {
398 | return "✅ 已开启"
399 | }
400 | return "❌ 已关闭"
401 | }
402 |
403 | // countGitHubHosts 统计 hosts 文件中的 GitHub 相关记录数量
404 | func (app *App) countGitHubHosts() (int, error) {
405 | content, err := os.ReadFile(hostsFile)
406 | if err != nil {
407 | return 0, err
408 | }
409 |
410 | count := 0
411 | lines := strings.Split(string(content), "\n")
412 | for _, line := range lines {
413 | if strings.Contains(line, "github") || strings.Contains(line, "githubusercontent") {
414 | count++
415 | }
416 | }
417 | return count, nil
418 | }
419 |
420 | // InstallStatus 安装状态结构体
421 | type InstallStatus struct {
422 | IsInstalled bool
423 | AutoUpdate bool
424 | UpdateInterval int
425 | LastUpdate string
426 | Version string
427 | }
428 |
429 | // openHostsFile 打开 hosts 文件
430 | func (app *App) openHostsFile() error {
431 | var cmd *exec.Cmd
432 |
433 | switch runtime.GOOS {
434 | case "darwin":
435 | // macOS 使用 open 命令
436 | cmd = exec.Command("open", hostsFile)
437 | case "linux":
438 | // Linux 使用 xdg-open 命令
439 | cmd = exec.Command("xdg-open", hostsFile)
440 | case "windows":
441 | // Windows 使用 notepad 打开
442 | cmd = exec.Command("notepad", hostsFile)
443 | default:
444 | return fmt.Errorf("不支持的操作系统: %s", runtime.GOOS)
445 | }
446 |
447 | if err := cmd.Run(); err != nil {
448 | return fmt.Errorf("打开 hosts 文件失败: %w", err)
449 | }
450 |
451 | app.logWithLevel(SUCCESS, "已打开 hosts 文件")
452 | return nil
453 | }
454 |
--------------------------------------------------------------------------------
/scripts/menu.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | "os/exec"
7 | "path/filepath"
8 | "runtime"
9 | "strings"
10 | "time"
11 | )
12 |
13 | // showHostsContent 显示 hosts 文件内容
14 | func (app *App) showHostsContent() error {
15 | // 读取 hosts 文件内容
16 | content, err := os.ReadFile(hostsFile)
17 | if err != nil {
18 | return fmt.Errorf("读取 hosts 文件失败: %w", err)
19 | }
20 |
21 | // 显示完整内容
22 | fmt.Printf("\n当前 hosts 文件内容 (%s)：\n", hostsFile)
23 | fmt.Println(strings.Repeat("-", 80))
24 | fmt.Println(string(content))
25 | fmt.Println(strings.Repeat("-", 80))
26 |
27 | // 显示文件信息
28 | if info, err := os.Stat(hostsFile); err == nil {
29 | fmt.Printf("文件大小: %.2f KB\n", float64(info.Size())/1024)
30 | fmt.Printf("修改时间: %s\n", info.ModTime().Format("2006-01-02 15:04:05"))
31 | }
32 |
33 | return nil
34 | }
35 |
36 | // openConfigDir 打开配置目录
37 | func (app *App) openConfigDir() error {
38 | var cmd *exec.Cmd
39 |
40 | switch runtime.GOOS {
41 | case "darwin":
42 | cmd = exec.Command("open", app.baseDir)
43 | case "linux":
44 | cmd = exec.Command("xdg-open", app.baseDir)
45 | case "windows":
46 | cmd = exec.Command("explorer", app.baseDir)
47 | default:
48 | return fmt.Errorf("不支持的操作系统: %s", runtime.GOOS)
49 | }
50 |
51 | if err := cmd.Run(); err != nil {
52 | return fmt.Errorf("打开目录失败: %w", err)
53 | }
54 |
55 | return nil
56 | }
57 |
58 | // showUpdateLogs 显示更新日志
59 | func (app *App) showUpdateLogs() error {
60 | logFile := filepath.Join(app.logDir, fmt.Sprintf("update_%s.log", time.Now().Format("20060102")))
61 |
62 | content, err := os.ReadFile(logFile)
63 | if err != nil {
64 | if os.IsNotExist(err) {
65 | app.logWithLevel(INFO, "今日暂无更新日志")
66 | return nil
67 | }
68 | return fmt.Errorf("读取日志文件失败: %w", err)
69 | }
70 |
71 | fmt.Println("\n最近的更新日志:")
72 | fmt.Println(strings.Repeat("-", 80))
73 | fmt.Println(string(content))
74 | fmt.Println(strings.Repeat("-", 80))
75 | return nil
76 | }
77 |
78 | // checkStatus 检查系统状态
79 | func (app *App) checkStatus() error {
80 | app.logWithLevel(INFO, "开始检查系统状态...")
81 |
82 | // 1. 检查配置文件
83 | config, err := app.loadConfig()
84 | if err != nil {
85 | app.logWithLevel(ERROR, "配置文件检查失败: %v", err)
86 | } else {
87 | app.logWithLevel(INFO, "配置文件状态:")
88 | app.logWithLevel(INFO, " • 更新间隔: %d 分钟", config.UpdateInterval)
89 | app.logWithLevel(INFO, " • 自动更新: %s", map[bool]string{true: "已启用", false: "已禁用"}[config.AutoUpdate])
90 | app.logWithLevel(INFO, " • 最后更新: %s", config.LastUpdate.Local().Format("2006-01-02 15:04:05"))
91 | app.logWithLevel(INFO, " • 版本: %s", config.Version)
92 | }
93 |
94 | // 2. 检查 hosts 文件
95 | if _, err := os.Stat(hostsFile); err != nil {
96 | app.logWithLevel(ERROR, "hosts 文件检查失败: %v", err)
97 | } else {
98 | content, err := os.ReadFile(hostsFile)
99 | if err != nil {
100 | app.logWithLevel(ERROR, "读取 hosts 文件失败: %v", err)
101 | } else {
102 | lines := strings.Split(string(content), "\n")
103 | githubCount := 0
104 | for _, line := range lines {
105 | if strings.Contains(strings.ToLower(line), "github") {
106 | githubCount++
107 | }
108 | }
109 | app.logWithLevel(INFO, "hosts 文件状态:")
110 | app.logWithLevel(INFO, " • 文件大小: %.2f KB", float64(len(content))/1024)
111 | app.logWithLevel(INFO, " • GitHub 相关记录数: %d", githubCount)
112 | }
113 | }
114 |
115 | // 3. 检查定时任务状态
116 | app.logWithLevel(INFO, "定时任务状态:")
117 | switch runtime.GOOS {
118 | case "darwin":
119 | cmd := exec.Command("launchctl", "list", "com.github.hosts")
120 | if err := cmd.Run(); err == nil {
121 | app.logWithLevel(SUCCESS, " • 定时任务运行正常")
122 | } else {
123 | app.logWithLevel(WARNING, " • 定时任务未运行")
124 | }
125 | case "windows":
126 | cmd := exec.Command("schtasks", "/query", "/tn", windowsTaskName)
127 | if err := cmd.Run(); err == nil {
128 | app.logWithLevel(SUCCESS, " • 定时任务运行正常")
129 | } else {
130 | app.logWithLevel(WARNING, " • 定时任务未运行")
131 | }
132 | case "linux":
133 | if _, err := os.Stat(linuxCronPath); err == nil {
134 | app.logWithLevel(SUCCESS, " • 定时任务配置正常")
135 | } else {
136 | app.logWithLevel(WARNING, " • 定时任务配置不存在")
137 | }
138 | }
139 |
140 | // 4. 检查目录权限
141 | app.logWithLevel(INFO, "目录权限检查:")
142 | dirs := []string{app.baseDir, app.backupDir, app.logDir}
143 | for _, dir := range dirs {
144 | if err := app.checkDirPermissions(dir); err != nil {
145 | app.logWithLevel(WARNING, " • %s: %v", dir, err)
146 | } else {
147 | app.logWithLevel(SUCCESS, " • %s: 权限正常", dir)
148 | }
149 | }
150 |
151 | // 5. 检查备份状态
152 | if backups, err := app.listBackups(); err != nil {
153 | app.logWithLevel(ERROR, "备份检查失败: %v", err)
154 | } else {
155 | app.logWithLevel(INFO, "备份状态:")
156 | app.logWithLevel(INFO, " • 备份文件数量: %d", len(backups))
157 | if len(backups) > 0 {
158 | app.logWithLevel(INFO, " • 最新备份: %s", backups[len(backups)-1])
159 | }
160 | }
161 |
162 | return nil
163 | }
164 |
--------------------------------------------------------------------------------
/scripts/network.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "bufio"
5 | "fmt"
6 | "net"
7 | "net/http"
8 | "os"
9 | "os/exec"
10 | "runtime"
11 | "strings"
12 | "text/tabwriter"
13 | "time"
14 | )
15 |
16 | // testConnection 测试网络连接
17 | func (app *App) testConnection() error {
18 | app.logWithLevel(INFO, "开始网络连接测试...")
19 | fmt.Println("\n=== 连接测试结果 ===")
20 |
21 | // 读取 hosts 文件
22 | content, err := os.ReadFile(hostsFile)
23 | if err != nil {
24 | fmt.Printf("\n❌ 严重错误：无法读取 hosts 文件\n")
25 | fmt.Printf("❌ 错误详情：%v\n", err)
26 | return err
27 | }
28 |
29 | // 解析 hosts 文件中的 GitHub 相关记录
30 | var tests []struct {
31 | name string
32 | ip string
33 | host string
34 | }
35 |
36 | startMarker := "# ===== GitHub Hosts Start ====="
37 | endMarker := "# ===== GitHub Hosts End ====="
38 | inGithubSection := false
39 | scanner := bufio.NewScanner(strings.NewReader(string(content)))
40 |
41 | for scanner.Scan() {
42 | line := strings.TrimSpace(scanner.Text())
43 |
44 | if line == startMarker {
45 | inGithubSection = true
46 | continue
47 | }
48 | if line == endMarker {
49 | inGithubSection = false
50 | continue
51 | }
52 |
53 | if inGithubSection && line != "" && !strings.HasPrefix(line, "#") {
54 | fields := strings.Fields(line)
55 | if len(fields) >= 2 {
56 | tests = append(tests, struct {
57 | name string
58 | ip string
59 | host string
60 | }{
61 | name: fields[1],
62 | ip: fields[0],
63 | host: fields[1],
64 | })
65 | }
66 | }
67 | }
68 |
69 | if len(tests) == 0 {
70 | fmt.Printf("\n❌ 错误：在 hosts 文件中未找到 GitHub 相关记录\n")
71 | return fmt.Errorf("no github hosts found")
72 | }
73 |
74 | // 创建 HTTP 客户端
75 | client := &http.Client{
76 | Timeout: 10 * time.Second,
77 | Transport: &http.Transport{
78 | TLSHandshakeTimeout: 5 * time.Second,
79 | ResponseHeaderTimeout: 5 * time.Second,
80 | DisableKeepAlives: true,
81 | },
82 | }
83 |
84 | // 使用 tabwriter 创建表格
85 | w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
86 |
87 | // 输出表头
88 | fmt.Fprintf(w, "\n%s\t%s\t%s\t%s\t%s\n",
89 | "域名",
90 | "状态",
91 | "响应时间",
92 | "当前解析IP",
93 | "期望IP")
94 | fmt.Fprintln(w, strings.Repeat("-", 100))
95 |
96 | // 测试结果统计
97 | var (
98 | successCount = 0
99 | failCount = 0
100 | )
101 |
102 | // 测试每个域名
103 | for _, test := range tests {
104 | start := time.Now()
105 |
106 | // 获取实际 DNS 解析结果
107 | actualIP := ""
108 | addrs, err := net.LookupHost(test.host)
109 | if err != nil {
110 | fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n",
111 | test.host,
112 | "✗ DNS失败",
113 | "-",
114 | "解析失败",
115 | test.ip)
116 | fmt.Printf("❌ DNS 解析失败: %v\n", err)
117 | failCount++
118 | continue
119 | }
120 | if len(addrs) > 0 {
121 | actualIP = addrs[0]
122 | }
123 |
124 | // 测试连接
125 | resp, err := client.Get("https://" + test.host)
126 | elapsed := time.Since(start)
127 |
128 | if err != nil {
129 | fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n",
130 | test.host,
131 | "✗ 连接失败",
132 | fmt.Sprintf("%.2fs", elapsed.Seconds()),
133 | actualIP,
134 | test.ip)
135 | fmt.Printf("❌ 连接失败: %v\n", err)
136 | failCount++
137 | continue
138 | }
139 | defer resp.Body.Close()
140 |
141 | // 检查 IP 匹配和连接状态
142 | status := "✓ 正常"
143 | if actualIP != test.ip {
144 | status = "! IP不匹配"
145 | fmt.Printf("⚠️ %s 的 IP 不匹配！当前: %s, 期望: %s\n", test.host, actualIP, test.ip)
146 | failCount++
147 | } else if resp.StatusCode != http.StatusOK {
148 | status = fmt.Sprintf("! 状态%d", resp.StatusCode)
149 | fmt.Printf("⚠️ %s 返回异常状态码: %d\n", test.host, resp.StatusCode)
150 | failCount++
151 | } else {
152 | successCount++
153 | }
154 |
155 | fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n",
156 | test.host,
157 | status,
158 | fmt.Sprintf("%.2fs", elapsed.Seconds()),
159 | actualIP,
160 | test.ip)
161 | }
162 |
163 | fmt.Fprintln(w, strings.Repeat("-", 100))
164 | w.Flush()
165 |
166 | // 输出总结
167 | fmt.Printf("\n测试总结:\n")
168 | fmt.Printf("总计测试: %d\n", len(tests))
169 | if successCount > 0 {
170 | fmt.Printf("✅ 成功: %d\n", successCount)
171 | }
172 | if failCount > 0 {
173 | fmt.Printf("❌ 失败: %d\n", failCount)
174 | fmt.Printf("\n⚠️ 警告：检测到 %d 个问题，建议重新执行更新操作\n", failCount)
175 | } else {
176 | fmt.Printf("\n✅ 太好了！所有测试都通过了\n")
177 | }
178 |
179 | return nil
180 | }
181 |
182 | // flushDNSCache 刷新 DNS 缓存
183 | func (app *App) flushDNSCache() error {
184 | var cmd *exec.Cmd
185 |
186 | switch runtime.GOOS {
187 | case "darwin":
188 | cmd = exec.Command("killall", "-HUP", "mDNSResponder")
189 | case "linux":
190 | cmd = exec.Command("systemd-resolve", "--flush-caches")
191 | if err := cmd.Run(); err != nil {
192 | cmd = exec.Command("systemctl", "restart", "systemd-resolved")
193 | }
194 | case "windows":
195 | cmd = exec.Command("ipconfig", "/flushdns")
196 | default:
197 | return fmt.Errorf("不支持的操作系统: %s", runtime.GOOS)
198 | }
199 |
200 | return cmd.Run()
201 | }
202 |
--------------------------------------------------------------------------------
/scripts/types.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "log"
5 | "runtime"
6 | "time"
7 | )
8 |
9 | // App 应用程序结构体
10 | type App struct {
11 | baseDir string
12 | configFile string
13 | backupDir string
14 | logDir string
15 | logger *log.Logger
16 | }
17 |
18 | // Config 配置文件结构体
19 | type Config struct {
20 | UpdateInterval int `json:"updateInterval"`
21 | LastUpdate time.Time `json:"lastUpdate"`
22 | Version string `json:"version"`
23 | AutoUpdate bool `json:"autoUpdate"`
24 | }
25 |
26 | // LogLevel 定义日志级别
27 | type LogLevel int
28 |
29 | const (
30 | INFO LogLevel = iota
31 | SUCCESS
32 | WARNING
33 | ERROR
34 | )
35 |
36 | const (
37 | MaxMenuOption = 12 // Maximum menu option number
38 | )
39 |
40 | // displayOption 定义菜单选项
41 | type displayOption struct {
42 | id int
43 | name string
44 | description string
45 | handler func(*App) error
46 | }
47 |
48 | // 系统相关常量
49 | var (
50 | // hostsAPI 定义 API 地址
51 | hostsAPI = "https://github-hosts.tinsfox.com/hosts"
52 |
53 | // hostsFile 根据操作系统定义 hosts 文件路径
54 | hostsFile = getHostsFilePath()
55 |
56 | // 定时任务相关路径
57 | windowsTaskName = "GitHubHostsUpdate"
58 | darwinPlistPath = "/Library/LaunchDaemons/com.github.hosts.plist"
59 | linuxCronPath = "/etc/cron.d/github-hosts"
60 | )
61 |
62 | // getHostsFilePath 根据操作系统返回 hosts 文件路径
63 | func getHostsFilePath() string {
64 | if runtime.GOOS == "windows" {
65 | return "C:\\Windows\\System32\\drivers\\etc\\hosts"
66 | }
67 | return "/etc/hosts"
68 | }
69 |
--------------------------------------------------------------------------------
/scripts/uninstall.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | "os/exec"
7 | "runtime"
8 | "strings"
9 | )
10 |
11 | func (app *App) uninstall() error {
12 | // 首先检查程序是否已安装
13 | installed, _ := app.checkInstallStatus()
14 | if !installed {
15 | app.logWithLevelOpt(ERROR, false, "程序尚未安装，无需卸载")
16 | return fmt.Errorf("程序未安装")
17 | }
18 |
19 | app.logWithLevelOpt(INFO, false, "准备卸载 GitHub Hosts 更新程序...")
20 | app.logWithLevelOpt(WARNING, false, "此操作将删除所有程序文件、配置和日志，且不可恢复")
21 |
22 | // 询问用户确认
23 | fmt.Print("确定要卸载吗？(y/N): ")
24 | var response string
25 | fmt.Scanln(&response)
26 |
27 | // 检查用户响应
28 | if response != "y" && response != "Y" {
29 | app.logWithLevelOpt(INFO, false, "已取消卸载")
30 | return nil
31 | }
32 |
33 | app.logWithLevelOpt(INFO, false, "开始卸载...")
34 |
35 | // 1. 清理 hosts 文件中的 GitHub 相关记录
36 | app.logWithLevelOpt(INFO, false, "正在清理 hosts 文件...")
37 | if err := app.cleanHostsFile(); err != nil {
38 | app.logWithLevelOpt(ERROR, false, "清理 hosts 文件失败: %v", err)
39 | return err
40 | }
41 | app.logWithLevelOpt(SUCCESS, false, "hosts 文件已清理")
42 |
43 | // 2. 移除定时任务
44 | app.logWithLevelOpt(INFO, false, "正在移除定时任务...")
45 | if runtime.GOOS == "darwin" {
46 | exec.Command("launchctl", "bootout", "system/com.github.hosts").Run()
47 | os.Remove(darwinPlistPath)
48 | } else if runtime.GOOS == "windows" {
49 | exec.Command("schtasks", "/delete", "/tn", windowsTaskName, "/f").Run()
50 | } else {
51 | os.Remove(linuxCronPath)
52 | }
53 | app.logWithLevelOpt(SUCCESS, false, "定时任务已移除")
54 |
55 | // 3. 删除程序文件和目录
56 | app.logWithLevelOpt(INFO, false, "正在删除程序文件...")
57 |
58 | // 获取用户主目录
59 | homeDir, err := os.UserHomeDir()
60 | if err != nil {
61 | app.logWithLevelOpt(ERROR, false, "获取用户主目录失败: %v", err)
62 | return err
63 | }
64 |
65 | // 需要删除的目录列表
66 | dirsToRemove := []string{
67 | app.baseDir, // 主程序目录
68 | app.backupDir, // 备份目录
69 | app.logDir, // 日志目录
70 | homeDir + "/.github-hosts", // 配置目录
71 | homeDir + "/.github-hosts/backups", // 备份目录
72 | homeDir + "/.github-hosts/logs", // 日志目录
73 | }
74 |
75 | // 删除所有相关目录
76 | for _, dir := range dirsToRemove {
77 | if err := os.RemoveAll(dir); err != nil {
78 | app.logWithLevelOpt(WARNING, false, "删除目录失败: %s: %v", dir, err)
79 | }
80 | }
81 |
82 | // 4. 刷新 DNS 缓存
83 | app.logWithLevelOpt(INFO, false, "正在刷新 DNS 缓存...")
84 | if err := app.flushDNSCache(); err != nil {
85 | app.logWithLevelOpt(WARNING, false, "DNS 缓存刷新失败: %v", err)
86 | }
87 |
88 | app.logWithLevelOpt(SUCCESS, false, "卸载完成")
89 | app.logWithLevelOpt(INFO, false, "所有程序文件和配置已清理干净")
90 | return nil
91 | }
92 |
93 | // cleanHostsFile 清理 hosts 文件中的 GitHub 相关记录
94 | func (app *App) cleanHostsFile() error {
95 | // 读取 hosts 文件内容
96 | content, err := os.ReadFile(hostsFile)
97 | if err != nil {
98 | return fmt.Errorf("读取 hosts 文件失败: %w", err)
99 | }
100 |
101 | lines := strings.Split(string(content), "\n")
102 | var newLines []string
103 | var lastLineEmpty bool = true // 用于跟踪上一行是否为空
104 |
105 | // 逐行处理，移除 GitHub 相关记录和多余的空行
106 | for _, line := range lines {
107 | trimmedLine := strings.TrimSpace(line)
108 |
109 | // 跳过 GitHub 相关记录
110 | if strings.Contains(trimmedLine, "github") || strings.Contains(trimmedLine, "githubusercontent") {
111 | continue
112 | }
113 |
114 | // 处理空行：只有当上一行不是空行时才保留当前空行
115 | if trimmedLine == "" {
116 | if lastLineEmpty {
117 | continue // 跳过连续的空行
118 | }
119 | lastLineEmpty = true
120 | } else {
121 | lastLineEmpty = false
122 | }
123 |
124 | newLines = append(newLines, line)
125 | }
126 |
127 | // 确保文件末尾只有一个换行符
128 | for len(newLines) > 0 && strings.TrimSpace(newLines[len(newLines)-1]) == "" {
129 | newLines = newLines[:len(newLines)-1]
130 | }
131 | newLines = append(newLines, "") // 添加一个空行作为文件结尾
132 |
133 | // 写回文件
134 | newContent := strings.Join(newLines, "\n")
135 | if err := os.WriteFile(hostsFile, []byte(newContent), 0644); err != nil {
136 | return fmt.Errorf("写入 hosts 文件失败: %w", err)
137 | }
138 |
139 | return nil
140 | }
141 |
--------------------------------------------------------------------------------
/scripts/utils.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | "path/filepath"
7 | "runtime"
8 | )
9 |
10 | // checkDirPermissions 检查目录权限
11 | func (app *App) checkDirPermissions(dir string) error {
12 | // 检查目录是否存在
13 | if _, err := os.Stat(dir); os.IsNotExist(err) {
14 | return fmt.Errorf("目录不存在: %s", dir)
15 | }
16 |
17 | // 检查是否可写
18 | testFile := filepath.Join(dir, ".test")
19 | if err := os.WriteFile(testFile, []byte("test"), 0644); err != nil {
20 | return fmt.Errorf("目录不可写: %s", dir)
21 | }
22 | os.Remove(testFile)
23 |
24 | return nil
25 | }
26 |
27 | // runDiagnostics 运行系统诊断
28 | func (app *App) runDiagnostics() error {
29 | app.logWithLevel(INFO, "开始系统诊断...")
30 |
31 | // 1. 检查系统信息
32 | app.logWithLevel(INFO, "系统信息:")
33 | app.logWithLevel(INFO, " • 操作系统: %s", runtime.GOOS)
34 | app.logWithLevel(INFO, " • 架构: %s", runtime.GOARCH)
35 |
36 | // 2. 检查目录权限
37 | app.logWithLevel(INFO, "检查目录权限...")
38 | dirs := []string{app.baseDir, app.backupDir, app.logDir}
39 | for _, dir := range dirs {
40 | if err := app.checkDirPermissions(dir); err != nil {
41 | app.logWithLevel(WARNING, "目录权限问题: %v", err)
42 | } else {
43 | app.logWithLevel(SUCCESS, "目录权限正常: %s", dir)
44 | }
45 | }
46 |
47 | // 3. 检查网络连接
48 | app.logWithLevel(INFO, "检查网络连接...")
49 | if err := app.testConnection(); err != nil {
50 | app.logWithLevel(WARNING, "网络连接问题: %v", err)
51 | }
52 |
53 | // 4. 检查配置文件
54 | app.logWithLevel(INFO, "检查配置文件...")
55 | if config, err := app.loadConfig(); err != nil {
56 | app.logWithLevel(WARNING, "配置文件问题: %v", err)
57 | } else {
58 | app.logWithLevel(SUCCESS, "配置文件正常")
59 | app.logWithLevel(INFO, " • 版本: %s", config.Version)
60 | app.logWithLevel(INFO, " • 上次更新: %s", config.LastUpdate.Local().Format("2006-01-02 15:04:05"))
61 | }
62 |
63 | app.logWithLevel(SUCCESS, "诊断完成")
64 | return nil
65 | }
66 |
--------------------------------------------------------------------------------
/src/constants.ts:
--------------------------------------------------------------------------------
1 | export const GITHUB_URLS = [
2 | "alive.github.com",
3 | "api.github.com",
4 | "assets-cdn.github.com",
5 | "avatars.githubusercontent.com",
6 | "avatars0.githubusercontent.com",
7 | "avatars1.githubusercontent.com",
8 | "avatars2.githubusercontent.com",
9 | "avatars3.githubusercontent.com",
10 | "avatars4.githubusercontent.com",
11 | "avatars5.githubusercontent.com",
12 | "camo.githubusercontent.com",
13 | "central.github.com",
14 | "cloud.githubusercontent.com",
15 | "codeload.github.com",
16 | "collector.github.com",
17 | "desktop.githubusercontent.com",
18 | "favicons.githubusercontent.com",
19 | "gist.github.com",
20 | "github-cloud.s3.amazonaws.com",
21 | "github-com.s3.amazonaws.com",
22 | "github-production-release-asset-2e65be.s3.amazonaws.com",
23 | "github-production-repository-file-5c1aeb.s3.amazonaws.com",
24 | "github-production-user-asset-6210df.s3.amazonaws.com",
25 | "github.blog",
26 | "github.com",
27 | "github.community",
28 | "github.githubassets.com",
29 | "github.global.ssl.fastly.net",
30 | "github.io",
31 | "github.map.fastly.net",
32 | "githubstatus.com",
33 | "live.github.com",
34 | "media.githubusercontent.com",
35 | "objects.githubusercontent.com",
36 | "pipelines.actions.githubusercontent.com",
37 | "raw.githubusercontent.com",
38 | "user-images.githubusercontent.com",
39 | "vscode.dev",
40 | "education.github.com",
41 | "private-user-images.githubusercontent.com",
42 | ]
43 |
44 | export const HOSTS_TEMPLATE = `# github hosts
45 | # 加速 GitHub 访问
46 |
47 | {content}
48 |
49 | # 数据更新时间：{updateTime}
50 | `
51 |
52 | export const GITHUB_API_BASE = "https://api.github.com"
53 |
54 | export const HOSTS_PATH = "hosts"
55 |
56 | export const DNS_PROVIDERS = [
57 | {
58 | url: (domain: string) => `https://1.1.1.1/dns-query?name=${domain}&type=A`,
59 | headers: { Accept: "application/dns-json" },
60 | name: "Cloudflare DNS",
61 | },
62 | {
63 | url: (domain: string) => `https://dns.google/resolve?name=${domain}&type=A`,
64 | headers: { Accept: "application/dns-json" },
65 | name: "Google DNS",
66 | },
67 | ]
68 |
--------------------------------------------------------------------------------
/src/env.d.ts:
--------------------------------------------------------------------------------
1 | declare module "cloudflare:test" {
2 | interface ProvidedEnv {
3 | KV_NAMESPACE: KVNamespace
4 | }
5 | // ...or if you have an existing `Env` type...
6 | interface ProvidedEnv extends Env {}
7 | }
--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
1 | import { Hono } from "hono"
2 | import {
3 | formatHostsFile,
4 | getDomainData,
5 | getHostsData,
6 | resetHostsData,
7 | } from "./services/hosts"
8 | import { handleSchedule } from "./scheduled"
9 | import { Bindings } from "./types"
10 |
11 | const app = new Hono<{ Bindings: Bindings }>()
12 |
13 | app.get("/", async (c) => {
14 | const html = await c.env.ASSETS.get("index.html")
15 | if (!html) {
16 | return c.text("Template not found", 404)
17 | }
18 |
19 | return c.html(html)
20 | })
21 |
22 | app.get("/hosts.json", async (c) => {
23 | const data = await getHostsData(c.env)
24 | return c.json(data)
25 | })
26 |
27 | app.get("/hosts", async (c) => {
28 | const data = await getHostsData(c.env)
29 | const hostsContent = formatHostsFile(data)
30 | return c.text(hostsContent)
31 | })
32 |
33 | app.post("/reset", async (c) => {
34 | const apiKey = c.req.query("key")
35 |
36 | // 验证 API key
37 | if (apiKey !== c.env.API_KEY) {
38 | return c.json({ error: "Unauthorized" }, 401)
39 | }
40 |
41 | const newEntries = await resetHostsData(c.env)
42 |
43 | return c.json({
44 | message: "Reset completed",
45 | entriesCount: newEntries.length,
46 | entries: newEntries,
47 | })
48 | })
49 |
50 | app.get("/:domain", async (c) => {
51 | const domain = c.req.param("domain")
52 | const data = await getDomainData(c.env, domain)
53 |
54 | if (!data) {
55 | return c.json({ error: "Domain not found" }, 404)
56 | }
57 |
58 | return c.json(data)
59 | })
60 |
61 | export default {
62 | fetch: app.fetch,
63 | async scheduled(event: ScheduledEvent, env: Bindings, ctx: ExecutionContext) {
64 | ctx.waitUntil(handleSchedule(event, env))
65 | },
66 | }
67 |
--------------------------------------------------------------------------------
/src/scheduled.ts:
--------------------------------------------------------------------------------
1 | import { Bindings } from "./types"
2 | import { fetchLatestHostsData, storeData } from "./services/hosts"
3 |
4 | export async function handleSchedule(
5 | event: ScheduledEvent,
6 | env: Bindings
7 | ): Promise {
8 | console.log("Running scheduled task...")
9 |
10 | try {
11 | const newEntries = await fetchLatestHostsData()
12 | await storeData(env, newEntries)
13 |
14 | console.log("Scheduled task completed successfully")
15 | } catch (error) {
16 | console.error("Error in scheduled task:", error)
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/src/services/__tests__/hosts.test.ts:
--------------------------------------------------------------------------------
1 | import { describe, it, expect, vi, beforeEach } from "vitest"
2 | import { fetchIPFromIPAddress } from "../hosts"
3 |
4 | describe("fetchIpFromIpaddress", () => {
5 | beforeEach(() => {
6 | // 清除所有模拟
7 | vi.clearAllMocks()
8 | })
9 |
10 | it("should successfully extract IP from DNS section", async () => {
11 | // 模拟 fetch 响应
12 | global.fetch = vi.fn().mockResolvedValue({
13 | text: () =>
14 | Promise.resolve(`
15 |
16 |
17 |
18 |
19 |
20 | | 140.82.114.25 |
21 |
22 |
23 |
No DNS section here
44 |
45 |
46 | `),
47 | })
48 |
49 | const result = await fetchIPFromIPAddress("invalid-domain.com")
50 | expect(result).toBeNull()
51 | })
52 |
53 | it("should handle fetch errors gracefully", async () => {
54 | global.fetch = vi.fn().mockRejectedValue(new Error("Network error"))
55 |
56 | const result = await fetchIPFromIPAddress("github.com")
57 | expect(result).toBeNull()
58 | })
59 |
60 | it("should use fallback IP when DNS section IP is not available", async () => {
61 | global.fetch = vi.fn().mockResolvedValue({
62 | text: () =>
63 | Promise.resolve(`
64 |
65 |
66 |
67 | IP Address: 192.168.1.1
68 |
69 |
70 | `),
71 | })
72 |
73 | const result = await fetchIPFromIPAddress("github.com")
74 | expect(result).toBe("192.168.1.1")
75 | })
76 |
77 | it("should handle multiple IPs in DNS section", async () => {
78 | global.fetch = vi.fn().mockResolvedValue({
79 | text: () =>
80 | Promise.resolve(`
81 |
82 |
83 |
84 |
85 |
86 | | 140.82.114.4 |
87 | 140.82.114.5 |
88 |
89 |
90 |
48 |