init: init proj

This commit is contained in:
2026-08-25 11:35:05 +08:00
commit bf7f2df67e
80 changed files with 9936 additions and 0 deletions

6
.env.example Normal file
View File

@@ -0,0 +1,6 @@
# 服务端口(监听 0.0.0.0,局域网内的手机等设备可直接访问)
PORT=3000
# SQLite 数据目录(相对 server/ 或绝对路径)
DATA_DIR=./data
# 管理界面鉴权 token。未设置时 /api/* 仅放行 localhost 与局域网私有网段
ADMIN_TOKEN=

11
.gitignore vendored Normal file
View File

@@ -0,0 +1,11 @@
node_modules/
dist/
data/
*.db
*.db-journal
*.db-wal
*.db-shm
.env
.env.local
.DS_Store
*.log

99
CLAUDE.md Normal file
View File

@@ -0,0 +1,99 @@
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## 这是什么
自托管的代理节点与分流规则管理平台Web 界面管理多协议节点VMessTrojanShadowsocksHysteria2与策略组、规则向 macOS Surge、iOS ShadowRocket、Android ClashMeta 下发托管订阅。规则模板来自 [ClashConnectRules/Surge](https://github.com/ClashConnectRules/Surge),节点来自 `~/Development/Fusion/Projects/edge-nodes/` 交付的边缘节点舰队。
## 命令
```bash
pnpm dev # server :3000 + web :5173都监听 0.0.0.0,局域网可访问)
pnpm -r typecheck # 三个包全量类型检查
pnpm test # 服务端单测vitest
pnpm --filter @proxy-station/web build
# 单测过滤(在 server/ 目录下)
npx vitest run parse # 按文件名
npx vitest run -t "round-trip" # 按用例名
npx vitest # watch 模式
# 校验生成的 Clash 配置(最有价值的一条端到端验证)
curl -s "http://localhost:3000/sub/<token>/clash" > /tmp/c.yaml && mihomo -t -f /tmp/c.yaml
```
**网络与安装的两个坑**:本机会话注入的 `HTTPS_PROXY` 会让 git构建挂死跑任何命令前先剥掉代理见用户全局 CLAUDE.md。pnpm 在无 TTY 时执行 `pnpm install` 需要 `CI=true`原生模块better-sqlite3、esbuild、vue-demi的构建许可写在 `pnpm-workspace.yaml``allowBuilds`
## 架构
pnpm monorepo`shared/`zod schema 与 DTO前后端共用源码非构建产物 `server/`Hono + better-sqlite3 + Drizzle `web/`Vue 3 + Naive UI + Pinia。生产模式由 server 静态托管 web 产物,单端口。
### 配置生成流水线(核心)
```
SQLite → buildProfileIR({nodeIds}) → ProfileIR → 四个序列化器
├─ generateSurge(ir, {selfUrl})
├─ generateShadowrocket(ir) 节点订阅
├─ generateShadowrocketConf(ir, …) 策略组+规则
└─ generateClash(ir, {convertBaseUrl})
```
`services/ir.ts` 是唯一的读库出口把节点、策略组、规则、Surge 原文段落收成与客户端无关的 `ProfileIR`;四个生成器只读 IR互不依赖。**新增客户端就是加一个序列化器**,不要在生成器里再查数据库。
IR 层承担三件防护,改动时不要绕过:
- 停用或已删除的策略组会被剔除,引用它的成员与规则一并跳过
- `FINAL` 规则永远保留,其策略组失效时降级为 `DIRECT`
- `nodeIds` 为空数组表示「不限制」,非空则按订阅分配的节点范围过滤
### 客户端能力矩阵
`shared/src/protocols.ts``clientSupports()` 决定某节点能否下发给某客户端,生成器据此静默排除并回报 `excluded`。当前唯一规则:**Surge 不支持 Shadowsocks over WebSocket**Surge 的 ss 类型只有 simple-obfs没有 WS 传输)。这不是 bug同机的 VMessTrojan 线路凭据相同、覆盖等价。
### 协议字段差异
同一协议在三端写法不同,映射集中在 `shared/src/protocols.ts` 与各生成器:
- SS cipher分享链接用 Xray 命名 `chacha20-poly1305`SurgeClash 要 `chacha20-ietf-poly1305``normalizeSsCipher()`
- VMess `alterId=0` 必须输出 Surge 的 `vmess-aead=true`,否则连不上且症状隐晦
- Hysteria2 的 salamander 混淆Surge 用 `salamander-password=`Clash 用 `obfs``obfs-password`
- SS over WS 在 Clash 侧唯一可行方案是 `plugin: v2ray-plugin`
这些写法参考了 `../sub-router` 项目(用户已在生产使用的同类系统),遇到新的客户端适配问题优先查它。
### 策略组的两种取节点方式
`includeAllNodes``filterRegex` 可以共存,生成器里 **filterRegex 分支优先**
-`filterRegex` → 动态筛选Surge `include-all-proxies=true, policy-regex-filter=…`Clash `filter:`ShadowRocket `use=true, policy-regex-filter=…`。新增同地区节点会自动进组
-`includeAllNodes` → Surge 静态展开全部节点名ClashShadowRocket 仍用动态引用
**地区组靠节点名称正则匹配,不看 `region` 字段**。节点命名规范与新增地区的完整步骤见 `docs/ADDING-REGIONS.md`——命名不对就进不了地区组。
### 规则集:映射与兜底转换
模板里的 `RULE-SET``DOMAIN-SET` 指向外部 URL。SurgeShadowRocket 直接透传Clash 需要 rule-providers`services/rulesets/mapping.ts` 按序尝试映射到 skk.moe 的 Clash 版与 blackmatrix7 的 Clash 目录,映射不到的标记 `needsConvert`provider URL 指向自托管端点 `/sub/:token/ruleset/:id.yaml`——该端点实时拉取 Surge 版并用 `convert.ts` 转成 classical provider。规则集拉取带 24h 缓存 + etag失败回落陈旧缓存。
### ShadowRocket 分两步导入
ShadowRocket 的原生订阅格式只承载节点,因此拆成两个端点:`/shadowrocket`(节点 base64 URI 列表)与 `/shadowrocket-conf`(策略组与规则的 .conf。**conf 里的策略组用 `use=true` 引用订阅名**,所以用户在 App 内必须把节点订阅命名为 `SHADOWROCKET_SUB_NAME`= `Proxy Station`。ShadowRocket 不支持 `DOMAIN-SET``AND``URL-REGEX`,生成时跳过并回报 `skippedRules`。**该 conf 尚未经过真机验证。**
### 鉴权与订阅
`/api/*``adminAuth`:设置了 `ADMIN_TOKEN` 则要求 Bearer未设置时仅放行 localhost 与 RFC1918 私有网段(公网 IP 一律拒绝)。`/sub/:token/*` 公开token 用常量时间比对。**订阅 URL 完全由请求来源决定**——后端只返回路径,前端用 `window.location.origin` 拼接,`#!MANAGED-CONFIG` 与 Clash provider URL 取本次请求的 origin所以没有也不需要「订阅基址」配置项。
未匹配的 `/api/*` 显式返回 404不落到 SPA 回退(否则会拿到一页 HTML调接口时极难排查
## 前端约定
UI 走「站牌导视」设计方向(轨道交通导视系统语言):白底 `#f7f7f4`、深藏青重点色 `#2b3f5c`、**琥珀 `#b26a00` = 直连出口、青 `#007a72` = WARP 净出口**,协议各有线路色圆标。颜色只在承载信息时出现——避免发光、亮边条、装饰性渐变。四个方向的设计对比留在 `docs/design-demos.html`
两个共用工具:
- `utils/nodeName.ts``nodeDisplayName()`:与出口标签并排显示时剥掉名字末尾的出口词。**下发给客户端的名字必须保留出口词**,客户端里没有标签,用户只能靠名字区分同协议的两条线路
- `utils/clipboard.ts``copyText()``navigator.clipboard` 只在 HTTPSlocalhost 可用,局域网 HTTP 访问时是 `undefined`,直接调用会静默失败。必须走这个带 `execCommand` 降级的封装
## 数据与安全
SQLite 落在 `server/data/`,存有节点真实凭据。`data/``*.db``.env` 已在 `.gitignore`——**绝不入 git**。仓库内所有示例、测试、模板一律用占位凭据。节点通过 Web 界面粘贴分享链接导入,不直接读 edge-nodes 目录(见 `docs/SEEDING.md`)。
schema 变更走 `db/index.ts` 里的 `BOOTSTRAP_SQL``CREATE TABLE IF NOT EXISTS`,旧库补列用同文件下方的轻量 `ALTER TABLE` 循环(吞掉「列已存在」错误)——没有引入 migration 工具。
公网部署必须设 `ADMIN_TOKEN` 并用反代提供 HTTPS订阅 token 就在 URL 里,明文 HTTP 会泄露。

25
Dockerfile Normal file
View File

@@ -0,0 +1,25 @@
# ---- 构建阶段完整镜像自带编译工具链better-sqlite3 原生模块)----
FROM node:22 AS build
WORKDIR /app
RUN corepack enable
COPY pnpm-workspace.yaml package.json pnpm-lock.yaml ./
COPY shared/package.json shared/
COPY server/package.json server/
COPY web/package.json web/
RUN CI=true pnpm install --frozen-lockfile
COPY shared/ shared/
COPY server/ server/
COPY web/ web/
RUN pnpm --filter @proxy-station/web build
# ---- 运行阶段 ----
FROM node:22-slim
WORKDIR /app
RUN corepack enable
COPY --from=build /app ./
ENV NODE_ENV=production
ENV PORT=3000
ENV DATA_DIR=/data
VOLUME /data
EXPOSE 3000
CMD ["pnpm", "--filter", "@proxy-station/server", "start"]

85
README.md Normal file
View File

@@ -0,0 +1,85 @@
# Proxy Station
自托管的代理节点与分流规则管理平台。在 Web 界面里管理多协议节点与策略组、规则,向 macOS、iOS、Android 三端下发托管订阅——客户端填一次 URL之后配置自动更新。
```
节点 ──┐
策略组 ──┼──→ ProfileIR ──┬──→ Surge .conf
规则 ──┘ ├──→ ShadowRocket 节点订阅 + 规则配置
└──→ ClashMeta .yaml
```
## 能做什么
**多协议节点管理**——VMess、Trojan、Shadowsocks、Hysteria2支持粘贴分享链接批量导入`vmess://``trojan://``ss://` 的 SIP002 与 Xray 两种写法、`hysteria2://`),也支持手动填写与导出。节点按站点分段展示。
**分流规则与策略组**——首次启动自动从 [ClashConnectRules/Surge](https://github.com/ClashConnectRules/Surge) 模板导入26 个策略组 + 88 条规则含广告拦截、AI 服务、流媒体、国内直连等)。规则可排序、改策略、启停、增删;策略组可启停并调整顺序,顺序即客户端里的排列顺序。外部规则集可在界面上实时预览内容。
**按客户端自动适配**——同一份数据生成三端配置,客户端不支持的协议在下发时自动屏蔽(例如 Surge 的 ss 类型没有 WebSocket 传输SS over WS 节点会被排除字段差异自动映射cipher 命名、VMess AEAD、Hysteria2 混淆参数等)。
**按订阅分配节点**——每个订阅可以只开放部分节点,用于把不同线路分给不同设备或他人。
## 客户端支持
| 客户端 | 节点 | 策略组 | 规则 | 导入方式 |
|---|:--:|:--:|:--:|---|
| **Surge** (macOS) | ✅ | ✅ | ✅ | 一个 URL托管配置自动更新`#!MANAGED-CONFIG` |
| **ClashMeta** (Android) | ✅ | ✅ | ✅ | 一个 URL`RULE-SET` 自动映射为 rule-providers |
| **ShadowRocket** (iOS) | ✅ | ✅ | ✅ | **两个 URL**:节点订阅 + 规则配置,见下 |
ShadowRocket 的原生订阅格式只承载节点,因此拆成两步:先在「订阅」里添加节点链接并**命名为 `Proxy Station`**,再在「配置」里添加规则链接。配置文件按这个名字引用节点,名字必须一致。订阅页的 ⓘ 图标里有同样的说明。
> ClashMeta 侧无 Clash 版本的规则集,由本服务实时拉取 Surge 版并转换后提供,无需外部转换服务。
## 快速开始
```bash
pnpm install
pnpm dev # server :3000 + web :5173
```
打开 http://localhost:3000 (或开发时的 :5173然后
1. **节点** → 批量导入,粘贴分享链接。命名建议带地区词(如 `🇺🇸 US LA VMess Direct`),地区策略组靠节点名正则匹配
2. **订阅** → 新建订阅,勾选要开放的节点
3. 复制对应客户端的 URL 填进客户端
两端都监听 `0.0.0.0`,手机在同一局域网下用 `http://<你的内网IP>:5173` 即可访问管理界面,页面上显示的订阅 URL 会自动带上该地址。
## 部署
```bash
ADMIN_TOKEN=<随机长字符串> docker compose up -d
```
SQLite 落在 `./data` 卷。订阅 URL 由请求来源自动推断,无需配置基址。
**公网部署的两条硬要求**:设置 `ADMIN_TOKEN`(未设置时管理接口只放行 localhost 与局域网);用反向代理提供 **HTTPS**——订阅 token 就在 URL 里,明文传输会泄露。反代的 access log 建议对 `/sub/` 路径脱敏。
## 校验
```bash
# Clash 产物(最有价值的一条端到端验证)
curl -s "http://localhost:3000/sub/<token>/clash" > /tmp/c.yaml && mihomo -t -f /tmp/c.yaml
pnpm -r typecheck
pnpm test
```
Surge 与 ShadowRocket 需真机导入验收。
## 文档
| 文件 | 内容 |
|---|---|
| `docs/SEEDING.md` | 从 edge-nodes 交付文档导入真实节点、命名建议 |
| `docs/ADDING-REGIONS.md` | 新增地区(香港、日本等)时的节点命名与策略组配套步骤 |
| `CLAUDE.md` | 架构要点与开发约定 |
## 安全
数据库存有节点真实凭据。`data/``*.db``.env` 已在 `.gitignore` 中,**绝不入 git**;仓库内所有示例、测试、模板一律使用占位凭据。订阅 token 可随时在「订阅」页禁用或删除。
## 技术栈
pnpm monorepo`server/`Hono + better-sqlite3 + Drizzle `web/`Vue 3 + Vite + Naive UI + Pinia `shared/`zod schema 与 DTO前后端共用。生产模式由 server 静态托管前端产物,单端口运行。

13
docker-compose.yml Normal file
View File

@@ -0,0 +1,13 @@
services:
proxy-station:
build: .
container_name: proxy-station
restart: unless-stopped
ports:
- '3000:3000'
volumes:
- ./data:/data
environment:
# 公网部署必须设置:管理接口的 Bearer token
# 未设置时管理接口仅放行 localhost 与局域网订阅端点始终公开token 即凭证)
- ADMIN_TOKEN=${ADMIN_TOKEN:-}

135
docs/ADDING-REGIONS.md Normal file
View File

@@ -0,0 +1,135 @@
# 新增地区与新增站点
当舰队里加入新地区(香港、日本、韩国、台湾、英国……)的节点时,按本文操作。
> 背景:策略组的地区筛选靠**节点名称正则**,不靠节点的 `region` 字段。所以节点命名是一切的前提。
## 当前状态2026-08-24
只有美国与新加坡两个地区的节点,因此策略组里只有 `🇺🇸 United States``🇸🇬 Singapore` 两个地区组。
香港、日本、台湾、英国、韩国的地区组**已删除**——留着会是空组,在客户端里显示为无可用节点。
兜底的 `🌍 Other` 组也已删除:所有节点都能被现有两个地区组收纳,它恒为空。
## 一、给新节点命名(决定它能被哪个组收纳)
命名格式:`<国旗> <国家码> · <站点码> · <协议> · <出口>`
```
🇭🇰 HK · VMess · 直连
🇯🇵 JP · Trojan · WARP
🇺🇸 US · LA · VMess · 直连 ← 同国多站点时插入站点码
```
- **国家码必须出现在名字里**HKJPUSSG…地区组的正则靠它匹配
- 出口词(`直连` / `WARP`)必须保留:客户端里没有出口标签,用户只能靠名字区分同协议的两条线路。界面上显示时会自动隐去,不必担心重复
- 站点码LARNAWS用于节点页的分段归类来自节点的 `region` 字段
节点的 `region` 字段填站点码(`SG``LA``RN``HK`…),它决定节点页里归到哪一段。
## 二、让站点标题显示国旗
`web/src/components/stations.ts``STATION_LABELS` 加一行:
```ts
const STATION_LABELS: Record<string, string> = {
SG: '🇸🇬 SG AWS',
LA: '🇺🇸 US LA',
RN: '🇺🇸 US RN',
HK: '🇭🇰 HK 香港站点名', // ← 新增
};
```
未配置的站点码会原样显示,不影响功能。
## 三、新建地区策略组
在「策略组」页点「添加策略组」,按下表填写:
| 字段 | 值 |
|---|---|
| 名称 | `🇭🇰 Hong Kong`emoji 前缀 + 英文原名) |
| 类型 | `url-test` |
| 成员 | 留空 |
| 收纳全部节点 | **开启** |
| 名称筛选正则 | 见下方对照表 |
| 测速 URL | `http://cp.cloudflare.com/generate_204` |
| 间隔 | `300` |
| 容差 | `50` |
「收纳全部节点」+「筛选正则」的组合会生成 `include-all-proxies=true, policy-regex-filter=…`Surge`include-all-proxies: true, filter: …`Clash`use=true, policy-regex-filter=…`ShadowRocket三端都是**动态筛选**——之后再加同地区节点会自动进组,不用改配置。
各地区的正则(取自原模板,可直接复制):
```
香港 港|🇭🇰|香港|HK|Hong
日本 日|🇯🇵|日本|JP|Japan
台湾 台|🇹🇼|台湾|TW|Tai
韩国 韩|韩国|Korea|KR|🇰🇷
英国 🇬🇧|英国|英|英格兰|UK|United Kingdom
新加坡 坡|🇸🇬|新加坡|狮城|SG|Singapore
美国 美|🇺🇸|美国|US|States|American
```
## 四、兜底组 `🌍 Other`(当前不存在)
原模板有一个 `🌍 Other` 组,用否定前瞻正则收纳「不属于任何已建地区组」的节点。**当前已删除**,因为现有节点都能被美/新两个组收纳,它恒为空。
只有当你加入的节点**不属于任何已建地区组**(比如加了德国节点但没建德国组)时,才需要重建它:
| 字段 | 值 |
|---|---|
| 名称 | `🌍 Other` |
| 类型 | `url-test`,收纳全部节点开启 |
| 筛选正则 | 见下(把所有**已建**地区组的关键字排除掉) |
```
^((?!港|🇭🇰|香港|HK|Hong|日|🇯🇵|日本|JP|Japan|坡|🇸🇬|新加坡|狮城|SG|Singapore|美|🇺🇸|美国|US|States|American|Remain|Expired|官网|如需|套餐|去除|剩余|距离|Reset|重置|流量).)+$
```
**如果重建了 Other每次新增地区组都必须往这个否定前瞻里追加对应关键字**,否则新地区节点会同时出现在自己的组和 Other 里。
## 五、把新地区加进服务组的可选项
新建地区组后,它不会自动出现在服务组的成员里。按需编辑这些组,把新地区加进成员列表:
| 组 | 当前成员 | 建议 |
|---|---|---|
| `⚡️ Automatic` | SG、US | 加入所有地区组 |
| `🚀 Proxy` | Automatic、SG、US | 加入所有地区组 |
| `🎬 Streaming` | SG、US | 加入解锁能力强的地区HK/TW/JP |
| `🤖 AI` | Automatic、US、SG | 加入 JP、US 等 AI 服务可用地区 |
| `🌐 Global Services` | Automatic、US、SG | 同 AI |
| `🍎 Apple` | Mainland、US | 按需加入 HK |
成员的顺序就是客户端里的排列顺序,**第一个成员是该组的默认选中项**。
## 六、地区流媒体解锁规则(可选)
模板原有 `stream_hk``stream_jp``stream_tw``stream_kr``stream_eu` 等按地区解锁的规则集。删除地区组时,这些规则被改指向了 `🎬 Streaming`
如果新建了对应地区组,可以在「规则」页把这些规则的策略改回该地区组,解锁效果更精准:
| 规则集 | 建议策略 |
|---|---|
| `stream_hk`non_ip + ip 两条) | `🇭🇰 Hong Kong` |
| `stream_jp`(两条) | `🇯🇵 Japan` |
| `stream_tw``stream_kr``stream_eu` | 对应地区组 |
## 七、验证
1. 「策略组」页:新地区组的**命中**一栏应列出该地区的所有节点
2. 「节点」页:新站点应有独立分段,标题显示国旗
3. 命令行校验 Clash 产物:
```bash
curl -s "http://<host>/sub/<token>/clash" > /tmp/c.yaml && mihomo -t -f /tmp/c.yaml
```
4. 若重建过 `🌍 Other`,确认它的命中里**不再包含**新地区节点
## 删除某个地区(反向操作)
1. 把指向该组的规则改指向别的组否则规则会被自动跳过——IR 层有悬空引用防护,但那是兜底不是意图)
2. 从其他组的成员里摘掉它
3. 删除该组
4. Other 的排除列表可以保留该地区关键字(留着无害,将来重建时省事)
> 上述 13 步如果漏做生成器不会产出无效配置悬空引用会被自动跳过、FINAL 会降级为 DIRECT但分流意图会悄悄改变所以要显式处理。

33
docs/SEEDING.md Normal file
View File

@@ -0,0 +1,33 @@
# 节点导入指引
proxy-station 不直接读取 edge-nodes 工作区(那里全是真实凭据,保持解耦),节点通过 Web 界面批量粘贴分享链接导入。
## 从 edge-nodes 交付文档导入
每个节点目录 `<id>-edge-node-docs/` 已生成好分享链接:
- `<proto>-<egress>.link`——VMessTrojan 的分享链接文件(`vmess://``trojan://`
- Shadowsocks 线路没有通用分享链接,用 sing-box JSON`ss-*-singbox.json`)里的参数手动添加,或按 SIP002 + v2ray-plugin 格式自拼:
`ss://base64url(chacha20-poly1305:密码)@域名:443?plugin=v2ray-plugin%3Btls%3Bmode%3Dwebsocket%3Bhost%3D域名%3Bpath%3D%2F路径#名称`
- Hysteria2 线路在 `scripts/node-links/` 下有 `hysteria2://` 链接(含 `obfs=salamander&obfs-password=…`
操作:
1. 在 edge-nodes 侧汇总链接:`cat ~/Development/Fusion/Projects/edge-nodes/*-edge-node-docs/*.link`
2. 打开 proxy-station「节点」页 →「批量导入」→ 粘贴(每行一条)→「解析预览」确认字段 →「导入」
3. SOCKS5 线路为内部使用,不要导入本系统
## 命名建议(影响地区组归类)
模板的地区策略组按**节点名正则**筛选(如 `坡|🇸🇬|新加坡|狮城|SG|Singapore``美|🇺🇸|美国|US`)。命名时带上地区词与出口词,例如:
- `SG-vmess-direct``SG-trojan-warp`(命中 Singapore 组)
- `US-LA-trojan-direct``US-RN-vmess-warp`(命中 United States 组;只写 LARN 不会命中任何地区组,会落入 Other
名称含 `direct``warp` 会自动打出口标签,线路矩阵按此归位(琥珀 = 直连,青 = WARP
## 导入后核对
- 「节点」页线路矩阵:每个站点的协议 × 出口格子是否齐全
- 「策略组」页:地区组的「命中」行是否圈中了预期节点
- 「订阅」页预览Surge 端确认 SS over WS 节点已被自动屏蔽预期行为Surge 不支持该组合)

720
docs/design-demos.html Normal file
View File

@@ -0,0 +1,720 @@
<!doctype html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Proxy Station · 设计方向 Demo</title>
<style>
/* ============ 全局与切换器 ============ */
* { margin: 0; padding: 0; box-sizing: border-box; }
html { -webkit-font-smoothing: antialiased; }
body { font-family: -apple-system, 'PingFang SC', 'Helvetica Neue', sans-serif; }
.switcher {
position: fixed; top: 16px; left: 50%; transform: translateX(-50%);
display: flex; gap: 2px; z-index: 99;
background: rgba(20,20,20,0.92); backdrop-filter: blur(12px);
border-radius: 8px; padding: 3px;
box-shadow: 0 4px 24px rgba(0,0,0,0.25);
}
.switcher button {
appearance: none; border: none; cursor: pointer;
background: transparent; color: #999;
font: 500 13px/1 -apple-system, 'PingFang SC', sans-serif;
padding: 8px 14px; border-radius: 6px;
}
.switcher button:hover { color: #fff; }
.switcher button.on { background: #fff; color: #111; }
.demo { display: none; min-height: 100vh; padding: 88px 0 80px; }
.demo.on { display: block; }
.frame { max-width: 1080px; margin: 0 auto; padding: 0 40px; }
.demo-intro { margin-bottom: 36px; }
.demo-intro .no { font-size: 12px; letter-spacing: 0.12em; }
.demo-intro h1 { margin: 6px 0 8px; }
.demo-intro p { max-width: 640px; }
/* =========================================================
方向 A 「站牌导视」 —— 交通导视系统:白底、粗黑标题、
线路色圆标,站名牌是签名元素。名字都叫 station 了。
========================================================= */
.demo-a {
--bg: #f7f7f4; --ink: #17181a; --sub: #6e7073; --line: #e2e2dd;
--direct: #b26a00; --direct-bg: #faf1e2; --warp: #007a72; --warp-bg: #e2f2f0;
background: var(--bg); color: var(--ink);
}
.demo-a .demo-intro .no { color: var(--sub); }
.demo-a h1 { font-size: 30px; font-weight: 800; letter-spacing: -0.01em; }
.demo-a .demo-intro p { color: var(--sub); font-size: 14px; line-height: 1.8; }
.demo-a .toolbar { display: flex; gap: 10px; margin-bottom: 28px; }
.demo-a .btn {
appearance: none; cursor: pointer; font: 600 13px/1 inherit;
padding: 10px 18px; border-radius: 999px; border: 1.5px solid transparent;
transition: transform 0.06s;
}
.demo-a .btn:active { transform: scale(0.98); }
.demo-a .btn-primary { background: var(--ink); color: #fff; }
.demo-a .btn-primary:hover { background: #000; }
.demo-a .btn-secondary { background: transparent; border-color: var(--ink); color: var(--ink); }
.demo-a .btn-secondary:hover { background: rgba(0,0,0,0.05); }
.demo-a .btn-plain { background: transparent; color: var(--sub); padding-left: 8px; padding-right: 8px; }
.demo-a .btn-plain:hover { color: var(--ink); }
/* 站名牌:黑底白字 + 线路色条,仿轨道交通站名标 */
.demo-a .station-sign {
background: var(--ink); color: #fff; border-radius: 10px;
padding: 18px 22px 14px; margin-bottom: 2px;
display: flex; align-items: baseline; gap: 14px;
}
.demo-a .station-sign .code { font-size: 30px; font-weight: 800; letter-spacing: 0.02em; }
.demo-a .station-sign .name { font-size: 13px; color: #c9c9c4; font-family: ui-monospace, 'SF Mono', Menlo, monospace; }
.demo-a .station-sign .count { margin-left: auto; font-size: 12px; color: #8b8d90; }
.demo-a .sign-strip { display: flex; height: 5px; border-radius: 0 0 6px 6px; overflow: hidden; margin-bottom: 16px; }
.demo-a .sign-strip i { flex: 1; }
.demo-a .sign-strip .s-direct { background: var(--direct); }
.demo-a .sign-strip .s-warp { background: var(--warp); }
.demo-a .card {
background: #fff; border: 1px solid var(--line); border-radius: 10px;
padding: 22px; margin-bottom: 28px;
}
.demo-a .card .platforms { display: flex; gap: 28px; }
.demo-a .platform { flex: 1; }
.demo-a .platform-head {
font-size: 12px; font-weight: 700; letter-spacing: 0.1em;
padding-bottom: 8px; margin-bottom: 10px; border-bottom: 2.5px solid;
}
.demo-a .platform-direct .platform-head { color: var(--direct); border-color: var(--direct); }
.demo-a .platform-warp .platform-head { color: var(--warp); border-color: var(--warp); }
.demo-a .platform ul { list-style: none; }
.demo-a .platform li {
display: flex; align-items: center; gap: 10px;
padding: 7px 0; font-size: 13.5px;
}
.demo-a .proto-dot {
width: 22px; height: 22px; border-radius: 50%; flex-shrink: 0;
display: inline-flex; align-items: center; justify-content: center;
font: 700 11px/1 inherit; color: #fff;
}
.demo-a .p-v { background: #275ad1; }
.demo-a .p-t { background: #8348c7; }
.demo-a .p-s { background: #2f7d3b; }
.demo-a .p-h { background: #c23d5d; }
.demo-a .platform .path { margin-left: auto; font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12px; color: var(--sub); }
.demo-a table { width: 100%; border-collapse: collapse; background: #fff; border: 1px solid var(--line); border-radius: 10px; overflow: hidden; }
.demo-a th {
text-align: left; font-size: 12px; font-weight: 700; letter-spacing: 0.06em;
color: var(--sub); padding: 12px 16px; border-bottom: 2px solid var(--ink); background: #fff;
}
.demo-a td { padding: 13px 16px; font-size: 13.5px; border-bottom: 1px solid var(--line); }
.demo-a tr:last-child td { border-bottom: none; }
.demo-a tr:hover td { background: #fbfbf8; }
.demo-a .mono { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12.5px; }
.demo-a .tag {
display: inline-flex; align-items: center; gap: 6px;
font-size: 12px; font-weight: 600; padding: 3px 10px; border-radius: 999px;
}
.demo-a .tag i { width: 7px; height: 7px; border-radius: 50%; }
.demo-a .tag-direct { background: var(--direct-bg); color: var(--direct); }
.demo-a .tag-direct i { background: var(--direct); }
.demo-a .tag-warp { background: var(--warp-bg); color: var(--warp); }
.demo-a .tag-warp i { background: var(--warp); }
.demo-a .tag-off { background: #eeeeea; color: var(--sub); }
.demo-a .rowact { color: var(--sub); font-size: 12.5px; cursor: pointer; }
.demo-a .rowact:hover { color: var(--ink); text-decoration: underline; }
/* =========================================================
方向 B 「纸上台账」 —— 档案登记簿:纸面、衬线标题、
墨蓝正文、出口语义做成印章。
========================================================= */
.demo-b {
--paper: #f4f1e9; --card: #fbf9f3; --ink: #2b2a24; --navy: #23406e;
--sub: #8a8577; --line: #ddd7c8; --seal-red: #b53a2e; --seal-blue: #23406e;
background: var(--paper); color: var(--ink);
}
.demo-b .demo-intro .no { color: var(--sub); font-family: ui-monospace, 'SF Mono', Menlo, monospace; }
.demo-b h1 {
font-family: 'Songti SC', 'STSong', Georgia, serif;
font-size: 32px; font-weight: 700; color: var(--navy);
}
.demo-b .demo-intro p { color: var(--sub); font-size: 14px; line-height: 2; }
.demo-b .toolbar { display: flex; gap: 10px; margin-bottom: 28px; }
.demo-b .btn {
appearance: none; cursor: pointer;
font: 600 13px/1 'Songti SC', 'STSong', Georgia, serif;
padding: 10px 20px; border-radius: 3px; letter-spacing: 0.08em;
border: 1px solid var(--ink); background: transparent; color: var(--ink);
}
.demo-b .btn-primary { background: var(--navy); border-color: var(--navy); color: var(--paper); }
.demo-b .btn-primary:hover { background: #1a3157; }
.demo-b .btn:not(.btn-primary):hover { background: rgba(43,42,36,0.06); }
.demo-b .btn-plain { border-color: transparent; color: var(--sub); }
.demo-b .btn-plain:hover { color: var(--ink); background: transparent; text-decoration: underline; text-underline-offset: 4px; }
.demo-b .card {
background: var(--card); border: 1px solid var(--line); border-radius: 4px;
padding: 24px 26px; margin-bottom: 28px; position: relative;
}
.demo-b .card::before {
content: ''; position: absolute; inset: 6px; pointer-events: none;
border: 1px solid var(--line); border-radius: 2px;
}
.demo-b .card-head { display: flex; align-items: baseline; gap: 14px; margin-bottom: 16px; position: relative; }
.demo-b .card-head .code {
font-family: 'Songti SC', 'STSong', Georgia, serif;
font-size: 26px; font-weight: 700; color: var(--navy);
}
.demo-b .card-head .domain { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12px; color: var(--sub); }
.demo-b .card-head .no { margin-left: auto; font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 11px; color: var(--sub); letter-spacing: 0.1em; }
/* 印章:出口语义 */
.demo-b .seal {
display: inline-flex; align-items: center; justify-content: center;
width: 34px; height: 34px; border-radius: 50%; flex-shrink: 0;
border: 2px solid; transform: rotate(-6deg);
font: 700 13px/1 'Songti SC', 'STSong', Georgia, serif;
}
.demo-b .seal-direct { color: var(--seal-red); border-color: var(--seal-red); }
.demo-b .seal-warp { color: var(--seal-blue); border-color: var(--seal-blue); }
.demo-b .ledger { list-style: none; }
.demo-b .ledger li {
display: flex; align-items: center; gap: 14px;
padding: 10px 2px; border-bottom: 1px dotted var(--line); font-size: 14px;
}
.demo-b .ledger li:last-child { border-bottom: none; }
.demo-b .ledger .idx { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 11px; color: var(--sub); width: 26px; }
.demo-b .ledger .leader { flex: 1; border-bottom: 1px dotted var(--line); height: 1px; margin: 0 4px; }
.demo-b .ledger .path { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12.5px; color: var(--navy); }
.demo-b table { width: 100%; border-collapse: collapse; }
.demo-b th {
text-align: left; font-family: 'Songti SC', 'STSong', Georgia, serif;
font-size: 13px; font-weight: 700; color: var(--navy);
padding: 10px 14px; border-bottom: 3px double var(--ink);
}
.demo-b td { padding: 12px 14px; font-size: 13.5px; border-bottom: 1px solid var(--line); background: var(--card); }
.demo-b tr:hover td { background: #f6f3ea; }
.demo-b .mono { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12.5px; }
.demo-b .tag {
display: inline-block; font-size: 12px; padding: 2px 10px;
border: 1px solid; border-radius: 2px; letter-spacing: 0.06em;
}
.demo-b .tag-direct { color: var(--seal-red); border-color: var(--seal-red); }
.demo-b .tag-warp { color: var(--seal-blue); border-color: var(--seal-blue); }
.demo-b .tag-proto { color: var(--sub); border-color: var(--line); background: rgba(255,255,255,0.5); }
.demo-b .rowact { color: var(--navy); font-size: 12.5px; cursor: pointer; }
.demo-b .rowact:hover { text-decoration: underline; text-underline-offset: 3px; }
/* =========================================================
方向 C 「克制暗色」 —— 修正现有暗色的 AI 味:中性炭黑、
零装饰、纯排版分层,强调色只落在数据本身。
========================================================= */
.demo-c {
--bg: #161616; --panel: #1c1c1c; --line: #282828;
--text: #e8e6e1; --sub: #8f8c85;
--direct: #d0a05c; --warp: #5fb3a1;
background: var(--bg); color: var(--text);
}
.demo-c .demo-intro .no { color: var(--sub); }
.demo-c h1 { font-size: 26px; font-weight: 600; letter-spacing: -0.01em; }
.demo-c .demo-intro p { color: var(--sub); font-size: 14px; line-height: 1.9; }
.demo-c .toolbar { display: flex; gap: 8px; margin-bottom: 32px; }
.demo-c .btn {
appearance: none; cursor: pointer; font: 500 13px/1 inherit;
padding: 9px 16px; border-radius: 6px; border: 1px solid transparent;
background: transparent; color: var(--text);
}
.demo-c .btn-primary { background: var(--text); color: #111; }
.demo-c .btn-primary:hover { background: #fff; }
.demo-c .btn-secondary { border-color: var(--line); background: transparent; color: var(--text); }
.demo-c .btn-secondary:hover { border-color: #3a3a3a; background: var(--panel); }
.demo-c .btn-plain { color: var(--sub); }
.demo-c .btn-plain:hover { color: var(--text); }
.demo-c .card { border: 1px solid var(--line); border-radius: 8px; margin-bottom: 32px; overflow: hidden; }
.demo-c .card-head {
display: flex; align-items: baseline; gap: 12px;
padding: 16px 20px; border-bottom: 1px solid var(--line);
}
.demo-c .card-head .code { font-size: 15px; font-weight: 600; }
.demo-c .card-head .domain { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12px; color: var(--sub); }
.demo-c .card-head .count { margin-left: auto; font-size: 12px; color: var(--sub); font-variant-numeric: tabular-nums; }
.demo-c .lines { list-style: none; }
.demo-c .lines li {
display: grid; grid-template-columns: 110px 1fr 90px; align-items: center;
padding: 11px 20px; font-size: 13px; border-bottom: 1px solid var(--line);
}
.demo-c .lines li:last-child { border-bottom: none; }
.demo-c .lines li:hover { background: var(--panel); }
.demo-c .lines .proto { color: var(--text); font-weight: 500; }
.demo-c .lines .path { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12.5px; }
.demo-c .path-direct { color: var(--direct); }
.demo-c .path-warp { color: var(--warp); }
.demo-c .lines .eg { text-align: right; font-size: 12px; color: var(--sub); }
.demo-c table { width: 100%; border-collapse: collapse; }
.demo-c th {
text-align: left; font-size: 11.5px; font-weight: 500; letter-spacing: 0.08em;
text-transform: uppercase; color: var(--sub);
padding: 10px 14px; border-bottom: 1px solid var(--line);
}
.demo-c td { padding: 13px 14px; font-size: 13px; border-bottom: 1px solid var(--line); font-variant-numeric: tabular-nums; }
.demo-c tr:hover td { background: var(--panel); }
.demo-c .mono { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12.5px; }
.demo-c .tag { display: inline-block; font-size: 12px; padding: 2px 8px; border-radius: 4px; border: 1px solid var(--line); color: var(--sub); }
.demo-c .tag-direct { color: var(--direct); border-color: rgba(208,160,92,0.35); }
.demo-c .tag-warp { color: var(--warp); border-color: rgba(95,179,161,0.35); }
.demo-c .rowact { color: var(--sub); font-size: 12.5px; cursor: pointer; }
.demo-c .rowact:hover { color: var(--text); }
/* =========================================================
方向 D 「仪表工业」 —— Rams 式仪器面板:冷灰、指示灯、
实体按键手感、小写字母间距标签。
========================================================= */
.demo-d {
--bg: #e9eaec; --card: #f7f8f9; --ink: #1b1d1f; --sub: #70757b;
--line: #cfd2d6; --direct: #d9480f; --warp: #2b8a3e;
background: var(--bg); color: var(--ink);
}
.demo-d .demo-intro .no { color: var(--sub); letter-spacing: 0.18em; }
.demo-d h1 { font-size: 26px; font-weight: 700; letter-spacing: -0.01em; }
.demo-d .demo-intro p { color: var(--sub); font-size: 14px; line-height: 1.9; }
.demo-d .toolbar { display: flex; gap: 10px; margin-bottom: 28px; }
.demo-d .btn {
appearance: none; cursor: pointer; font: 600 13px/1 inherit;
padding: 9px 16px; border-radius: 4px;
background: var(--card); color: var(--ink);
border: 1px solid var(--line); border-bottom: 2.5px solid #b7bbc0;
}
.demo-d .btn:active { border-bottom-width: 1px; transform: translateY(1.5px); }
.demo-d .btn-primary { background: var(--ink); color: #fff; border-color: var(--ink); border-bottom-color: #000; }
.demo-d .btn-plain { background: transparent; border-color: transparent; color: var(--sub); }
.demo-d .btn-plain:hover { color: var(--ink); }
.demo-d .label {
font-size: 10.5px; font-weight: 600; letter-spacing: 0.16em;
text-transform: uppercase; color: var(--sub);
}
.demo-d .card {
background: var(--card); border: 1px solid var(--line); border-radius: 6px;
padding: 20px 22px; margin-bottom: 28px;
box-shadow: 0 1px 0 rgba(255,255,255,0.8) inset, 0 1px 3px rgba(27,29,31,0.06);
}
.demo-d .card-head { display: flex; align-items: center; gap: 12px; margin-bottom: 16px; }
.demo-d .card-head .code { font-size: 20px; font-weight: 700; font-variant-numeric: tabular-nums; }
.demo-d .card-head .domain { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12px; color: var(--sub); }
.demo-d .meter { margin-left: auto; display: flex; align-items: center; gap: 6px; }
.demo-d .lamp { width: 9px; height: 9px; border-radius: 50%; }
.demo-d .lamp-direct { background: var(--direct); box-shadow: 0 0 0 2.5px rgba(217,72,15,0.15); }
.demo-d .lamp-warp { background: var(--warp); box-shadow: 0 0 0 2.5px rgba(43,138,62,0.15); }
.demo-d .grid { display: grid; grid-template-columns: repeat(2, 1fr); gap: 10px; }
.demo-d .slot {
border: 1px solid var(--line); border-radius: 4px; background: #fff;
padding: 10px 12px; display: flex; align-items: center; gap: 10px; font-size: 13px;
}
.demo-d .slot .path { margin-left: auto; font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12px; color: var(--sub); }
.demo-d table { width: 100%; border-collapse: collapse; background: var(--card); border: 1px solid var(--line); border-radius: 6px; overflow: hidden; }
.demo-d th { text-align: left; padding: 11px 14px; border-bottom: 1px solid var(--line); background: #eff1f3; }
.demo-d td { padding: 12px 14px; font-size: 13px; border-bottom: 1px solid #e3e5e8; font-variant-numeric: tabular-nums; }
.demo-d tr:last-child td { border-bottom: none; }
.demo-d tr:hover td { background: #fbfcfd; }
.demo-d .mono { font-family: ui-monospace, 'SF Mono', Menlo, monospace; font-size: 12.5px; }
.demo-d .tag {
display: inline-flex; align-items: center; gap: 6px;
font-size: 11px; font-weight: 600; letter-spacing: 0.1em; text-transform: uppercase;
padding: 3px 9px; border-radius: 3px; border: 1px solid var(--line); background: #fff; color: var(--sub);
}
.demo-d .tag i { width: 7px; height: 7px; border-radius: 50%; }
.demo-d .tag-direct { color: var(--direct); }
.demo-d .tag-direct i { background: var(--direct); }
.demo-d .tag-warp { color: var(--warp); }
.demo-d .tag-warp i { background: var(--warp); }
.demo-d .rowact { color: var(--sub); font-size: 12px; cursor: pointer; letter-spacing: 0.06em; }
.demo-d .rowact:hover { color: var(--ink); }
/* ============ 各方向的导航样例(选中态是重点) ============ */
.navdemo { display: flex; align-items: center; gap: 4px; margin-bottom: 28px; }
/* A选中 = 粗下划线(站台线条),不加底不加边 */
.demo-a .navdemo { gap: 22px; border-bottom: 1px solid var(--line); }
.demo-a .navdemo a {
text-decoration: none; color: var(--sub); font-size: 14px; font-weight: 600;
padding: 10px 2px 12px; border-bottom: 3px solid transparent; margin-bottom: -1px;
}
.demo-a .navdemo a:hover { color: var(--ink); }
.demo-a .navdemo a.cur { color: var(--ink); border-bottom-color: var(--ink); }
/* B选中 = 墨蓝衬线加粗 + 传统着重号 */
.demo-b .navdemo { gap: 26px; }
.demo-b .navdemo a {
text-decoration: none; color: var(--sub); font-size: 15px;
font-family: 'Songti SC', 'STSong', Georgia, serif; position: relative; padding: 4px 0;
}
.demo-b .navdemo a:hover { color: var(--ink); }
.demo-b .navdemo a.cur { color: var(--navy); font-weight: 700; }
.demo-b .navdemo a.cur::before {
content: '・'; position: absolute; left: 50%; transform: translateX(-50%);
top: -14px; color: var(--seal-red); font-size: 12px;
}
/* C选中 = 纯字色与字重变化,零装饰 */
.demo-c .navdemo { gap: 6px; }
.demo-c .navdemo a {
text-decoration: none; color: var(--sub); font-size: 13.5px;
padding: 7px 12px; border-radius: 6px;
}
.demo-c .navdemo a:hover { color: var(--text); }
.demo-c .navdemo a.cur { color: #fff; font-weight: 600; }
/* D选中 = 按下去的实体键(内凹) */
.demo-d .navdemo { gap: 6px; }
.demo-d .navdemo a {
text-decoration: none; color: var(--sub); font-size: 13px; font-weight: 600;
padding: 8px 14px; border-radius: 4px; border: 1px solid transparent;
}
.demo-d .navdemo a:hover { color: var(--ink); }
.demo-d .navdemo a.cur {
color: var(--ink); background: #dfe1e4; border-color: var(--line);
box-shadow: 0 1.5px 2px rgba(27,29,31,0.18) inset;
}
.section-label { margin: 0 0 12px; }
.demo-a .section-label { font-size: 13px; font-weight: 700; letter-spacing: 0.08em; color: var(--sub); }
.demo-b .section-label { font-family: 'Songti SC', 'STSong', Georgia, serif; font-size: 15px; font-weight: 700; color: var(--navy); }
.demo-c .section-label { font-size: 11.5px; font-weight: 500; letter-spacing: 0.1em; text-transform: uppercase; color: var(--sub); }
.demo-d .section-label { font-size: 10.5px; font-weight: 600; letter-spacing: 0.16em; text-transform: uppercase; color: var(--sub); }
</style>
</head>
<body>
<nav class="switcher" role="tablist">
<button class="on" data-t="a" role="tab">A 站牌导视</button>
<button data-t="b" role="tab">B 纸上台账</button>
<button data-t="c" role="tab">C 克制暗色</button>
<button data-t="d" role="tab">D 仪表工业</button>
</nav>
<!-- ================= A 站牌导视 ================= -->
<section class="demo demo-a on" id="demo-a">
<div class="frame">
<header class="demo-intro">
<div class="no">方向 A</div>
<h1>站牌导视</h1>
<p>轨道交通导视系统的语言:白底粗黑、线路色圆标、站名牌。系统本来就叫 Station——站点是车站协议是线路直连和 WARP 是两个站台。信息密度靠导视系统级的层级控制,而不是靠深色背景。</p>
</header>
<nav class="navdemo">
<a href="#" onclick="return false">节点</a>
<a href="#" onclick="return false" class="cur">策略组</a>
<a href="#" onclick="return false">规则</a>
<a href="#" onclick="return false">订阅</a>
<a href="#" onclick="return false">设置</a>
</nav>
<div class="toolbar">
<button class="btn btn-primary">添加节点</button>
<button class="btn btn-secondary">批量导入</button>
<button class="btn btn-plain">复制链接</button>
</div>
<p class="section-label">站点卡</p>
<div class="station-sign">
<span class="code">SG</span>
<span class="name">sg.example.com</span>
<span class="count">7 条线路 · AWS 新加坡</span>
</div>
<div class="sign-strip"><i class="s-direct"></i><i class="s-warp"></i></div>
<div class="card">
<div class="platforms">
<div class="platform platform-direct">
<div class="platform-head">直连出口 DIRECT</div>
<ul>
<li><span class="proto-dot p-v">V</span>VMess<span class="path">/9d3f01</span></li>
<li><span class="proto-dot p-t">T</span>Trojan<span class="path">/8a20c4</span></li>
<li><span class="proto-dot p-s">S</span>Shadowsocks<span class="path">/3f81b2</span></li>
<li><span class="proto-dot p-h">H</span>Hysteria2<span class="path">:443</span></li>
</ul>
</div>
<div class="platform platform-warp">
<div class="platform-head">WARP 净出口</div>
<ul>
<li><span class="proto-dot p-v">V</span>VMess<span class="path">/72e5a9</span></li>
<li><span class="proto-dot p-t">T</span>Trojan<span class="path">/93bf25</span></li>
<li><span class="proto-dot p-s">S</span>Shadowsocks<span class="path">/29c1b3</span></li>
</ul>
</div>
</div>
</div>
<p class="section-label">节点表</p>
<table>
<thead><tr><th>名称</th><th>协议</th><th>出口</th><th>服务器</th><th>路径</th><th></th></tr></thead>
<tbody>
<tr>
<td>SG-vmess-direct</td>
<td><span class="proto-dot p-v">V</span></td>
<td><span class="tag tag-direct"><i></i>直连</span></td>
<td class="mono">cc.sg.example.com:443</td>
<td class="mono">/9d3f01</td>
<td><span class="rowact">编辑</span></td>
</tr>
<tr>
<td>SG-trojan-warp</td>
<td><span class="proto-dot p-t">T</span></td>
<td><span class="tag tag-warp"><i></i>WARP</span></td>
<td class="mono">cc.sg.example.com:443</td>
<td class="mono">/93bf25</td>
<td><span class="rowact">编辑</span></td>
</tr>
<tr>
<td>LA-ss-direct已停用</td>
<td><span class="proto-dot p-s">S</span></td>
<td><span class="tag tag-off">已停用</span></td>
<td class="mono">cc.la.example.com:443</td>
<td class="mono">/3f81b2</td>
<td><span class="rowact">编辑</span></td>
</tr>
</tbody>
</table>
</div>
</section>
<!-- ================= B 纸上台账 ================= -->
<section class="demo demo-b" id="demo-b">
<div class="frame">
<header class="demo-intro">
<div class="no">No. B 登记簿式</div>
<h1>纸上台账</h1>
<p>档案登记簿的秩序感:纸面底色、衬线标题、墨蓝正文、点线引导。出口语义不用高亮色块,而是盖两枚印章——朱砂是直连,藏青是 WARP。数据库本来就是台账界面照着台账长。</p>
</header>
<nav class="navdemo">
<a href="#" onclick="return false">节点</a>
<a href="#" onclick="return false" class="cur">策略组</a>
<a href="#" onclick="return false">规则</a>
<a href="#" onclick="return false">订阅</a>
<a href="#" onclick="return false">设置</a>
</nav>
<div class="toolbar">
<button class="btn btn-primary">添加节点</button>
<button class="btn">批量导入</button>
<button class="btn btn-plain">复制链接</button>
</div>
<p class="section-label">站点卡</p>
<div class="card">
<div class="card-head">
<span class="code">新加坡 SG</span>
<span class="domain">sg.example.com</span>
<span class="no">REG-2026-001</span>
</div>
<ul class="ledger">
<li><span class="idx">01</span>VMess<span class="leader"></span><span class="path">/9d3f01</span><span class="seal seal-direct"></span></li>
<li><span class="idx">02</span>VMess<span class="leader"></span><span class="path">/72e5a9</span><span class="seal seal-warp">W</span></li>
<li><span class="idx">03</span>Trojan<span class="leader"></span><span class="path">/8a20c4</span><span class="seal seal-direct"></span></li>
<li><span class="idx">04</span>Shadowsocks<span class="leader"></span><span class="path">/29c1b3</span><span class="seal seal-warp">W</span></li>
<li><span class="idx">05</span>Hysteria2<span class="leader"></span><span class="path">:443</span><span class="seal seal-direct"></span></li>
</ul>
</div>
<p class="section-label">节点表</p>
<table>
<thead><tr><th>名称</th><th>协议</th><th>出口</th><th>服务器</th><th>路径</th><th></th></tr></thead>
<tbody>
<tr>
<td>SG-vmess-direct</td>
<td><span class="tag tag-proto">VMess</span></td>
<td><span class="tag tag-direct">直连</span></td>
<td class="mono">cc.sg.example.com:443</td>
<td class="mono">/9d3f01</td>
<td><span class="rowact">编辑</span></td>
</tr>
<tr>
<td>SG-trojan-warp</td>
<td><span class="tag tag-proto">Trojan</span></td>
<td><span class="tag tag-warp">WARP</span></td>
<td class="mono">cc.sg.example.com:443</td>
<td class="mono">/93bf25</td>
<td><span class="rowact">编辑</span></td>
</tr>
<tr>
<td>LA-ss-direct已停用</td>
<td><span class="tag tag-proto">Shadowsocks</span></td>
<td><span class="tag tag-proto">已停用</span></td>
<td class="mono">cc.la.example.com:443</td>
<td class="mono">/3f81b2</td>
<td><span class="rowact">编辑</span></td>
</tr>
</tbody>
</table>
</div>
</section>
<!-- ================= C 克制暗色 ================= -->
<section class="demo demo-c" id="demo-c">
<div class="frame">
<header class="demo-intro">
<div class="no">方向 C</div>
<h1>克制暗色</h1>
<p>保留暗色但把「AI 味」全部拿掉中性炭黑而非深蓝、零发光零亮边条、层级全部交给字重与留白。琥珀与青只出现在数据本身WS 路径)上——颜色只在承载信息时才出现。</p>
</header>
<nav class="navdemo">
<a href="#" onclick="return false">节点</a>
<a href="#" onclick="return false" class="cur">策略组</a>
<a href="#" onclick="return false">规则</a>
<a href="#" onclick="return false">订阅</a>
<a href="#" onclick="return false">设置</a>
</nav>
<div class="toolbar">
<button class="btn btn-primary">添加节点</button>
<button class="btn btn-secondary">批量导入</button>
<button class="btn btn-plain">复制链接</button>
</div>
<p class="section-label">站点卡</p>
<div class="card">
<div class="card-head">
<span class="code">SG · 新加坡</span>
<span class="domain">sg.example.com</span>
<span class="count">7 条线路</span>
</div>
<ul class="lines">
<li><span class="proto">VMess</span><span class="path path-direct">/9d3f01</span><span class="eg">直连</span></li>
<li><span class="proto">VMess</span><span class="path path-warp">/72e5a9</span><span class="eg">WARP</span></li>
<li><span class="proto">Trojan</span><span class="path path-direct">/8a20c4</span><span class="eg">直连</span></li>
<li><span class="proto">Shadowsocks</span><span class="path path-warp">/29c1b3</span><span class="eg">WARP</span></li>
<li><span class="proto">Hysteria2</span><span class="path path-direct">:443</span><span class="eg">直连</span></li>
</ul>
</div>
<p class="section-label">节点表</p>
<table>
<thead><tr><th>名称</th><th>协议</th><th>出口</th><th>服务器</th><th>路径</th><th></th></tr></thead>
<tbody>
<tr>
<td>SG-vmess-direct</td>
<td><span class="tag">vmess</span></td>
<td><span class="tag tag-direct">直连</span></td>
<td class="mono">cc.sg.example.com:443</td>
<td class="mono path-direct">/9d3f01</td>
<td><span class="rowact">编辑</span></td>
</tr>
<tr>
<td>SG-trojan-warp</td>
<td><span class="tag">trojan</span></td>
<td><span class="tag tag-warp">WARP</span></td>
<td class="mono">cc.sg.example.com:443</td>
<td class="mono path-warp">/93bf25</td>
<td><span class="rowact">编辑</span></td>
</tr>
<tr>
<td>LA-ss-direct已停用</td>
<td><span class="tag">ss</span></td>
<td><span class="tag">已停用</span></td>
<td class="mono">cc.la.example.com:443</td>
<td class="mono">/3f81b2</td>
<td><span class="rowact">编辑</span></td>
</tr>
</tbody>
</table>
</div>
</section>
<!-- ================= D 仪表工业 ================= -->
<section class="demo demo-d" id="demo-d">
<div class="frame">
<header class="demo-intro">
<div class="no">MODULE D</div>
<h1>仪表工业</h1>
<p>Dieter Rams 式仪器面板:冷灰机身、白色面板、实体按键的按压手感、大写字母间距的小标签。出口状态是两枚指示灯——橙灯直连、绿灯 WARP像老式功放上的通道指示。</p>
</header>
<nav class="navdemo">
<a href="#" onclick="return false">节点</a>
<a href="#" onclick="return false" class="cur">策略组</a>
<a href="#" onclick="return false">规则</a>
<a href="#" onclick="return false">订阅</a>
<a href="#" onclick="return false">设置</a>
</nav>
<div class="toolbar">
<button class="btn btn-primary">添加节点</button>
<button class="btn">批量导入</button>
<button class="btn btn-plain">复制链接</button>
</div>
<p class="section-label">Station Card 站点卡</p>
<div class="card">
<div class="card-head">
<span class="code">SG</span>
<span class="domain">sg.example.com</span>
<div class="meter">
<span class="label">DIRECT</span><i class="lamp lamp-direct"></i>
<span class="label" style="margin-left:10px">WARP</span><i class="lamp lamp-warp"></i>
</div>
</div>
<div class="grid">
<div class="slot"><i class="lamp lamp-direct"></i>VMess<span class="path">/9d3f01</span></div>
<div class="slot"><i class="lamp lamp-warp"></i>VMess<span class="path">/72e5a9</span></div>
<div class="slot"><i class="lamp lamp-direct"></i>Trojan<span class="path">/8a20c4</span></div>
<div class="slot"><i class="lamp lamp-warp"></i>Shadowsocks<span class="path">/29c1b3</span></div>
</div>
</div>
<p class="section-label">Nodes 节点表</p>
<table>
<thead><tr>
<th><span class="label">名称</span></th><th><span class="label">协议</span></th>
<th><span class="label">出口</span></th><th><span class="label">服务器</span></th>
<th><span class="label">路径</span></th><th></th>
</tr></thead>
<tbody>
<tr>
<td>SG-vmess-direct</td>
<td class="mono">vmess</td>
<td><span class="tag tag-direct"><i></i>Direct</span></td>
<td class="mono">cc.sg.example.com:443</td>
<td class="mono">/9d3f01</td>
<td><span class="rowact">EDIT</span></td>
</tr>
<tr>
<td>SG-trojan-warp</td>
<td class="mono">trojan</td>
<td><span class="tag tag-warp"><i></i>WARP</span></td>
<td class="mono">cc.sg.example.com:443</td>
<td class="mono">/93bf25</td>
<td><span class="rowact">EDIT</span></td>
</tr>
<tr>
<td>LA-ss-direct已停用</td>
<td class="mono">ss</td>
<td><span class="tag"><i style="background:#b7bbc0"></i>OFF</span></td>
<td class="mono">cc.la.example.com:443</td>
<td class="mono">/3f81b2</td>
<td><span class="rowact">EDIT</span></td>
</tr>
</tbody>
</table>
</div>
</section>
<script>
document.querySelectorAll('.switcher button').forEach(function (btn) {
btn.addEventListener('click', function () {
document.querySelectorAll('.switcher button').forEach(function (b) { b.classList.remove('on'); });
document.querySelectorAll('.demo').forEach(function (d) { d.classList.remove('on'); });
btn.classList.add('on');
document.getElementById('demo-' + btn.dataset.t).classList.add('on');
window.scrollTo(0, 0);
});
});
</script>
</body>
</html>

15
package.json Normal file
View File

@@ -0,0 +1,15 @@
{
"name": "proxy-station",
"version": "0.1.0",
"private": true,
"scripts": {
"dev": "concurrently -n server,web -c cyan,yellow \"pnpm --filter @proxy-station/server dev\" \"pnpm --filter @proxy-station/web dev\"",
"build": "pnpm --filter @proxy-station/shared build && pnpm --filter @proxy-station/web build && pnpm --filter @proxy-station/server build",
"typecheck": "pnpm -r typecheck",
"test": "pnpm --filter @proxy-station/server test",
"start": "pnpm --filter @proxy-station/server start"
},
"devDependencies": {
"concurrently": "^9.1.2"
}
}

2733
pnpm-lock.yaml generated Normal file

File diff suppressed because it is too large Load Diff

8
pnpm-workspace.yaml Normal file
View File

@@ -0,0 +1,8 @@
packages:
- shared
- server
- web
allowBuilds:
better-sqlite3: true
esbuild: true
vue-demi: true

View File

@@ -0,0 +1,303 @@
[General]
# --- GENERAL / 通用设置 ---
# Enhanced Wi-Fi Assist / 增强 Wi-Fi 助手
wifi-assist = true
# Hybrid Network / 混合网络
all-hybrid = false
# Gaming Optimization / 游戏优化
udp-priority = false
# Latency Benchmark / 延迟基准测试
internet-test-url = http://connectivitycheck.gstatic.com/generate_204
proxy-test-url = http://captive.apple.com/generate_204
test-timeout = 3
# GeoIP Database / GeoIP 数据库
geoip-maxmind-url = https://github.com/Hackl0us/GeoIP2-CN/raw/release/Country.mmdb
# IPv6 Support / IPv6 支持
ipv6 = false
ipv6-vif = auto
# --- Wi-Fi ACCESS / Wi-Fi 访问 ---
allow-wifi-access = false
wifi-access-http-port = 6152
wifi-access-socks5-port = 6153
http-listen = 0.0.0.0
socks5-listen = 0.0.0.0
allow-hotspot-access = true
# --- REMOTE CONTROLLER / 远程控制器 ---
external-controller-access = surge@0.0.0.0:6160
http-api = clashconnectrules@0.0.0.0:6166
http-api-tls = true
http-api-web-dashboard = true
# --- COMPATIBILITY / 兼容性 ---
compatibility-mode = 1
# --- NETWORK / 网络 ---
skip-proxy = localhost, *.local, captive.apple.com, guzzoni.apple.com, 0.0.0.0/8, 10.0.0.0/8, 17.0.0.0/8, 100.64.0.0/10, 127.0.0.0/8, 169.254.0.0/16, 172.16.0.0/12, 192.0.0.0/24, 192.0.2.0/24, 192.168.0.0/16, 192.88.99.0/24, 198.18.0.0/15, 198.51.100.0/24, 203.0.113.0/24, 224.0.0.0/4, 240.0.0.0/4, 255.255.255.255/32
exclude-simple-hostnames = true
read-etc-hosts = true
# --- DNS / 域名系统 ---
use-local-host-item-for-proxy = true
encrypted-dns-follow-outbound-mode = false
include-all-networks = false
include-local-networks = false
dns-server = 223.5.5.5, 223.6.6.6, 119.29.29.29
encrypted-dns-server = https://doh.pub/dns-query, https://dns.alidns.com/dns-query
loglevel = notify
# --- ADVANCED / 高级设置 ---
show-error-page-for-reject = true
force-http-engine-hosts = *.ott.cibntv.net, 123.59.31.1, 119.18.193.135, 122.14.246.33, 175.102.178.52, 116.253.24.*, 175.6.26.*, 220.169.153.*
always-real-ip = link-ip.nextdns.io, *.msftconnecttest.com, *.msftncsi.com, *.srv.nintendo.net, *.stun.playstation.net, xbox.*.microsoft.com, *.xboxlive.com, *.logon.battlenet.com.cn, *.logon.battle.net, stun.l.google.com
hijack-dns = 8.8.8.8:53, 8.8.4.4:53
udp-policy-not-supported-behaviour = REJECT
proxy-restricted-to-lan = false
[Proxy]
[Proxy Group]
# ==================== 核心策略分组 / Core Policy Groups ====================
Mainland = select, DIRECT, no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/05icon/direct.png
AllServer = select, policy-path="Your Surge subscription link goes here", update-interval=86400, no-alert=0, hidden=0, include-all-proxies=0, policy-regex-filter=^((?!Remain|Expired|官网|如需|套餐|去除|剩余|距离|Reset|重置|流量).)+$, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/05icon/rocket(1).png
# ==================== 地区自动选择组 / Region Auto-Select Groups ====================
Hong Kong = url-test, update-interval=0, policy-regex-filter=港|🇭🇰|香港|HK|Hong, no-alert=0, hidden=0, include-all-proxies=0, include-other-group=AllServer, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/01Country/Hongkong.png, url=http://cp.cloudflare.com/generate_204, interval=300, tolerance=50, timeout=3
Taiwan = url-test, update-interval=0, policy-regex-filter=台|🇹🇼|台湾|TW|Tai, no-alert=0, hidden=0, include-all-proxies=0, include-other-group=AllServer, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/01Country/taiwan.png, url=http://cp.cloudflare.com/generate_204, interval=300, tolerance=50, timeout=3
Japan = url-test, update-interval=0, policy-regex-filter=日|🇯🇵|日本|JP|Japan, no-alert=0, hidden=0, include-all-proxies=0, include-other-group=AllServer, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/01Country/Japan.png, url=http://cp.cloudflare.com/generate_204, interval=300, tolerance=50, timeout=3
Singapore = url-test, update-interval=0, policy-regex-filter=坡|🇸🇬|新加坡|狮城|SG|Singapore, no-alert=0, hidden=0, include-all-proxies=0, include-other-group=AllServer, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/01Country/singapore.png, url=http://cp.cloudflare.com/generate_204, interval=300, tolerance=50, timeout=3
United States = url-test, update-interval=0, policy-regex-filter=美|🇺🇸|美国|US|States|American, no-alert=0, hidden=0, include-all-proxies=0, include-other-group=AllServer, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/01Country/US.png, url=http://cp.cloudflare.com/generate_204, interval=300, tolerance=50, timeout=3
United Kingdom = url-test, update-interval=0, policy-regex-filter=🇬🇧|英国|英|英格兰|UK|United Kingdom, no-alert=0, hidden=0, include-all-proxies=0, include-other-group=AllServer, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/01Country/UnitedKingdom.png, url=http://cp.cloudflare.com/generate_204, interval=300, tolerance=50, timeout=3
Korea = url-test, update-interval=0, policy-regex-filter=韩|韩国|Korea|KR|🇰🇷, no-alert=0, hidden=0, include-all-proxies=0, include-other-group=AllServer, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/01Country/Korea.png, url=http://cp.cloudflare.com/generate_204, interval=300, tolerance=50, timeout=3
Other = url-test, update-interval=0, policy-regex-filter=^((?!港|🇭🇰|香港|HK|Hong|台|🇹🇼|台湾|TW|Tai|日|🇯🇵|日本|JP|Japan|坡|🇸🇬|新加坡|狮城|SG|Singapore|美|🇺🇸|美国|US|States|American|🇬🇧|英国|英|英格兰|UK|United Kingdom|韩|韩国|Korea|KR|🇰🇷|Remain|Expired|官网|如需|套餐|去除|剩余|距离|Reset|重置|流量).)+$, no-alert=0, hidden=0, include-all-proxies=0, include-other-group=AllServer, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/01Country/EuropeanUnion.png, url=http://cp.cloudflare.com/generate_204, interval=300, tolerance=50, timeout=3
# ==================== 组合策略 / Combined Policies ====================
Automatic = select, "Hong Kong", Taiwan, Japan, Singapore, "United States", "United Kingdom", Korea, url=http://cp.cloudflare.com/generate_204, interval=300, tolerance=50, timeout=3, no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/05icon/lightning(5).png
Proxy = select, Automatic, "Hong Kong", Taiwan, Singapore, Japan, "United States", "United Kingdom", no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/05icon/rocket(1).png
NoAuto = select, Mainland, Automatic, no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/05icon/lightning.png
# ==================== 应用服务策略 / App Service Policies ====================
# --- 苹果服务 / Apple Services ---
Apple = select, Mainland, "Hong Kong", "United States", icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/03CNSoft/apple.png
# --- AI 服务 / AI Services ---
AI = select, Automatic, "United States", Japan, Singapore, no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/04ProxySoft/chatgpt(1).png
# --- 微软服务 / Microsoft Services ---
Microsoft = select, Mainland, "Hong Kong", Singapore, "United States", icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/03CNSoft/microsoft.png
OneDrive = select, Mainland, "Hong Kong", Singapore, "United States", icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/03CNSoft/OneDrive.png
# --- 社交通讯 / Social & Messaging ---
Telegram = select, Automatic, Singapore, "United States", "Hong Kong", Taiwan, Japan, no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/04ProxySoft/telegram.png
WeChat = select, Mainland, "Hong Kong", Singapore, "United States", icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/03CNSoft/wechat.png
X = select, Automatic, "Hong Kong", Taiwan, Singapore, Japan, "United States", no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/04ProxySoft/twitter.png
# --- 流媒体服务 / Streaming Services ---
Bilibili = select, Mainland, "Hong Kong", Taiwan, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/03CNSoft/bilibili.png
Disney+ = select, "Hong Kong", Singapore, no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/04ProxySoft/disney.png
Netflix = select, "Hong Kong", Taiwan, Singapore, Japan, "United States", icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/04ProxySoft/netflix.png
TikTok = select, Taiwan, Singapore, Japan, "United States", no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/04ProxySoft/tiktok.png
YouTube = select, Automatic, "Hong Kong", Taiwan, Singapore, Japan, "United States", no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/04ProxySoft/Youtube.png
# --- 工具服务 / Utility Services ---
Speedtest = select, Mainland, Automatic, AllServer, no-alert=0, hidden=0, include-all-proxies=0, icon-url=https://raw.githubusercontent.com/lige47/QuanX-icon-rule/main/icon/03CNSoft/speedtest.png
[Rule]
# >> 规则修正 (Unbreak Rules)
RULE-SET,https://raw.githubusercontent.com/zxfccmm4/Profiles/refs/heads/main/Surge/Ruleset/Unbreak.list,DIRECT
# >> 广告拦截 (Ad Blocking)
DOMAIN-SET,https://ruleset.skk.moe/List/domainset/reject.conf,REJECT
RULE-SET,https://ruleset.skk.moe/List/non_ip/reject-drop.conf,REJECT-DROP
RULE-SET,https://ruleset.skk.moe/List/non_ip/reject.conf,REJECT
RULE-SET,https://ruleset.skk.moe/List/ip/reject.conf,REJECT-DROP
# >> 隐私保护 (Privacy Protection)
DOMAIN,app-site-association.cdn-apple.com,REJECT
DOMAIN,prpr.96110.cn.com,DIRECT
DOMAIN-KEYWORD,96110,REJECT
DOMAIN-SUFFIX,gjfzpt.cn,REJECT
# >> 国内应用 (Mainland Apps)
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/WeChat/WeChat.list,WeChat
RULE-SET,https://ruleset.skk.moe/List/non_ip/neteasemusic.conf,Mainland
RULE-SET,https://ruleset.skk.moe/List/ip/neteasemusic.conf,Mainland
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/BiliBili/BiliBili.list,Bilibili
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Weibo/Weibo.list,Mainland
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/XiaoHongShu/XiaoHongShu.list,Mainland
# >> Apple 服务 (Apple Services)
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/AppStore/AppStore.list,DIRECT
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/AppleNews/AppleNews.list,"United States"
DOMAIN-SET,https://ruleset.skk.moe/List/domainset/apple_cdn.conf,Apple
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/AppleTV/AppleTV.list,Apple
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Apple/Apple.list,Apple
# >> AI 服务 (AI Services)
DOMAIN-KEYWORD,diabrowser.engineering,AI
DOMAIN-SUFFIX,apple-relay.apple.com,AI
DOMAIN-SUFFIX,apple-relay.cloudflare.com,AI
DOMAIN-KEYWORD,apple-relay,AI
DOMAIN-SUFFIX,googleapis.com,AI
RULE-SET,https://ruleset.skk.moe/List/non_ip/ai.conf,AI
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Bing/Bing.list,AI
DOMAIN-SUFFIX,diabrowser.engineering,AI
# >> 国外流媒体 (International Streaming)
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Disney/Disney.list,Disney+
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Netflix/Netflix.list,Netflix
RULE-SET,https://raw.githubusercontent.com/Semporia/TikTok-Unlock/master/Surge/TikTok.list,TikTok
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/YouTube/YouTube.list,YouTube
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/GoogleSearch/GoogleSearch.list,YouTube
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Emby/Emby.list,Automatic
# >> 地区流媒体解锁 (Regional Streaming Unlock)
RULE-SET,https://ruleset.skk.moe/List/non_ip/stream_us.conf,"United States"
RULE-SET,https://ruleset.skk.moe/List/ip/stream_us.conf,"United States"
RULE-SET,https://ruleset.skk.moe/List/non_ip/stream_eu.conf,"United Kingdom"
RULE-SET,https://ruleset.skk.moe/List/ip/stream_eu.conf,"United Kingdom"
RULE-SET,https://ruleset.skk.moe/List/non_ip/stream_jp.conf,Japan
RULE-SET,https://ruleset.skk.moe/List/ip/stream_jp.conf,Japan
RULE-SET,https://ruleset.skk.moe/List/non_ip/stream_kr.conf,Korea
RULE-SET,https://ruleset.skk.moe/List/ip/stream_kr.conf,Korea
RULE-SET,https://ruleset.skk.moe/List/non_ip/stream_hk.conf,"Hong Kong"
RULE-SET,https://ruleset.skk.moe/List/ip/stream_hk.conf,"Hong Kong"
RULE-SET,https://ruleset.skk.moe/List/non_ip/stream_tw.conf,Taiwan
RULE-SET,https://ruleset.skk.moe/List/ip/stream_tw.conf,Taiwan
# >> 国外社交媒体 (International Social Media)
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Twitter/Twitter.list,X
RULE-SET,https://ruleset.skk.moe/List/non_ip/telegram.conf,Telegram
RULE-SET,https://ruleset.skk.moe/List/ip/telegram.conf,Telegram
RULE-SET,https://ruleset.skk.moe/List/ip/telegram_asn.conf,Telegram
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Facebook/Facebook.list,Automatic
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Instagram/Instagram.list,Automatic
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Threads/Threads.list,Automatic
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Discord/Discord.list,Automatic
# >> 其他国外服务 (Other International Services)
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/OneDrive/OneDrive.list,OneDrive
RULE-SET,https://ruleset.skk.moe/List/non_ip/microsoft.conf,Microsoft
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/GitHub/GitHub.list,Automatic
RULE-SET,https://raw.githubusercontent.com/getsomecat/GetSomeCats/Surge/rule/substore.list,Automatic
DOMAIN-SUFFIX,vercel.app,Automatic
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Speedtest/Speedtest.list,Speedtest
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Riot/Riot.list,"United States"
DOMAIN-SUFFIX,mypikpak.com,"United States"
DOMAIN-SUFFIX,nssurge.com,Automatic
DOMAIN-SUFFIX,surgee.me,Automatic
DOMAIN-SUFFIX,www.torrentmac.net,Automatic
DOMAIN-SUFFIX,cloudflare.com,Automatic
DOMAIN,jable.tv,Automatic
DOMAIN,api.amplitude.com,Automatic
DOMAIN,m.cmx.im,Automatic
DOMAIN-SUFFIX,api.themoviedb.org,Automatic
# >> 国内规则 (Mainland China Rules)
RULE-SET,https://ruleset.skk.moe/List/non_ip/direct.conf,Mainland
RULE-SET,https://ruleset.skk.moe/List/non_ip/domestic.conf,Mainland
RULE-SET,https://ruleset.skk.moe/List/ip/domestic.conf,Mainland
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/ChinaMax/ChinaMax.list,Mainland
RULE-SET,https://raw.githubusercontent.com/VirgilClyne/GetSomeFries/main/ruleset/ASN.China.list,DIRECT
DOMAIN-SET,https://ruleset.skk.moe/List/domainset/download.conf,Mainland
RULE-SET,https://ruleset.skk.moe/List/non_ip/download.conf,Mainland
RULE-SET,https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Surge/Tesla/Tesla.list,DIRECT
DOMAIN-SUFFIX,appstorrent.ru,DIRECT
# >> 国外规则 (Global Rules)
DOMAIN-SET,https://ruleset.skk.moe/List/domainset/cdn.conf,Automatic
RULE-SET,https://ruleset.skk.moe/List/non_ip/cdn.conf,Automatic
RULE-SET,https://ruleset.skk.moe/List/non_ip/global_plus.conf,Automatic
RULE-SET,https://ruleset.skk.moe/List/non_ip/global.conf,Automatic
# >> 网络优化与特殊规则 (Network Optimization)
AND,((PROTOCOL,UDP), (DOMAIN-SUFFIX,googlevideo.com)),REJECT-NO-DROP
DOMAIN-SUFFIX,smtp,DIRECT
URL-REGEX,(Subject|HELO|SMTP),DIRECT
# >> 本地网络 (LAN)
RULE-SET,LAN,DIRECT
# >> 兜底规则 (Final Rule)
FINAL,NoAuto,dns-failed
[Host]
*.taobao.com = server:223.5.5.5
*.tmall.com = server:223.5.5.5
*.alipay.com = server:223.5.5.5
*.alicdn.com = server:223.5.5.5
*.aliyun.com = server:223.5.5.5
*.jd.com = server:119.28.28.28
*.qq.com = server:119.28.28.28
*.tencent.com = server:119.28.28.28
*.weixin.com = server:119.28.28.28
*.bilibili.com = server:119.29.29.29
hdslb.com = server:119.29.29.29
*.163.com = server:119.29.29.29
*.126.com = server:119.29.29.29
*.126.net = server:119.29.29.29
*.127.net = server:119.29.29.29
*.netease.com = server:119.29.29.29
*.mi.com = server:119.29.29.29
*.xiaomi.com = server:119.29.29.29
*testflight.apple.com = server:8.8.4.4
# > Firebase Cloud Messaging / Firebase 云消息
mtalk.google.com = 108.177.125.188
# > Google Download / Google 下载
dl.google.com = server:119.29.29.29
dl.l.google.com = server:119.29.29.29
update.googleapis.com = server:119.29.29.29
# > Router Admin Panel / 路由器管理面板
amplifi.lan = server:system // Ubiquiti Amplifi Router
router.synology.com = server:system // Synology Router
sila.razer.com = server:system // Razer Sila Router
router.asus.com = server:system // Asus Router
routerlogin.net = server:system // Netgear Router
orbilogin.com = server:system // Netgear Obri Router
www.LinksysSmartWiFi.com = server:system // Linksys Router
LinksysSmartWiFi.com = server:system // Linksys Router
myrouter.local = server:system // Linksys Router
www.miwifi.com = server:system // Xiaomi Mi WiFi Router
miwifi.com = server:system // Xiaomi Mi WiFi Router
mediarouter.home = server:system // Huawei Router
tplogin.cn = server:system // TP-Link Router
tplinklogin.net = server:system // TP-Link Router
melogin.cn = server:system // MERCURY Router
falogin.cn = server:system // FAST Router
[URL Rewrite]
# > Redirect Google Services / 重定向 Google 服务
^https?:\/\/(www\.)?(g|google)\.cn https://www.google.com 302
^https?:\/\/(ditu|maps)\.google\.cn https://maps.google.com 302
# > HTTPS Redirects / HTTPS 重定向
^https?:\/\/(www\.)?taobao\.com\/ https://taobao.com/ 302
^https?:\/\/(www\.)?jd\.com\/ https://www.jd.com/ 302
^https?:\/\/(www\.)?mi\.com\/ https://www.mi.com/ 302
^https?:\/\/you\.163\.com\/ https://you.163.com/ 302
^https?:\/\/(www\.)?suning\.com\/ https://suning.com/ 302
^https?:\/\/(www\.)?yhd\.com\/ https://yhd.com/ 302
# > Service Optimizations / 服务优化
^https?:\/\/api\.abema\.io\/v\d\/ip\/check - reject
[Header Rewrite]
# 解决github速率限制返回429问题 / Fix GitHub 429 Rate Limit Issue
http-request ^https:\/\/github\.com\/ header-replace Accept-Language en-us
http-request ^https:\/\/(raw|gist)\.githubusercontent\.com\/ header-replace Accept-Language en-us
[MITM]
skip-server-cert-verify = true
tcp-connection = true
h2 = true
hostname = www.google.cn, api.abema.io, *.zhihu.com, -CUSTOMMitM, sub.store
[Script]
# > Flush DNS, show the DNS delay and server / 刷新 DNS显示延迟和服务器

32
server/package.json Normal file
View File

@@ -0,0 +1,32 @@
{
"name": "@proxy-station/server",
"version": "0.1.0",
"private": true,
"type": "module",
"scripts": {
"dev": "tsx watch src/index.ts",
"build": "tsc --noEmit",
"start": "tsx src/index.ts",
"typecheck": "tsc --noEmit",
"test": "vitest run"
},
"dependencies": {
"@hono/node-server": "^1.13.7",
"@hono/zod-validator": "^0.4.2",
"@proxy-station/shared": "workspace:*",
"better-sqlite3": "^11.7.0",
"drizzle-orm": "^0.38.3",
"hono": "^4.6.14",
"nanoid": "^5.0.9",
"tsx": "^4.19.2",
"undici": "^7.2.0",
"yaml": "^2.6.1",
"zod": "^3.24.1"
},
"devDependencies": {
"@types/better-sqlite3": "^7.6.12",
"@types/node": "^22.10.2",
"typescript": "^5.7.2",
"vitest": "^2.1.8"
}
}

125
server/src/db/index.ts Normal file
View File

@@ -0,0 +1,125 @@
import Database from 'better-sqlite3';
import { drizzle } from 'drizzle-orm/better-sqlite3';
import fs from 'node:fs';
import path from 'node:path';
import { env } from '../env.js';
import * as schema from './schema.js';
const BOOTSTRAP_SQL = `
CREATE TABLE IF NOT EXISTS nodes (
id TEXT PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
protocol TEXT NOT NULL,
server TEXT NOT NULL,
port INTEGER NOT NULL,
network TEXT NOT NULL DEFAULT 'tcp',
ws_path TEXT,
ws_host TEXT,
tls INTEGER NOT NULL DEFAULT 0,
sni TEXT,
skip_cert_verify INTEGER NOT NULL DEFAULT 0,
uuid TEXT,
alter_id INTEGER NOT NULL DEFAULT 0,
security TEXT NOT NULL DEFAULT 'auto',
password TEXT,
method TEXT,
obfs_type TEXT,
obfs_password TEXT,
up_mbps INTEGER,
down_mbps INTEGER,
region TEXT,
tags TEXT NOT NULL DEFAULT '[]',
enabled INTEGER NOT NULL DEFAULT 1,
sort_order INTEGER NOT NULL DEFAULT 0,
extra TEXT NOT NULL DEFAULT '{}',
created_at INTEGER NOT NULL,
updated_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS policy_groups (
id TEXT PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
type TEXT NOT NULL,
test_url TEXT,
interval INTEGER,
tolerance INTEGER,
filter_regex TEXT,
include_all_nodes INTEGER NOT NULL DEFAULT 0,
enabled INTEGER NOT NULL DEFAULT 1,
sort_order INTEGER NOT NULL DEFAULT 0,
source TEXT NOT NULL DEFAULT 'custom'
);
CREATE TABLE IF NOT EXISTS group_members (
id INTEGER PRIMARY KEY AUTOINCREMENT,
group_id TEXT NOT NULL REFERENCES policy_groups(id) ON DELETE CASCADE,
member_kind TEXT NOT NULL,
node_id TEXT REFERENCES nodes(id) ON DELETE CASCADE,
ref_name TEXT,
sort_order INTEGER NOT NULL DEFAULT 0
);
CREATE TABLE IF NOT EXISTS rules (
id TEXT PRIMARY KEY,
seq INTEGER NOT NULL,
type TEXT NOT NULL,
value TEXT,
policy TEXT NOT NULL,
params TEXT NOT NULL DEFAULT '[]',
enabled INTEGER NOT NULL DEFAULT 1,
source TEXT NOT NULL DEFAULT 'custom'
);
CREATE TABLE IF NOT EXISTS rulesets (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
surge_url TEXT NOT NULL UNIQUE,
clash_url TEXT,
clash_behavior TEXT NOT NULL DEFAULT 'classical',
clash_format TEXT NOT NULL DEFAULT 'yaml',
needs_convert INTEGER NOT NULL DEFAULT 0
);
CREATE TABLE IF NOT EXISTS ruleset_cache (
url TEXT PRIMARY KEY,
content TEXT NOT NULL,
etag TEXT,
fetched_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS sub_tokens (
id TEXT PRIMARY KEY,
token TEXT NOT NULL UNIQUE,
name TEXT NOT NULL,
node_ids TEXT NOT NULL DEFAULT '[]',
enabled INTEGER NOT NULL DEFAULT 1,
created_at INTEGER NOT NULL,
last_access_at INTEGER,
access_count INTEGER NOT NULL DEFAULT 0
);
CREATE TABLE IF NOT EXISTS settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);
`;
export function createDb(dbPath?: string) {
const file = dbPath ?? path.join(env.dataDir, 'proxy-station.db');
if (file !== ':memory:') {
fs.mkdirSync(path.dirname(file), { recursive: true });
}
const sqlite = new Database(file);
sqlite.pragma('journal_mode = WAL');
sqlite.pragma('foreign_keys = ON');
sqlite.exec(BOOTSTRAP_SQL);
// 轻量迁移:旧库补列
for (const stmt of [
'ALTER TABLE policy_groups ADD COLUMN enabled INTEGER NOT NULL DEFAULT 1',
"ALTER TABLE sub_tokens ADD COLUMN node_ids TEXT NOT NULL DEFAULT '[]'",
]) {
try {
sqlite.exec(stmt);
} catch {
// 列已存在
}
}
return drizzle(sqlite, { schema });
}
export type Db = ReturnType<typeof createDb>;
export const db = createDb();

101
server/src/db/schema.ts Normal file
View File

@@ -0,0 +1,101 @@
import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
export const nodes = sqliteTable('nodes', {
id: text('id').primaryKey(),
name: text('name').notNull().unique(),
protocol: text('protocol', { enum: ['vmess', 'trojan', 'shadowsocks', 'hysteria2'] }).notNull(),
server: text('server').notNull(),
port: integer('port').notNull(),
network: text('network', { enum: ['tcp', 'ws'] }).notNull().default('tcp'),
wsPath: text('ws_path'),
wsHost: text('ws_host'),
tls: integer('tls', { mode: 'boolean' }).notNull().default(false),
sni: text('sni'),
skipCertVerify: integer('skip_cert_verify', { mode: 'boolean' }).notNull().default(false),
uuid: text('uuid'),
alterId: integer('alter_id').notNull().default(0),
security: text('security').notNull().default('auto'),
password: text('password'),
method: text('method'),
obfsType: text('obfs_type'),
obfsPassword: text('obfs_password'),
upMbps: integer('up_mbps'),
downMbps: integer('down_mbps'),
region: text('region'),
tags: text('tags').notNull().default('[]'),
enabled: integer('enabled', { mode: 'boolean' }).notNull().default(true),
sortOrder: integer('sort_order').notNull().default(0),
extra: text('extra').notNull().default('{}'),
createdAt: integer('created_at').notNull(),
updatedAt: integer('updated_at').notNull(),
});
export const policyGroups = sqliteTable('policy_groups', {
id: text('id').primaryKey(),
name: text('name').notNull().unique(),
type: text('type', { enum: ['select', 'url-test', 'fallback'] }).notNull(),
testUrl: text('test_url'),
interval: integer('interval'),
tolerance: integer('tolerance'),
filterRegex: text('filter_regex'),
includeAllNodes: integer('include_all_nodes', { mode: 'boolean' }).notNull().default(false),
enabled: integer('enabled', { mode: 'boolean' }).notNull().default(true),
sortOrder: integer('sort_order').notNull().default(0),
source: text('source', { enum: ['template', 'custom'] }).notNull().default('custom'),
});
export const groupMembers = sqliteTable('group_members', {
id: integer('id').primaryKey({ autoIncrement: true }),
groupId: text('group_id')
.notNull()
.references(() => policyGroups.id, { onDelete: 'cascade' }),
memberKind: text('member_kind', { enum: ['node', 'group', 'builtin'] }).notNull(),
nodeId: text('node_id').references(() => nodes.id, { onDelete: 'cascade' }),
refName: text('ref_name'),
sortOrder: integer('sort_order').notNull().default(0),
});
export const rules = sqliteTable('rules', {
id: text('id').primaryKey(),
seq: integer('seq').notNull(),
type: text('type').notNull(),
value: text('value'),
policy: text('policy').notNull(),
params: text('params').notNull().default('[]'),
enabled: integer('enabled', { mode: 'boolean' }).notNull().default(true),
source: text('source', { enum: ['template', 'custom'] }).notNull().default('custom'),
});
export const rulesets = sqliteTable('rulesets', {
id: text('id').primaryKey(),
name: text('name').notNull(),
surgeUrl: text('surge_url').notNull().unique(),
clashUrl: text('clash_url'),
clashBehavior: text('clash_behavior').notNull().default('classical'),
clashFormat: text('clash_format').notNull().default('yaml'),
needsConvert: integer('needs_convert', { mode: 'boolean' }).notNull().default(false),
});
export const rulesetCache = sqliteTable('ruleset_cache', {
url: text('url').primaryKey(),
content: text('content').notNull(),
etag: text('etag'),
fetchedAt: integer('fetched_at').notNull(),
});
export const subTokens = sqliteTable('sub_tokens', {
id: text('id').primaryKey(),
token: text('token').notNull().unique(),
name: text('name').notNull(),
/** 分配给该订阅的节点 idJSON 数组);空数组 = 不限制,下发全部启用节点 */
nodeIds: text('node_ids').notNull().default('[]'),
enabled: integer('enabled', { mode: 'boolean' }).notNull().default(true),
createdAt: integer('created_at').notNull(),
lastAccessAt: integer('last_access_at'),
accessCount: integer('access_count').notNull().default(0),
});
export const settings = sqliteTable('settings', {
key: text('key').primaryKey(),
value: text('value').notNull(),
});

131
server/src/db/seed.ts Normal file
View File

@@ -0,0 +1,131 @@
import fs from 'node:fs';
import path from 'node:path';
import { nanoid } from 'nanoid';
import { eq } from 'drizzle-orm';
import { env } from '../env.js';
import type { Db } from './index.js';
import { policyGroups, groupMembers, rules, rulesets, settings } from './schema.js';
import { parseSurgeConf, type ParsedGroup } from '../services/template/surge-parser.js';
import { mapRulesetUrl, rulesetNameFromUrl } from '../services/rulesets/mapping.js';
const TEMPLATE_PATH = path.resolve(env.serverRoot, 'assets/surge-template.conf');
const BUILTIN_POLICIES = new Set(['DIRECT', 'REJECT', 'REJECT-DROP', 'REJECT-NO-DROP', 'REJECT-TINYGIF']);
function seedGroups(db: Db, groups: ParsedGroup[], source: 'template' | 'custom') {
groups.forEach((g, i) => {
const groupId = nanoid(10);
db.insert(policyGroups)
.values({
id: groupId,
name: g.name,
type: g.type,
testUrl: g.testUrl ?? null,
interval: g.interval ?? null,
tolerance: g.tolerance ?? null,
filterRegex: g.filterRegex ?? null,
// AllServer 在模板中挂上游订阅policy-path在本系统中即「全部节点」组
includeAllNodes: !!(g.hasPolicyPath || g.includeAllProxies),
sortOrder: i,
source,
})
.run();
const members = [...g.members];
if (g.includeOtherGroup && !members.includes(g.includeOtherGroup)) {
members.push(g.includeOtherGroup);
}
members.forEach((m, j) => {
db.insert(groupMembers)
.values({
groupId,
memberKind: BUILTIN_POLICIES.has(m) ? 'builtin' : 'group',
nodeId: null,
refName: m,
sortOrder: j,
})
.run();
});
});
}
export function seedRulesFromTemplate(db: Db, opts: { keepCustom: boolean }) {
const text = fs.readFileSync(TEMPLATE_PATH, 'utf8');
const parsed = parseSurgeConf(text);
const custom = opts.keepCustom
? db.select().from(rules).where(eq(rules.source, 'custom')).all()
: [];
db.delete(rules).where(eq(rules.source, 'template')).run();
if (!opts.keepCustom) db.delete(rules).where(eq(rules.source, 'custom')).run();
let seq = 0;
for (const r of parsed.rules) {
let value = r.value;
if ((r.type === 'RULE-SET' || r.type === 'DOMAIN-SET') && value && /^https?:\/\//.test(value)) {
const existing = db.select().from(rulesets).where(eq(rulesets.surgeUrl, value)).get();
if (existing) {
value = existing.id;
} else {
const mapping = mapRulesetUrl(value, r.type);
const rulesetId = nanoid(10);
db.insert(rulesets)
.values({
id: rulesetId,
name: rulesetNameFromUrl(value),
surgeUrl: value,
clashUrl: mapping.clashUrl,
clashBehavior: mapping.clashBehavior,
clashFormat: mapping.clashFormat,
needsConvert: mapping.needsConvert,
})
.run();
value = rulesetId;
}
}
db.insert(rules)
.values({
id: nanoid(10),
seq: seq++,
type: r.type,
value,
policy: r.policy,
params: JSON.stringify(r.params),
enabled: true,
source: 'template',
})
.run();
}
// 自定义规则重新插回:保持原相对顺序,排在 FINAL 之前
if (custom.length > 0) {
const finalRow = db.select().from(rules).where(eq(rules.type, 'FINAL')).get();
let base = finalRow ? finalRow.seq : seq;
// 给自定义行腾出 seq 空间FINAL 及之后行整体后移
for (const c of custom.sort((a, b) => a.seq - b.seq)) {
db.insert(rules)
.values({ ...c, seq: base++ })
.run();
}
if (finalRow) db.update(rules).set({ seq: base }).where(eq(rules.id, finalRow.id)).run();
}
}
export function seedIfEmpty(db: Db) {
const hasGroups = db.select().from(policyGroups).limit(1).all().length > 0;
if (hasGroups) return;
const text = fs.readFileSync(TEMPLATE_PATH, 'utf8');
const parsed = parseSurgeConf(text);
seedGroups(db, parsed.groups, 'template');
seedRulesFromTemplate(db, { keepCustom: false });
for (const [name, content] of Object.entries(parsed.sections)) {
db.insert(settings)
.values({ key: `surge:${name}`, value: content })
.onConflictDoNothing()
.run();
}
console.log(
`seeded from template: ${parsed.groups.length} groups, ${parsed.rules.length} rules, sections: ${Object.keys(parsed.sections).join(', ')}`
);
}

11
server/src/env.ts Normal file
View File

@@ -0,0 +1,11 @@
import path from 'node:path';
import { fileURLToPath } from 'node:url';
const serverRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
export const env = {
port: Number(process.env.PORT || 3000),
dataDir: path.resolve(serverRoot, process.env.DATA_DIR || './data'),
adminToken: process.env.ADMIN_TOKEN || '',
serverRoot,
};

54
server/src/index.ts Normal file
View File

@@ -0,0 +1,54 @@
import { serve } from '@hono/node-server';
import { serveStatic } from '@hono/node-server/serve-static';
import { Hono } from 'hono';
import path from 'node:path';
import fs from 'node:fs';
import os from 'node:os';
import { env } from './env.js';
import { db } from './db/index.js';
import { seedIfEmpty } from './db/seed.js';
import { adminAuth } from './middleware/admin-auth.js';
import { nodesRoute } from './routes/nodes.js';
import { groupsRoute } from './routes/groups.js';
import { rulesRoute, rulesetsRoute } from './routes/rules.js';
import { tokensRoute } from './routes/tokens.js';
import { subRoute } from './routes/sub.js';
import { settingsRoute } from './routes/settings.js';
seedIfEmpty(db);
const app = new Hono();
app.get('/api/health', (c) => c.json({ ok: true, name: 'proxy-station' }));
app.use('/api/*', adminAuth);
app.route('/api/nodes', nodesRoute);
app.route('/api/groups', groupsRoute);
app.route('/api/rules', rulesRoute);
app.route('/api/rulesets', rulesetsRoute);
app.route('/api/tokens', tokensRoute);
app.route('/api/settings', settingsRoute);
// 公开订阅端点token 即凭证
app.route('/sub', subRoute);
// 未匹配的接口路径返回 404不落到下面的 SPA 回退(否则会拿到一页 HTML
app.all('/api/*', (c) => c.json({ error: '接口不存在' }, 404));
// 生产模式:托管 web 构建产物web/dist 相对 server 根目录)
const webDist = path.resolve(env.serverRoot, '../web/dist');
if (fs.existsSync(webDist)) {
const relRoot = path.relative(process.cwd(), webDist);
app.use('/*', serveStatic({ root: relRoot }));
app.get('*', serveStatic({ path: path.join(relRoot, 'index.html') }));
}
// 监听 0.0.0.0:局域网内的手机等设备可直接访问管理界面与订阅
serve({ fetch: app.fetch, port: env.port, hostname: '0.0.0.0' }, (info) => {
const lan = Object.values(os.networkInterfaces())
.flat()
.filter((i): i is NonNullable<typeof i> => !!i && i.family === 'IPv4' && !i.internal)
.map((i) => i.address);
console.log(`proxy-station server listening on http://localhost:${info.port}`);
for (const addr of lan) console.log(` http://${addr}:${info.port}`);
});

View File

@@ -0,0 +1,31 @@
import type { MiddlewareHandler } from 'hono';
import { env } from '../env.js';
/** 本机或 RFC1918 私有网段(局域网) */
function isLocalOrPrivate(addr: string): boolean {
const ip = addr.replace(/^::ffff:/, '');
if (!ip || ip === '127.0.0.1' || ip === '::1') return true;
if (/^10\./.test(ip)) return true;
if (/^192\.168\./.test(ip)) return true;
if (/^172\.(1[6-9]|2\d|3[01])\./.test(ip)) return true;
return false;
}
/**
* /api/* 鉴权:设置了 ADMIN_TOKEN 则要求 Bearer未设置时仅放行本机与局域网来源
*(本机/局域网开发免配置,公网部署必须设 token
*/
export const adminAuth: MiddlewareHandler = async (c, next) => {
if (env.adminToken) {
const header = c.req.header('Authorization') || '';
if (header !== `Bearer ${env.adminToken}`) {
return c.json({ error: '未授权' }, 401);
}
} else {
const addr = c.env?.incoming?.socket?.remoteAddress ?? '';
if (!isLocalOrPrivate(addr)) {
return c.json({ error: '服务未设置 ADMIN_TOKEN仅允许本机与局域网访问管理接口' }, 403);
}
}
await next();
};

107
server/src/routes/groups.ts Normal file
View File

@@ -0,0 +1,107 @@
import { Hono } from 'hono';
import { zValidator } from '@hono/zod-validator';
import { asc, eq } from 'drizzle-orm';
import { nanoid } from 'nanoid';
import { z } from 'zod';
import { groupInputSchema, type GroupDto } from '@proxy-station/shared';
import { db } from '../db/index.js';
import { groupMembers, policyGroups, rules } from '../db/schema.js';
function loadGroups(): GroupDto[] {
const groups = db.select().from(policyGroups).orderBy(asc(policyGroups.sortOrder)).all();
const members = db.select().from(groupMembers).orderBy(asc(groupMembers.sortOrder)).all();
return groups.map((g) => ({
...g,
members: members
.filter((m) => m.groupId === g.id)
.map((m) => ({ id: m.id, kind: m.memberKind, nodeId: m.nodeId, refName: m.refName, sortOrder: m.sortOrder })),
}));
}
function replaceMembers(groupId: string, members: z.output<typeof groupInputSchema>['members']) {
db.delete(groupMembers).where(eq(groupMembers.groupId, groupId)).run();
members.forEach((m, i) => {
db.insert(groupMembers)
.values({
groupId,
memberKind: m.kind,
nodeId: m.kind === 'node' ? (m.nodeId ?? null) : null,
refName: m.kind === 'node' ? null : (m.refName ?? null),
sortOrder: i,
})
.run();
});
}
export const groupsRoute = new Hono()
.get('/', (c) => c.json(loadGroups()))
.post('/', zValidator('json', groupInputSchema), (c) => {
const input = c.req.valid('json');
const id = nanoid(10);
try {
db.insert(policyGroups)
.values({
id,
name: input.name,
type: input.type,
testUrl: input.testUrl ?? null,
interval: input.interval ?? null,
tolerance: input.tolerance ?? null,
filterRegex: input.filterRegex || null,
includeAllNodes: input.includeAllNodes,
sortOrder: input.sortOrder,
source: 'custom',
})
.run();
} catch (e: any) {
if (String(e.message).includes('UNIQUE')) return c.json({ error: `策略组「${input.name}」已存在` }, 409);
throw e;
}
replaceMembers(id, input.members);
return c.json({ id }, 201);
})
.put('/reorder', zValidator('json', z.object({ ids: z.array(z.string()) })), (c) => {
const { ids } = c.req.valid('json');
ids.forEach((id, i) => db.update(policyGroups).set({ sortOrder: i }).where(eq(policyGroups.id, id)).run());
return c.json({ ok: true });
})
.patch('/:id/enabled', zValidator('json', z.object({ enabled: z.boolean() })), (c) => {
const res = db
.update(policyGroups)
.set({ enabled: c.req.valid('json').enabled })
.where(eq(policyGroups.id, c.req.param('id')))
.run();
if (res.changes === 0) return c.json({ error: '策略组不存在' }, 404);
return c.json({ ok: true });
})
.put('/:id', zValidator('json', groupInputSchema), (c) => {
const id = c.req.param('id');
const existing = db.select().from(policyGroups).where(eq(policyGroups.id, id)).get();
if (!existing) return c.json({ error: '策略组不存在' }, 404);
const input = c.req.valid('json');
const oldName = existing.name;
db.update(policyGroups)
.set({
name: input.name,
type: input.type,
testUrl: input.testUrl ?? null,
interval: input.interval ?? null,
tolerance: input.tolerance ?? null,
filterRegex: input.filterRegex || null,
includeAllNodes: input.includeAllNodes,
})
.where(eq(policyGroups.id, id))
.run();
replaceMembers(id, input.members);
// 组名变更时同步引用它的成员与规则策略
if (oldName !== input.name) {
db.update(groupMembers).set({ refName: input.name }).where(eq(groupMembers.refName, oldName)).run();
db.update(rules).set({ policy: input.name }).where(eq(rules.policy, oldName)).run();
}
return c.json({ ok: true });
})
.delete('/:id', (c) => {
const res = db.delete(policyGroups).where(eq(policyGroups.id, c.req.param('id'))).run();
if (res.changes === 0) return c.json({ error: '策略组不存在' }, 404);
return c.json({ ok: true });
});

132
server/src/routes/nodes.ts Normal file
View File

@@ -0,0 +1,132 @@
import { Hono } from 'hono';
import { zValidator } from '@hono/zod-validator';
import { asc, eq } from 'drizzle-orm';
import { nanoid } from 'nanoid';
import { z } from 'zod';
import { nodeInputSchema, type NodeDto } from '@proxy-station/shared';
import { db } from '../db/index.js';
import { nodes } from '../db/schema.js';
import { encodeShareLink, parseShareLinkBatch } from '../services/sharelink/parse.js';
type NodeRow = typeof nodes.$inferSelect;
export function rowToDto(row: NodeRow): NodeDto {
return { ...row, tags: JSON.parse(row.tags) } as unknown as NodeDto;
}
function dtoToRowPatch(input: z.output<typeof nodeInputSchema>) {
return {
name: input.name,
protocol: input.protocol,
server: input.server,
port: input.port,
network: input.network,
wsPath: input.wsPath ?? null,
wsHost: input.wsHost ?? null,
tls: input.tls,
sni: input.sni ?? null,
skipCertVerify: input.skipCertVerify,
uuid: input.uuid ?? null,
alterId: input.alterId,
security: input.security,
password: input.password ?? null,
method: input.method ?? null,
obfsType: input.obfsType ?? null,
obfsPassword: input.obfsPassword ?? null,
upMbps: input.upMbps ?? null,
downMbps: input.downMbps ?? null,
region: input.region ?? null,
tags: JSON.stringify(input.tags),
enabled: input.enabled,
sortOrder: input.sortOrder,
};
}
/** 名称冲突时自动追加 -2 / -3 … 后缀 */
function uniqueName(base: string, taken: Set<string>): string {
if (!taken.has(base)) return base;
for (let i = 2; ; i++) {
const candidate = `${base}-${i}`;
if (!taken.has(candidate)) return candidate;
}
}
export const nodesRoute = new Hono()
.get('/', (c) => {
const rows = db.select().from(nodes).orderBy(asc(nodes.sortOrder), asc(nodes.name)).all();
return c.json(rows.map(rowToDto));
})
.post('/', zValidator('json', nodeInputSchema), (c) => {
const input = c.req.valid('json');
const now = Date.now();
const row = { id: nanoid(10), ...dtoToRowPatch(input), extra: '{}', createdAt: now, updatedAt: now };
try {
db.insert(nodes).values(row).run();
} catch (e: any) {
if (String(e.message).includes('UNIQUE')) return c.json({ error: `节点名「${input.name}」已存在` }, 409);
throw e;
}
return c.json(rowToDto(row as NodeRow), 201);
})
.post(
'/import',
zValidator('json', z.object({ text: z.string().min(1), commit: z.boolean().default(false) })),
(c) => {
const { text, commit } = c.req.valid('json');
const parsed = parseShareLinkBatch(text);
const taken = new Set(db.select({ name: nodes.name }).from(nodes).all().map((r) => r.name));
const now = Date.now();
const results = parsed.map((item) => {
if (!item.node) return { ok: false as const, uri: item.uri, error: item.error };
const name = uniqueName(item.node.name, taken);
taken.add(name);
const node = { ...item.node, name };
if (commit) {
const validated = nodeInputSchema.parse(node);
const row = { id: nanoid(10), ...dtoToRowPatch(validated), extra: '{}', createdAt: now, updatedAt: now };
db.insert(nodes).values(row).run();
}
return { ok: true as const, uri: item.uri, node };
});
return c.json({
committed: commit,
total: results.length,
succeeded: results.filter((r) => r.ok).length,
items: results,
});
}
)
.get('/:id/uri', (c) => {
const row = db.select().from(nodes).where(eq(nodes.id, c.req.param('id'))).get();
if (!row) return c.json({ error: '节点不存在' }, 404);
const dto = rowToDto(row);
return c.json({ uri: encodeShareLink({ ...dto, obfsType: dto.obfsType as 'salamander' | null }) });
})
.put('/:id', zValidator('json', nodeInputSchema), (c) => {
const id = c.req.param('id');
const existing = db.select().from(nodes).where(eq(nodes.id, id)).get();
if (!existing) return c.json({ error: '节点不存在' }, 404);
const input = c.req.valid('json');
try {
db.update(nodes)
.set({ ...dtoToRowPatch(input), updatedAt: Date.now() })
.where(eq(nodes.id, id))
.run();
} catch (e: any) {
if (String(e.message).includes('UNIQUE')) return c.json({ error: `节点名「${input.name}」已存在` }, 409);
throw e;
}
return c.json(rowToDto(db.select().from(nodes).where(eq(nodes.id, id)).get()!));
})
.patch('/:id/enabled', zValidator('json', z.object({ enabled: z.boolean() })), (c) => {
const id = c.req.param('id');
const { enabled } = c.req.valid('json');
const res = db.update(nodes).set({ enabled, updatedAt: Date.now() }).where(eq(nodes.id, id)).run();
if (res.changes === 0) return c.json({ error: '节点不存在' }, 404);
return c.json({ ok: true });
})
.delete('/:id', (c) => {
const res = db.delete(nodes).where(eq(nodes.id, c.req.param('id'))).run();
if (res.changes === 0) return c.json({ error: '节点不存在' }, 404);
return c.json({ ok: true });
});

116
server/src/routes/rules.ts Normal file
View File

@@ -0,0 +1,116 @@
import { Hono } from 'hono';
import { zValidator } from '@hono/zod-validator';
import { asc, eq } from 'drizzle-orm';
import { nanoid } from 'nanoid';
import { z } from 'zod';
import { ruleInputSchema, type RuleDto } from '@proxy-station/shared';
import { db } from '../db/index.js';
import { rules, rulesets } from '../db/schema.js';
import { seedRulesFromTemplate } from '../db/seed.js';
function loadRules(): RuleDto[] {
const rows = db.select().from(rules).orderBy(asc(rules.seq)).all();
const sets = new Map(db.select().from(rulesets).all().map((r) => [r.id, r]));
return rows.map((r) => {
const rs = r.value ? sets.get(r.value) : undefined;
return {
...r,
params: JSON.parse(r.params),
rulesetName: rs?.name ?? null,
rulesetUrl: rs?.surgeUrl ?? null,
};
});
}
function nextSeq(): number {
const rows = db.select({ seq: rules.seq }).from(rules).all();
return rows.length ? Math.max(...rows.map((r) => r.seq)) + 1 : 0;
}
export const rulesRoute = new Hono()
.get('/', (c) => c.json(loadRules()))
.post('/', zValidator('json', ruleInputSchema), (c) => {
const input = c.req.valid('json');
// 新自定义规则插到 FINAL 之前
const finalRow = db.select().from(rules).where(eq(rules.type, 'FINAL')).get();
let seq: number;
if (finalRow) {
seq = finalRow.seq;
db.update(rules).set({ seq: finalRow.seq + 1 }).where(eq(rules.id, finalRow.id)).run();
} else {
seq = nextSeq();
}
const id = nanoid(10);
db.insert(rules)
.values({
id,
seq,
type: input.type,
value: input.value ?? null,
policy: input.policy,
params: JSON.stringify(input.params),
enabled: input.enabled,
source: 'custom',
})
.run();
return c.json({ id }, 201);
})
.put('/reorder', zValidator('json', z.object({ ids: z.array(z.string()) })), (c) => {
const { ids } = c.req.valid('json');
ids.forEach((id, i) => db.update(rules).set({ seq: i }).where(eq(rules.id, id)).run());
return c.json({ ok: true });
})
.post('/reset', (c) => {
seedRulesFromTemplate(db, { keepCustom: true });
return c.json({ ok: true, rules: loadRules().length });
})
.put('/:id', zValidator('json', ruleInputSchema), (c) => {
const id = c.req.param('id');
const existing = db.select().from(rules).where(eq(rules.id, id)).get();
if (!existing) return c.json({ error: '规则不存在' }, 404);
const input = c.req.valid('json');
db.update(rules)
.set({
type: input.type,
value: input.value ?? null,
policy: input.policy,
params: JSON.stringify(input.params),
enabled: input.enabled,
})
.where(eq(rules.id, id))
.run();
return c.json({ ok: true });
})
.patch('/:id/enabled', zValidator('json', z.object({ enabled: z.boolean() })), (c) => {
const res = db
.update(rules)
.set({ enabled: c.req.valid('json').enabled })
.where(eq(rules.id, c.req.param('id')))
.run();
if (res.changes === 0) return c.json({ error: '规则不存在' }, 404);
return c.json({ ok: true });
})
.delete('/:id', (c) => {
const res = db.delete(rules).where(eq(rules.id, c.req.param('id'))).run();
if (res.changes === 0) return c.json({ error: '规则不存在' }, 404);
return c.json({ ok: true });
});
export const rulesetsRoute = new Hono()
.get('/', (c) => {
const rows = db.select().from(rulesets).all();
return c.json(rows);
})
.get('/:id/content', async (c) => {
const rs = db.select().from(rulesets).where(eq(rulesets.id, c.req.param('id'))).get();
if (!rs) return c.json({ error: '规则集不存在' }, 404);
const refresh = c.req.query('refresh') === '1';
try {
const { fetchRulesetContent } = await import('../services/rulesets/fetch.js');
const { content, fetchedAt, stale } = await fetchRulesetContent(rs.surgeUrl, { refresh });
const lineCount = content.split(/\r?\n/).filter((l) => l.trim() && !l.trim().startsWith('#')).length;
return c.json({ content, fetchedAt, stale, lineCount });
} catch (e: any) {
return c.json({ error: `拉取失败:${e.message}` }, 502);
}
});

View File

@@ -0,0 +1,22 @@
import { Hono } from 'hono';
import { zValidator } from '@hono/zod-validator';
import { z } from 'zod';
import { getSetting, setSetting } from '../services/ir.js';
const SURGE_SECTION_KEYS = ['General', 'Host', 'URL Rewrite', 'Header Rewrite', 'MITM', 'Script'];
export const settingsRoute = new Hono()
.get('/', (c) => {
const surgeSections: Record<string, string> = {};
for (const key of SURGE_SECTION_KEYS) surgeSections[key] = getSetting(`surge:${key}`);
return c.json({ surgeSections });
})
.put('/', zValidator('json', z.object({ surgeSections: z.record(z.string()).optional() })), (c) => {
const input = c.req.valid('json');
if (input.surgeSections) {
for (const [key, value] of Object.entries(input.surgeSections)) {
if (SURGE_SECTION_KEYS.includes(key)) setSetting(`surge:${key}`, value);
}
}
return c.json({ ok: true });
});

104
server/src/routes/sub.ts Normal file
View File

@@ -0,0 +1,104 @@
import { Hono } from 'hono';
import { eq } from 'drizzle-orm';
import crypto from 'node:crypto';
import { db } from '../db/index.js';
import { rulesets, subTokens } from '../db/schema.js';
import { buildProfileIR } from '../services/ir.js';
import { fetchRulesetContent } from '../services/rulesets/fetch.js';
import { convertSurgeList } from '../services/rulesets/convert.js';
import { generateSurge } from '../services/generators/surge.js';
import { generateShadowrocket } from '../services/generators/shadowrocket.js';
import { generateShadowrocketConf } from '../services/generators/shadowrocket-conf.js';
import { SHADOWROCKET_SUB_NAME } from '@proxy-station/shared';
import { generateClash } from '../services/generators/clash.js';
function constantTimeEqual(a: string, b: string): boolean {
const ha = crypto.createHash('sha256').update(a).digest();
const hb = crypto.createHash('sha256').update(b).digest();
return crypto.timingSafeEqual(ha, hb);
}
export function findToken(token: string) {
const rows = db.select().from(subTokens).where(eq(subTokens.enabled, true)).all();
return rows.find((r) => constantTimeEqual(r.token, token)) ?? null;
}
/** 该订阅可见的节点范围 */
function irFor(row: { nodeIds: string }) {
return buildProfileIR({ nodeIds: JSON.parse(row.nodeIds) });
}
function touchToken(id: string, count: number) {
db.update(subTokens)
.set({ lastAccessAt: Date.now(), accessCount: count + 1 })
.where(eq(subTokens.id, id))
.run();
}
/** 订阅 URL 基址:直接取本次请求的 origin——客户端能请求到这里origin 就一定可达 */
function baseUrl(c: { req: { url: string } }): string {
return new URL(c.req.url).origin;
}
export const subRoute = new Hono()
.get('/:token/surge', (c) => {
const row = findToken(c.req.param('token'));
if (!row) return c.text('not found', 404);
touchToken(row.id, row.accessCount);
const ir = irFor(row);
const selfUrl = `${baseUrl(c)}/sub/${row.token}/surge`;
const { content } = generateSurge(ir, { selfUrl });
c.header('content-type', 'text/plain; charset=utf-8');
c.header('content-disposition', 'attachment; filename="Proxy Station.conf"; filename*=UTF-8\'\'Proxy%20Station.conf');
return c.body(content);
})
.get('/:token/shadowrocket', (c) => {
const row = findToken(c.req.param('token'));
if (!row) return c.text('not found', 404);
touchToken(row.id, row.accessCount);
const { content } = generateShadowrocket(irFor(row));
c.header('content-type', 'text/plain; charset=utf-8');
return c.body(content);
})
// ShadowRocket 的策略组与规则(节点走上面的节点订阅端点)
.get('/:token/shadowrocket-conf', (c) => {
const row = findToken(c.req.param('token'));
if (!row) return c.text('not found', 404);
touchToken(row.id, row.accessCount);
const { content } = generateShadowrocketConf(irFor(row), {
subscriptionName: SHADOWROCKET_SUB_NAME,
});
c.header('content-type', 'text/plain; charset=utf-8');
c.header('content-disposition', 'attachment; filename="Proxy Station Rules.conf"; filename*=UTF-8\'\'Proxy%20Station%20Rules.conf');
return c.body(content);
})
.get('/:token/clash', (c) => {
const row = findToken(c.req.param('token'));
if (!row) return c.text('not found', 404);
touchToken(row.id, row.accessCount);
const ir = irFor(row);
const convertBaseUrl = `${baseUrl(c)}/sub/${row.token}`;
const { content } = generateClash(ir, { convertBaseUrl });
c.header('content-type', 'text/yaml; charset=utf-8');
c.header('content-disposition', 'attachment; filename="Proxy Station.yaml"; filename*=UTF-8\'\'Proxy%20Station.yaml');
c.header('profile-update-interval', '24');
return c.body(content);
})
// Clash 兜底转换端点:无 Clash 等价 URL 的规则集,由本服务拉取 Surge 版并转换
.get('/:token/ruleset/:file', async (c) => {
const row = findToken(c.req.param('token'));
if (!row) return c.text('not found', 404);
const id = c.req.param('file').replace(/\.yaml$/, '');
const rs = db.select().from(rulesets).where(eq(rulesets.id, id)).get();
if (!rs) return c.text('not found', 404);
try {
const { content, stale } = await fetchRulesetContent(rs.surgeUrl);
const result = convertSurgeList(content, rs.clashBehavior as 'classical' | 'domain' | 'ipcidr');
c.header('content-type', 'text/yaml; charset=utf-8');
c.header('x-proxy-station-converted', `${result.converted}/${result.total}`);
if (stale) c.header('x-proxy-station-stale', '1');
return c.body(result.yaml);
} catch (e: any) {
return c.text(`upstream fetch failed: ${e.message}`, 502);
}
});

View File

@@ -0,0 +1,78 @@
import { Hono } from 'hono';
import { zValidator } from '@hono/zod-validator';
import { asc, eq } from 'drizzle-orm';
import crypto from 'node:crypto';
import { nanoid } from 'nanoid';
import { z } from 'zod';
import { CLIENTS, type TokenDto } from '@proxy-station/shared';
import { db } from '../db/index.js';
import { subTokens } from '../db/schema.js';
/** 只返回路径,前端用当前页面的 origin 拼完整 URL */
function tokenUrls(token: string): TokenDto['urls'] {
return {
...(Object.fromEntries(CLIENTS.map((c) => [c, `/sub/${token}/${c}`])) as Record<
(typeof CLIENTS)[number],
string
>),
shadowrocketConf: `/sub/${token}/shadowrocket-conf`,
};
}
type TokenRow = typeof subTokens.$inferSelect;
function toDto(row: TokenRow): TokenDto {
return { ...row, nodeIds: JSON.parse(row.nodeIds), urls: tokenUrls(row.token) };
}
const tokenInput = z.object({
name: z.string().min(1).max(64),
/** 空数组 = 不限制,下发全部启用节点 */
nodeIds: z.array(z.string()).default([]),
});
export const tokensRoute = new Hono()
.get('/', (c) => {
const rows = db.select().from(subTokens).orderBy(asc(subTokens.createdAt)).all();
return c.json(rows.map(toDto));
})
.post('/', zValidator('json', tokenInput), (c) => {
const { name, nodeIds } = c.req.valid('json');
const row: TokenRow = {
id: nanoid(10),
token: crypto.randomBytes(16).toString('hex'),
name,
nodeIds: JSON.stringify(nodeIds),
enabled: true,
createdAt: Date.now(),
lastAccessAt: null,
accessCount: 0,
};
db.insert(subTokens).values(row).run();
return c.json(toDto(row), 201);
})
.put('/:id', zValidator('json', tokenInput), (c) => {
const id = c.req.param('id');
const { name, nodeIds } = c.req.valid('json');
const res = db
.update(subTokens)
.set({ name, nodeIds: JSON.stringify(nodeIds) })
.where(eq(subTokens.id, id))
.run();
if (res.changes === 0) return c.json({ error: '订阅不存在' }, 404);
return c.json(toDto(db.select().from(subTokens).where(eq(subTokens.id, id)).get()!));
})
.patch('/:id/enabled', zValidator('json', z.object({ enabled: z.boolean() })), (c) => {
const res = db
.update(subTokens)
.set({ enabled: c.req.valid('json').enabled })
.where(eq(subTokens.id, c.req.param('id')))
.run();
if (res.changes === 0) return c.json({ error: '订阅不存在' }, 404);
return c.json({ ok: true });
})
.delete('/:id', (c) => {
const res = db.delete(subTokens).where(eq(subTokens.id, c.req.param('id'))).run();
if (res.changes === 0) return c.json({ error: '订阅不存在' }, 404);
return c.json({ ok: true });
});

View File

@@ -0,0 +1,192 @@
import YAML from 'yaml';
import { clientSupports, normalizeSsCipher, type ExcludedNode, type NodeDto } from '@proxy-station/shared';
import type { ProfileIR, RuleIR } from '../ir.js';
export function clashProxy(n: NodeDto): Record<string, unknown> {
const base: Record<string, unknown> = { name: n.name, server: n.server, port: n.port };
switch (n.protocol) {
case 'vmess': {
Object.assign(base, { type: 'vmess', uuid: n.uuid, alterId: n.alterId, cipher: n.security || 'auto' });
if (n.tls) {
base.tls = true;
if (n.sni) base.servername = n.sni;
}
if (n.network === 'ws') {
base.network = 'ws';
base['ws-opts'] = {
path: n.wsPath,
...(n.wsHost ? { headers: { Host: n.wsHost } } : {}),
};
}
break;
}
case 'trojan': {
Object.assign(base, { type: 'trojan', password: n.password, sni: n.sni || n.server });
if (n.network === 'ws') {
base.network = 'ws';
base['ws-opts'] = {
path: n.wsPath,
...(n.wsHost ? { headers: { Host: n.wsHost } } : {}),
};
}
if (n.skipCertVerify) base['skip-cert-verify'] = true;
break;
}
case 'shadowsocks': {
Object.assign(base, { type: 'ss', cipher: normalizeSsCipher(n.method || ''), password: n.password });
if (n.network === 'ws') {
// SS over WS+TLS 在 Clash 侧唯一可行方案是 v2ray-plugin
base.plugin = 'v2ray-plugin';
base['plugin-opts'] = {
mode: 'websocket',
tls: n.tls,
host: n.wsHost || n.sni || n.server,
path: n.wsPath,
};
}
break;
}
case 'hysteria2': {
Object.assign(base, { type: 'hysteria2', password: n.password });
if (n.sni) base.sni = n.sni;
if (n.obfsType === 'salamander' && n.obfsPassword) {
base.obfs = 'salamander';
base['obfs-password'] = n.obfsPassword;
}
if (n.upMbps) base.up = `${n.upMbps} Mbps`;
if (n.downMbps) base.down = `${n.downMbps} Mbps`;
if (n.skipCertVerify) base['skip-cert-verify'] = true;
break;
}
}
return base;
}
/** Surge 独有策略 → mihomo 等价策略 */
function mapPolicy(policy: string): string {
if (policy === 'REJECT-NO-DROP' || policy === 'REJECT-TINYGIF') return 'REJECT';
return policy;
}
/** Surge 逻辑规则里的子类型 → mihomo 命名 */
function mapLogicValue(value: string): string {
return value.replace(/\bPROTOCOL\b/g, 'NETWORK');
}
const CLASH_UNSUPPORTED_RULE_TYPES = new Set(['URL-REGEX', 'USER-AGENT']);
export interface ClashOutput {
content: string;
excluded: ExcludedNode[];
skippedRules: string[];
}
export function generateClash(ir: ProfileIR, opts: { convertBaseUrl: string }): ClashOutput {
const excluded: ExcludedNode[] = [];
const usable = ir.nodes.filter((n) => {
const verdict = clientSupports('clash', n);
if (!verdict.ok) excluded.push({ name: n.name, reason: verdict.reason! });
return verdict.ok;
});
const usableNames = new Set(usable.map((n) => n.name));
const proxies = usable.map(clashProxy);
const proxyGroups = ir.groups.map((g) => {
const group: Record<string, unknown> = { name: g.name, type: g.type };
const members = g.members
.filter((m) => m.kind !== 'node' || usableNames.has(m.name))
.map((m) => m.name);
if (g.filterRegex) {
group['include-all-proxies'] = true;
group.filter = g.filterRegex;
} else if (g.includeAllNodes) {
group['include-all-proxies'] = true;
const extra = members.filter((m) => !usableNames.has(m));
if (extra.length) group.proxies = extra;
} else {
group.proxies = members.length ? members : ['DIRECT'];
}
if (g.type !== 'select') {
group.url = g.testUrl || 'http://cp.cloudflare.com/generate_204';
group.interval = g.interval ?? 300;
if (g.tolerance) group.tolerance = g.tolerance;
}
return group;
});
// rule-providers从启用规则引用的规则集生成名称唯一化
const providerNameByRulesetId = new Map<string, string>();
const providers: Record<string, unknown> = {};
const takenNames = new Set<string>();
const usedRulesets = ir.rules.flatMap((r) => (r.ruleset ? [r.ruleset] : []));
for (const rs of usedRulesets) {
if (providerNameByRulesetId.has(rs.id)) continue;
let name = rs.name;
for (let i = 2; takenNames.has(name); i++) name = `${rs.name}-${i}`;
takenNames.add(name);
providerNameByRulesetId.set(rs.id, name);
const url = rs.needsConvert || !rs.clashUrl ? `${opts.convertBaseUrl}/ruleset/${rs.id}.yaml` : rs.clashUrl;
providers[name] = {
type: 'http',
url,
behavior: rs.clashBehavior,
format: rs.needsConvert || !rs.clashUrl ? 'yaml' : rs.clashFormat === 'yaml' ? 'yaml' : 'text',
interval: 86400,
};
}
const skippedRules: string[] = [];
const ruleLines: string[] = [];
for (const r of ir.rules) {
if (r.type === 'FINAL') {
ruleLines.push(`MATCH,${mapPolicy(r.policy)}`);
continue;
}
if (CLASH_UNSUPPORTED_RULE_TYPES.has(r.type)) {
skippedRules.push(`${r.type},${r.value},${r.policy}`);
continue;
}
const policy = mapPolicy(r.policy);
if (r.ruleset) {
ruleLines.push(`RULE-SET,${providerNameByRulesetId.get(r.ruleset.id)},${policy}`);
continue;
}
// Surge 内置规则集(非 URLLAN → 私网 GEOIPSYSTEM 无对应物,跳过
if (r.type === 'RULE-SET' || r.type === 'DOMAIN-SET') {
if (r.value === 'LAN') {
ruleLines.push(`GEOIP,private,${policy},no-resolve`);
} else {
skippedRules.push(`${r.type},${r.value},${r.policy}`);
}
continue;
}
if (r.type === 'AND' || r.type === 'OR' || r.type === 'NOT') {
ruleLines.push(`${r.type},${mapLogicValue(r.value || '')},${policy}`);
continue;
}
const params = r.params.filter((p) => p === 'no-resolve');
ruleLines.push([r.type, r.value, policy, ...params].join(','));
}
const doc = {
'mixed-port': 7890,
'allow-lan': false,
mode: 'rule',
'log-level': 'info',
'unified-delay': true,
ipv6: false,
dns: {
enable: true,
listen: '0.0.0.0:1053',
'enhanced-mode': 'fake-ip',
nameserver: ['https://doh.pub/dns-query', 'https://dns.alidns.com/dns-query'],
},
proxies,
'proxy-groups': proxyGroups,
'rule-providers': providers,
rules: ruleLines,
};
return { content: YAML.stringify(doc, { lineWidth: 0 }), excluded, skippedRules };
}

View File

@@ -0,0 +1,110 @@
import type { ProfileIR } from '../ir.js';
/** 成员名含空格/逗号时加引号 */
function quoteName(name: string): string {
return /[\s,]/.test(name) ? `"${name}"` : name;
}
/**
* ShadowRocket 的 [General] 只保留它认识的通用键——模板里的 Surge 专有键
* all-hybrid / udp-priority / http-api / compatibility-mode 等)会被过滤掉。
*/
const SR_GENERAL_KEYS = new Set([
'bypass-system',
'skip-proxy',
'bypass-tun',
'dns-server',
'fallback-dns-server',
'ipv6',
'prefer-ipv6',
'dns-direct-system',
'icmp-auto-reply',
'always-real-ip',
'hijack-dns',
'udp-policy-not-supported-behaviour',
'interface-mode',
]);
function shadowrocketGeneral(surgeGeneral: string): string {
const lines: string[] = [];
for (const raw of surgeGeneral.split(/\r?\n/)) {
const line = raw.trim();
if (!line || line.startsWith('#') || line.startsWith('//')) continue;
const key = line.split('=')[0].trim();
if (SR_GENERAL_KEYS.has(key)) lines.push(line);
}
// ShadowRocket 的常用默认值,模板里没有就补上
if (!lines.some((l) => l.startsWith('bypass-system'))) lines.push('bypass-system = true');
if (!lines.some((l) => l.startsWith('ipv6'))) lines.push('ipv6 = false');
if (!lines.some((l) => l.startsWith('dns-server'))) lines.push('dns-server = 223.5.5.5, 119.29.29.29');
return lines.join('\n');
}
/** ShadowRocket 不认识的规则类型 */
const SR_UNSUPPORTED_RULE_TYPES = new Set(['DOMAIN-SET', 'AND', 'OR', 'NOT', 'URL-REGEX']);
export interface ShadowrocketConfOutput {
content: string;
skippedRules: string[];
}
/**
* 生成 ShadowRocket 配置文件:策略组 + 规则,不含节点。
* 节点由「节点订阅」单独导入,策略组通过 `use=true` 引用该订阅的名称,
* 因此用户在 App 里给订阅起的名字必须与 subscriptionName 一致。
*/
export function generateShadowrocketConf(
ir: ProfileIR,
opts: { subscriptionName: string }
): ShadowrocketConfOutput {
const sub = quoteName(opts.subscriptionName);
const lines: string[] = [];
lines.push('# 由 Proxy Station 生成的 ShadowRocket 配置(策略组 + 规则)');
lines.push(`# 节点请另行导入「节点订阅」,并在 App 中将其命名为:${opts.subscriptionName}`);
lines.push('');
lines.push('[General]');
lines.push(shadowrocketGeneral(ir.sections['General'] ?? ''));
lines.push('', '[Proxy Group]');
for (const g of ir.groups) {
const parts: string[] = [g.type];
if (g.filterRegex) {
// 地区组:引用订阅 + 正则筛选ShadowRocket 原生支持 policy-regex-filter
parts.push(sub, 'use=true', `policy-regex-filter=${g.filterRegex}`);
} else if (g.includeAllNodes) {
// 收纳全部节点:引用订阅
parts.push(sub, 'use=true');
} else {
const members = g.members.map((m) => quoteName(m.name));
parts.push(...(members.length ? members : ['DIRECT']));
}
if (g.type !== 'select') {
parts.push(`url=${g.testUrl || 'http://cp.cloudflare.com/generate_204'}`);
if (g.interval) parts.push(`interval=${g.interval}`);
if (g.tolerance) parts.push(`tolerance=${g.tolerance}`);
}
lines.push(`${g.name} = ${parts.join(', ')}`);
}
const skippedRules: string[] = [];
lines.push('', '[Rule]');
for (const r of ir.rules) {
if (r.type === 'FINAL') {
lines.push(['FINAL', quoteName(r.policy)].join(','));
continue;
}
if (SR_UNSUPPORTED_RULE_TYPES.has(r.type)) {
skippedRules.push(`${r.type},${r.ruleset ? r.ruleset.name : r.value},${r.policy}`);
continue;
}
const value = r.ruleset ? r.ruleset.surgeUrl : r.value;
lines.push([r.type, value, quoteName(r.policy), ...r.params].join(','));
}
for (const section of ['Host', 'URL Rewrite', 'MITM']) {
if (ir.sections[section]) lines.push('', `[${section}]`, ir.sections[section]);
}
return { content: lines.join('\n') + '\n', skippedRules };
}

View File

@@ -0,0 +1,27 @@
import { clientSupports, type ExcludedNode } from '@proxy-station/shared';
import type { ProfileIR } from '../ir.js';
import { encodeShareLink } from '../sharelink/parse.js';
export interface ShadowrocketOutput {
content: string; // base64 后的 URI 列表ShadowRocket 原生订阅格式)
excluded: ExcludedNode[];
uris: string[];
}
export function generateShadowrocket(ir: ProfileIR): ShadowrocketOutput {
const excluded: ExcludedNode[] = [];
const uris: string[] = [];
for (const n of ir.nodes) {
const verdict = clientSupports('shadowrocket', n);
if (!verdict.ok) {
excluded.push({ name: n.name, reason: verdict.reason! });
continue;
}
uris.push(encodeShareLink({ ...n, obfsType: n.obfsType as 'salamander' | null }));
}
return {
content: Buffer.from(uris.join('\n'), 'utf8').toString('base64'),
excluded,
uris,
};
}

View File

@@ -0,0 +1,124 @@
import { clientSupports, normalizeSsCipher, type ExcludedNode, type NodeDto } from '@proxy-station/shared';
import type { ProfileIR } from '../ir.js';
/** 成员名含空格/逗号时按 Surge 习惯加引号 */
function quoteName(name: string): string {
return /[\s,]/.test(name) ? `"${name}"` : name;
}
export function surgeNodeLine(n: NodeDto): string {
const parts: string[] = [];
switch (n.protocol) {
case 'vmess': {
parts.push('vmess', n.server, String(n.port), `username=${n.uuid}`);
if (n.network === 'ws') {
parts.push('ws=true', `ws-path=${n.wsPath}`);
if (n.wsHost) parts.push(`ws-headers=Host:"${n.wsHost}"`);
}
if (n.tls) {
parts.push('tls=true');
if (n.sni) parts.push(`sni=${n.sni}`);
}
// alterId=0 的 AEAD 头必须显式打开,否则 Surge 连不上且症状隐晦
parts.push('vmess-aead=true');
break;
}
case 'trojan': {
parts.push('trojan', n.server, String(n.port), `password=${n.password}`);
if (n.network === 'ws') {
parts.push('ws=true', `ws-path=${n.wsPath}`);
if (n.wsHost) parts.push(`ws-headers=Host:"${n.wsHost}"`);
}
if (n.sni) parts.push(`sni=${n.sni}`);
if (n.skipCertVerify) parts.push('skip-cert-verify=true');
break;
}
case 'shadowsocks': {
parts.push('ss', n.server, String(n.port), `encrypt-method=${normalizeSsCipher(n.method || '')}`, `password=${n.password}`);
break;
}
case 'hysteria2': {
parts.push('hysteria2', n.server, String(n.port), `password=${n.password}`);
if (n.sni) parts.push(`sni=${n.sni}`);
// Surge 的 salamander 混淆参数名sub-router 生产验证过)
if (n.obfsType === 'salamander' && n.obfsPassword) parts.push(`salamander-password=${n.obfsPassword}`);
if (n.downMbps) parts.push(`download-bandwidth=${n.downMbps}`);
if (n.skipCertVerify) parts.push('skip-cert-verify=true');
break;
}
}
return `${n.name} = ${parts.join(', ')}`;
}
export interface SurgeOutput {
content: string;
excluded: ExcludedNode[];
}
export function generateSurge(ir: ProfileIR, opts: { selfUrl: string }): SurgeOutput {
const excluded: ExcludedNode[] = [];
const usable = ir.nodes.filter((n) => {
const verdict = clientSupports('surge', n);
if (!verdict.ok) excluded.push({ name: n.name, reason: verdict.reason! });
return verdict.ok;
});
const usableNames = new Set(usable.map((n) => n.name));
const lines: string[] = [];
lines.push(`#!MANAGED-CONFIG ${opts.selfUrl} interval=86400 strict=true`);
lines.push('# 由 Proxy Station 生成,请勿手动编辑(改动会在下次更新时被覆盖)');
lines.push('');
lines.push('[General]');
lines.push(ir.sections['General'] ?? '');
lines.push('', '[Proxy]');
for (const n of usable) lines.push(surgeNodeLine(n));
lines.push('', '[Proxy Group]');
for (const g of ir.groups) {
const parts: string[] = [g.type];
const memberNames = g.members
.filter((m) => m.kind !== 'node' || usableNames.has(m.name))
.map((m) => quoteName(m.name));
if (g.filterRegex) {
// 按名称正则动态筛选:节点来源可以是全部节点,也可以是另一个组
if (g.includeAllNodes) {
parts.push('include-all-proxies=true');
} else {
const source = g.members.find((m) => m.kind === 'group');
if (source) parts.push(`include-other-group=${quoteName(source.name)}`);
}
parts.push(`policy-regex-filter=${g.filterRegex}`);
} else if (g.includeAllNodes) {
// 「全部节点」组:显式展开当前启用且 Surge 支持的节点
parts.push(...usable.map((n) => quoteName(n.name)), ...memberNames.filter((m) => !usableNames.has(m)));
if (usable.length === 0) parts.push('DIRECT');
} else {
parts.push(...(memberNames.length ? memberNames : ['DIRECT']));
}
if (g.type !== 'select') {
parts.push(`url=${g.testUrl || 'http://cp.cloudflare.com/generate_204'}`);
if (g.interval) parts.push(`interval=${g.interval}`);
if (g.tolerance) parts.push(`tolerance=${g.tolerance}`);
}
lines.push(`${g.name} = ${parts.join(', ')}`);
}
lines.push('', '[Rule]');
for (const r of ir.rules) {
if (r.type === 'FINAL') {
lines.push(['FINAL', quoteName(r.policy), ...r.params].join(','));
continue;
}
const value = r.ruleset ? r.ruleset.surgeUrl : r.value;
lines.push([r.type, value, quoteName(r.policy), ...r.params].join(','));
}
for (const section of ['Host', 'URL Rewrite', 'Header Rewrite', 'MITM', 'Script']) {
if (ir.sections[section]) {
lines.push('', `[${section}]`, ir.sections[section]);
}
}
return { content: lines.join('\n') + '\n', excluded };
}

131
server/src/services/ir.ts Normal file
View File

@@ -0,0 +1,131 @@
import { asc, eq } from 'drizzle-orm';
import { db } from '../db/index.js';
import { groupMembers, nodes, policyGroups, rules, rulesets, settings } from '../db/schema.js';
import type { NodeDto } from '@proxy-station/shared';
import { rowToDto } from '../routes/nodes.js';
export interface GroupIR {
name: string;
type: 'select' | 'url-test' | 'fallback';
testUrl: string | null;
interval: number | null;
tolerance: number | null;
filterRegex: string | null;
includeAllNodes: boolean;
/** 有序成员:节点名 / 组名 / DIRECT 等内置策略 */
members: { kind: 'node' | 'group' | 'builtin'; name: string }[];
}
export interface RuleIR {
type: string;
value: string | null;
policy: string;
params: string[];
ruleset: {
id: string;
name: string;
surgeUrl: string;
clashUrl: string | null;
clashBehavior: string;
clashFormat: string;
needsConvert: boolean;
} | null;
}
export interface ProfileIR {
nodes: NodeDto[]; // 仅启用节点,按 sortOrder
groups: GroupIR[];
rules: RuleIR[]; // 仅启用规则,按 seq
sections: Record<string, string>; // Surge 原文段落General/Host/…)
}
export function getSetting(key: string): string {
const row = db.select().from(settings).where(eq(settings.key, key)).get();
return row?.value ?? '';
}
export function setSetting(key: string, value: string) {
db.insert(settings)
.values({ key, value })
.onConflictDoUpdate({ target: settings.key, set: { value } })
.run();
}
/**
* @param opts.nodeIds 订阅分配的节点范围;为空或未提供时下发全部启用节点
*/
export function buildProfileIR(opts: { nodeIds?: string[] } = {}): ProfileIR {
const allowed = opts.nodeIds && opts.nodeIds.length > 0 ? new Set(opts.nodeIds) : null;
const nodeRows = db
.select()
.from(nodes)
.where(eq(nodes.enabled, true))
.orderBy(asc(nodes.sortOrder), asc(nodes.name))
.all()
.map(rowToDto)
.filter((n) => !allowed || allowed.has(n.id));
const nodeById = new Map(nodeRows.map((n) => [n.id, n]));
const memberRows = db.select().from(groupMembers).orderBy(asc(groupMembers.sortOrder)).all();
const allGroupRows = db.select().from(policyGroups).orderBy(asc(policyGroups.sortOrder)).all();
// 停用的组从输出中剔除;引用它的成员与规则一并跳过,保证产物有效
const groupRows = allGroupRows.filter((g) => g.enabled);
const liveNames = new Set(groupRows.map((g) => g.name));
const BUILTIN_POLICIES = new Set(['DIRECT', 'REJECT', 'REJECT-DROP', 'REJECT-NO-DROP', 'REJECT-TINYGIF']);
/** 组已被删除或停用时,引用它的成员/规则应当跳过 */
const isDeadRef = (name: string) => !liveNames.has(name) && !BUILTIN_POLICIES.has(name);
const groups: GroupIR[] = groupRows.map((g) => ({
name: g.name,
type: g.type,
testUrl: g.testUrl,
interval: g.interval,
tolerance: g.tolerance,
filterRegex: g.filterRegex,
includeAllNodes: g.includeAllNodes,
members: memberRows
.filter((m) => m.groupId === g.id)
.flatMap((m): GroupIR['members'] => {
if (m.memberKind === 'node') {
const node = m.nodeId ? nodeById.get(m.nodeId) : undefined;
return node ? [{ kind: 'node', name: node.name }] : []; // 被禁用/删除的节点成员跳过
}
if (!m.refName) return [];
if (m.memberKind === 'group' && isDeadRef(m.refName)) return [];
return [{ kind: m.memberKind, name: m.refName }];
}),
}));
const setRows = new Map(db.select().from(rulesets).all().map((r) => [r.id, r]));
const ruleRows = db
.select()
.from(rules)
.where(eq(rules.enabled, true))
.orderBy(asc(rules.seq))
.all()
.filter((r) => r.type === 'FINAL' || !isDeadRef(r.policy))
// FINAL 必须保留:其策略组被停用或删除时兜底 DIRECT
.map((r) => (r.type === 'FINAL' && isDeadRef(r.policy) ? { ...r, policy: 'DIRECT' } : r));
const ruleIRs: RuleIR[] = ruleRows.map((r) => {
const rs = r.value ? setRows.get(r.value) : undefined;
return {
type: r.type,
value: r.value,
policy: r.policy,
params: JSON.parse(r.params),
ruleset: rs ?? null,
};
});
const sections: Record<string, string> = {};
for (const key of ['General', 'Host', 'URL Rewrite', 'Header Rewrite', 'MITM', 'Script']) {
const v = getSetting(`surge:${key}`);
if (v) sections[key] = v;
}
return {
nodes: nodeRows,
groups,
rules: ruleIRs,
sections,
};
}

View File

@@ -0,0 +1,29 @@
import { describe, expect, it } from 'vitest';
import YAML from 'yaml';
import { convertSurgeList } from './convert.js';
describe('convertSurgeList', () => {
it('classical保留支持类型与 no-resolve丢弃 USER-AGENT', () => {
const input = [
'# 注释',
'DOMAIN,example.com',
'DOMAIN-SUFFIX,example.org',
'IP-CIDR,10.0.0.0/8,no-resolve',
'USER-AGENT,Foo*',
'URL-REGEX,^http://bad',
].join('\n');
const result = convertSurgeList(input, 'classical');
expect(YAML.parse(result.yaml).payload).toEqual([
'DOMAIN,example.com',
'DOMAIN-SUFFIX,example.org',
'IP-CIDR,10.0.0.0/8,no-resolve',
]);
expect(result.dropped).toHaveLength(2);
expect(result.total).toBe(5);
});
it('domaindomainset前导点转 +.', () => {
const result = convertSurgeList('example.com\n.cdn.example.com', 'domain');
expect(YAML.parse(result.yaml).payload).toEqual(['example.com', '+.cdn.example.com']);
});
});

View File

@@ -0,0 +1,65 @@
import YAML from 'yaml';
/** mihomo classical provider 支持的规则类型 */
const CLASSICAL_TYPES = new Set([
'DOMAIN',
'DOMAIN-SUFFIX',
'DOMAIN-KEYWORD',
'DOMAIN-REGEX',
'IP-CIDR',
'IP-CIDR6',
'IP-ASN',
'GEOIP',
'PROCESS-NAME',
'PROCESS-PATH',
'DST-PORT',
'SRC-PORT',
]);
export interface ConvertResult {
yaml: string;
total: number;
converted: number;
dropped: string[]; // 被丢弃的行Clash 不支持的类型)
}
/**
* Surge .list/.conf 规则集 → Clash rule-provider yaml。
* behavior=domain 时按 domainset 处理(每行一个域名,.former 前缀转 +.)。
*/
export function convertSurgeList(content: string, behavior: 'classical' | 'domain' | 'ipcidr'): ConvertResult {
const lines = content
.split(/\r?\n/)
.map((l) => l.trim())
.filter((l) => l && !l.startsWith('#') && !l.startsWith('//') && !l.startsWith(';'));
const payload: string[] = [];
const dropped: string[] = [];
for (const line of lines) {
if (behavior === 'domain') {
// Surge domainset`example.com` 或 `.example.com`(含子域)→ Clash `example.com` / `+.example.com`
payload.push(line.startsWith('.') ? `+${line}` : line);
continue;
}
if (behavior === 'ipcidr') {
payload.push(line);
continue;
}
const parts = line.split(',').map((p) => p.trim());
const type = parts[0];
if (!CLASSICAL_TYPES.has(type)) {
dropped.push(line);
continue;
}
const params = parts.slice(2).filter((p) => p === 'no-resolve');
payload.push([type, parts[1], ...params].join(','));
}
return {
yaml: YAML.stringify({ payload }, { lineWidth: 0 }),
total: lines.length,
converted: payload.length,
dropped,
};
}

View File

@@ -0,0 +1,48 @@
import { eq } from 'drizzle-orm';
import { Agent, fetch as undiciFetch } from 'undici';
import { db } from '../../db/index.js';
import { rulesetCache } from '../../db/schema.js';
const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
// 规则集拉取一律直连(显式 Agent隔离环境注入的 HTTPS_PROXY
function dispatcher() {
return new Agent();
}
export interface FetchResult {
content: string;
fetchedAt: number;
stale: boolean; // 拉取失败时回落陈旧缓存
}
export async function fetchRulesetContent(url: string, opts: { refresh?: boolean } = {}): Promise<FetchResult> {
const cached = db.select().from(rulesetCache).where(eq(rulesetCache.url, url)).get();
const fresh = cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS;
if (cached && fresh && !opts.refresh) {
return { content: cached.content, fetchedAt: cached.fetchedAt, stale: false };
}
try {
const headers: Record<string, string> = { 'user-agent': 'proxy-station/0.1' };
if (cached?.etag) headers['if-none-match'] = cached.etag;
const res = await undiciFetch(url, { dispatcher: dispatcher(), headers });
if (res.status === 304 && cached) {
const fetchedAt = Date.now();
db.update(rulesetCache).set({ fetchedAt }).where(eq(rulesetCache.url, url)).run();
return { content: cached.content, fetchedAt, stale: false };
}
if (res.status !== 200) throw new Error(`HTTP ${res.status}`);
const content = await res.text();
const etag = res.headers.get('etag');
const fetchedAt = Date.now();
db.insert(rulesetCache)
.values({ url, content, etag, fetchedAt })
.onConflictDoUpdate({ target: rulesetCache.url, set: { content, etag, fetchedAt } })
.run();
return { content, fetchedAt, stale: false };
} catch (e) {
if (cached) return { content: cached.content, fetchedAt: cached.fetchedAt, stale: true };
throw e;
}
}

View File

@@ -0,0 +1,53 @@
/**
* Surge 规则集 URL → Clash 等价 URL 的静态映射。
* 映射不到的返回 needsConvert=true走自托管兜底转换端点。
*/
export interface RulesetMapping {
clashUrl: string | null;
clashBehavior: 'classical' | 'domain' | 'ipcidr';
clashFormat: 'yaml' | 'text';
needsConvert: boolean;
}
export function mapRulesetUrl(surgeUrl: string, ruleType: 'RULE-SET' | 'DOMAIN-SET'): RulesetMapping {
// skk.moeList/{non_ip|ip|domainset}/{name}.conf → Clash/{同路径}/{name}.txt
const skk = surgeUrl.match(/^https:\/\/ruleset\.skk\.moe\/List\/(non_ip|ip|domainset)\/([\w-]+)\.conf$/);
if (skk) {
const [, dir, name] = skk;
return {
clashUrl: `https://ruleset.skk.moe/Clash/${dir}/${name}.txt`,
clashBehavior: dir === 'domainset' ? 'domain' : 'classical',
clashFormat: 'text',
needsConvert: false,
};
}
// blackmatrix7rule/Surge/{Name}/{Name}.list → rule/Clash/{Name}/{Name}.yaml
const bm7 = surgeUrl.match(
/^https:\/\/raw\.githubusercontent\.com\/blackmatrix7\/ios_rule_script\/master\/rule\/Surge\/([\w-]+)\/([\w-]+)\.list$/
);
if (bm7) {
const [, dir, name] = bm7;
return {
clashUrl: `https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Clash/${dir}/${name}.yaml`,
clashBehavior: 'classical',
clashFormat: 'yaml',
needsConvert: false,
};
}
// 其余来源zxfccmm4/Profiles、Semporia/TikTok-Unlock 等):走兜底转换
return {
clashUrl: null,
clashBehavior: ruleType === 'DOMAIN-SET' ? 'domain' : 'classical',
clashFormat: 'yaml',
needsConvert: true,
};
}
/** 从 URL 提取展示名:最后一段文件名去扩展名 */
export function rulesetNameFromUrl(url: string): string {
const last = url.split('/').pop() || url;
return last.replace(/\.(list|conf|txt|yaml)$/, '');
}

View File

@@ -0,0 +1,44 @@
import { inferTags, readInsecure } from './util.js';
import type { ParsedShareLink } from './types.js';
// hysteria2://auth@host:port?sni=s&insecure=1&obfs=salamander&obfs-password=x#name
// hy2:// 是等价别名
export function parseHysteria2(uri: string): ParsedShareLink {
const url = new URL(uri);
const server = url.hostname;
const port = parseInt(url.port || '443', 10);
const user = decodeURIComponent(url.username);
const pass = decodeURIComponent(url.password);
const auth = pass ? `${user}:${pass}` : user;
if (!server || !auth) throw new Error('hysteria2 链接缺少 host/auth');
const name = decodeURIComponent(url.hash.slice(1)) || 'Hysteria2';
const params = url.searchParams;
const obfs = params.get('obfs');
return {
name,
protocol: 'hysteria2',
server,
port,
network: 'tcp',
tls: true,
sni: params.get('sni') || null,
skipCertVerify: readInsecure(params) || !!(params.get('pinSHA256') || params.get('pinsha256')),
password: auth,
obfsType: obfs === 'salamander' ? 'salamander' : null,
obfsPassword: params.get('obfs-password') || params.get('obfs_password') || null,
tags: inferTags(name),
};
}
export function encodeHysteria2(n: ParsedShareLink): string {
const params = new URLSearchParams();
if (n.sni) params.set('sni', n.sni);
if (n.skipCertVerify) params.set('insecure', '1');
if (n.obfsType === 'salamander' && n.obfsPassword) {
params.set('obfs', 'salamander');
params.set('obfs-password', n.obfsPassword);
}
const qs = params.toString();
return `hysteria2://${encodeURIComponent(n.password || '')}@${n.server}:${n.port}${qs ? `?${qs}` : ''}#${encodeURIComponent(n.name)}`;
}

View File

@@ -0,0 +1,167 @@
import { describe, expect, it } from 'vitest';
import { encodeShareLink, parseShareLink } from './parse.js';
const PLACEHOLDER_UUID = '00000000-1111-2222-3333-444444444444';
const PLACEHOLDER_PASS = 'placeholder-password';
describe('vmess', () => {
const json = {
v: '2',
ps: 'Edge Node XX-vmess-direct',
add: 'cc.xx.example.com',
port: '443',
id: PLACEHOLDER_UUID,
aid: '0',
scy: 'auto',
net: 'ws',
type: 'none',
host: 'cc.xx.example.com',
path: '/abc123',
tls: 'tls',
sni: 'cc.xx.example.com',
alpn: '',
};
const uri = 'vmess://' + Buffer.from(JSON.stringify(json)).toString('base64');
it('解析 edge-nodes 交付格式', () => {
const n = parseShareLink(uri);
expect(n).toMatchObject({
protocol: 'vmess',
server: 'cc.xx.example.com',
port: 443,
network: 'ws',
wsPath: '/abc123',
wsHost: 'cc.xx.example.com',
tls: true,
sni: 'cc.xx.example.com',
uuid: PLACEHOLDER_UUID,
alterId: 0,
tags: ['direct'],
});
});
it('round-trip 一致', () => {
const n = parseShareLink(uri);
expect(parseShareLink(encodeShareLink(n))).toEqual(n);
});
});
describe('trojan', () => {
const uri = `trojan://${PLACEHOLDER_PASS}@cc.xx.example.com:443?security=tls&type=ws&host=cc.xx.example.com&path=%2F4688c6&sni=cc.xx.example.com#Edge%20Node%20XX-trojan-warp-clean-exit`;
it('解析 edge-nodes 交付格式', () => {
const n = parseShareLink(uri);
expect(n).toMatchObject({
protocol: 'trojan',
server: 'cc.xx.example.com',
port: 443,
network: 'ws',
wsPath: '/4688c6',
wsHost: 'cc.xx.example.com',
tls: true,
password: PLACEHOLDER_PASS,
tags: ['warp'],
});
expect(n.name).toBe('Edge Node XX-trojan-warp-clean-exit');
});
it('round-trip 一致', () => {
const n = parseShareLink(uri);
expect(parseShareLink(encodeShareLink(n))).toEqual(n);
});
});
describe('shadowsocks', () => {
const userinfo = Buffer.from(`chacha20-poly1305:${PLACEHOLDER_PASS}`).toString('base64url');
const plugin = encodeURIComponent('v2ray-plugin;tls;mode=websocket;host=cc.xx.example.com;path=/22a3d7');
const uri = `ss://${userinfo}@cc.xx.example.com:443?plugin=${plugin}#ss-direct`;
it('解析 SIP002 + v2ray-pluginSS over WS+TLS', () => {
const n = parseShareLink(uri);
expect(n).toMatchObject({
protocol: 'shadowsocks',
server: 'cc.xx.example.com',
port: 443,
network: 'ws',
wsPath: '/22a3d7',
wsHost: 'cc.xx.example.com',
tls: true,
method: 'chacha20-poly1305',
password: PLACEHOLDER_PASS,
});
});
it('round-trip 一致', () => {
const n = parseShareLink(uri);
expect(parseShareLink(encodeShareLink(n))).toEqual(n);
});
it('解析纯 TCP 的 SIP002', () => {
const n = parseShareLink(`ss://${userinfo}@1.2.3.4:8388#plain`);
expect(n).toMatchObject({ network: 'tcp', tls: false, server: '1.2.3.4', port: 8388 });
});
it('解析 Xray 风格参数3x-ui 导出格式)', () => {
const uri = `ss://${userinfo}@cc.xx.example.com:443?type=ws&security=tls&path=%2F22a3d7&sni=cc.xx.example.com#ss-warp`;
expect(parseShareLink(uri)).toMatchObject({
network: 'ws',
wsPath: '/22a3d7',
wsHost: 'cc.xx.example.com',
tls: true,
sni: 'cc.xx.example.com',
method: 'chacha20-poly1305',
});
});
});
describe('hysteria2', () => {
const uri = `hysteria2://${PLACEHOLDER_PASS}@hy2.xx.example.com:443?sni=hy2.xx.example.com&obfs=salamander&obfs-password=obfs-placeholder#hy2-direct`;
it('解析含 salamander obfs 的链接', () => {
const n = parseShareLink(uri);
expect(n).toMatchObject({
protocol: 'hysteria2',
server: 'hy2.xx.example.com',
port: 443,
tls: true,
password: PLACEHOLDER_PASS,
obfsType: 'salamander',
obfsPassword: 'obfs-placeholder',
});
});
it('round-trip 一致', () => {
const n = parseShareLink(uri);
expect(parseShareLink(encodeShareLink(n))).toEqual(n);
});
it('hy2:// 别名可解析', () => {
expect(parseShareLink(uri.replace('hysteria2://', 'hy2://')).protocol).toBe('hysteria2');
});
});
describe('节点命名规范', () => {
// 与 web/src/utils/nodeName.ts 的 TRAILING_EGRESS 保持一致
const strip = (name: string) => name.replace(/[\s·_-]+(direct|warp|)\s*$/iu, '').trim();
it('界面显示名剥掉末尾出口词', () => {
expect(strip('🇺🇸 US LA Trojan Warp')).toBe('🇺🇸 US LA Trojan');
expect(strip('🇸🇬 SG VMess Direct')).toBe('🇸🇬 SG VMess');
expect(strip('🇸🇬 SG · HY2 · 直连')).toBe('🇸🇬 SG · HY2'); // 兼容旧格式
expect(strip('无出口词的节点')).toBe('无出口词的节点');
});
it('新命名仍能被地区组正则命中', () => {
const sg = /|🇸🇬|||SG|Singapore/u;
const us = /|🇺🇸||US|States|American/u;
expect(sg.test('🇸🇬 SG VMess Direct')).toBe(true);
expect(us.test('🇺🇸 US RN HY2 Warp')).toBe(true);
expect(sg.test('🇺🇸 US LA Trojan Warp')).toBe(false);
});
});
describe('批量与异常', () => {
it('未知协议抛错', () => {
expect(() => parseShareLink('vless://x@y:1')).toThrow();
});
});

View File

@@ -0,0 +1,44 @@
import { parseVmess, encodeVmess } from './vmess.js';
import { parseTrojan, encodeTrojan } from './trojan.js';
import { parseSs, encodeSs } from './ss.js';
import { parseHysteria2, encodeHysteria2 } from './hysteria2.js';
import type { ParsedShareLink } from './types.js';
export type { ParsedShareLink };
export function parseShareLink(uri: string): ParsedShareLink {
const s = uri.trim();
if (s.startsWith('vmess://')) return parseVmess(s);
if (s.startsWith('trojan://')) return parseTrojan(s);
if (s.startsWith('ss://')) return parseSs(s);
if (s.startsWith('hysteria2://') || s.startsWith('hy2://')) return parseHysteria2(s);
throw new Error('不支持的链接协议(支持 vmess:// trojan:// ss:// hysteria2://');
}
export function encodeShareLink(n: ParsedShareLink): string {
switch (n.protocol) {
case 'vmess':
return encodeVmess(n);
case 'trojan':
return encodeTrojan(n);
case 'shadowsocks':
return encodeSs(n);
case 'hysteria2':
return encodeHysteria2(n);
}
}
/** 多行文本 → 逐行解析(跳过空行与注释行) */
export function parseShareLinkBatch(text: string): { uri: string; node?: ParsedShareLink; error?: string }[] {
return text
.split(/\r?\n/)
.map((l) => l.trim())
.filter((l) => l && !l.startsWith('#') && !l.startsWith('//'))
.map((uri) => {
try {
return { uri, node: parseShareLink(uri) };
} catch (e: any) {
return { uri, error: e.message || '解析失败' };
}
});
}

View File

@@ -0,0 +1,102 @@
import { b64decode, inferTags, normalizeWsPath } from './util.js';
import type { ParsedShareLink } from './types.js';
// SIP002: ss://base64url(method:password)@host:port?plugin=v2ray-plugin%3Btls%3Bmode%3Dwebsocket%3Bpath%3D%2Fx%3Bhost%3Dh#name
// 旧格式: ss://base64(method:password@host:port)#name
export function parseSs(uri: string): ParsedShareLink {
const url = new URL(uri);
let method: string;
let password: string;
let server: string;
let port: number;
if (url.username) {
const decoded = b64decode(decodeURIComponent(url.username));
const idx = decoded.indexOf(':');
if (idx === -1) throw new Error('ss userinfo 缺少 method:password');
method = decoded.slice(0, idx);
password = decoded.slice(idx + 1);
server = url.hostname;
port = parseInt(url.port, 10);
} else {
// 整体 base64 的旧格式
const decoded = b64decode(uri.slice('ss://'.length).split('#')[0]);
const at = decoded.lastIndexOf('@');
if (at === -1) throw new Error('无法解析 ss 链接');
const [m, ...rest] = decoded.slice(0, at).split(':');
method = m;
password = rest.join(':');
const hostPort = decoded.slice(at + 1);
const colon = hostPort.lastIndexOf(':');
server = hostPort.slice(0, colon);
port = parseInt(hostPort.slice(colon + 1), 10);
}
if (!server || !port || !method) throw new Error('ss 链接缺少 server/port/method');
const name = decodeURIComponent(url.hash.slice(1)) || 'Shadowsocks';
const node: ParsedShareLink = {
name,
protocol: 'shadowsocks',
server,
port,
network: 'tcp',
tls: false,
method,
password,
tags: inferTags(name),
};
// Xray 风格参数3x-ui 导出即此形式type=ws&security=tls&path=&host=&sni=
const params = url.searchParams;
if (params.get('type') === 'ws') {
node.network = 'ws';
node.wsPath = normalizeWsPath(params.get('path'));
node.wsHost = params.get('host') || params.get('sni') || null;
}
if (params.get('security') === 'tls') {
node.tls = true;
node.sni = params.get('sni') || node.wsHost || null;
}
// v2ray-plugin 的 websocket/tls 参数ShadowRocket、ClashMeta 通用写法)
const plugin = params.get('plugin');
if (plugin && plugin.includes('v2ray-plugin')) {
const opts = new Map(
plugin
.split(';')
.slice(1)
.map((kv) => {
const eq = kv.indexOf('=');
return eq === -1 ? [kv, 'true'] : [kv.slice(0, eq), kv.slice(eq + 1)];
}) as [string, string][]
);
if (opts.get('mode') === 'websocket') {
node.network = 'ws';
node.wsPath = normalizeWsPath(opts.get('path'));
node.wsHost = opts.get('host') || null;
}
if (opts.has('tls')) {
node.tls = true;
node.sni = opts.get('host') || null;
}
}
return node;
}
export function encodeSs(n: ParsedShareLink): string {
const userinfo = Buffer.from(`${n.method}:${n.password}`, 'utf8')
.toString('base64')
.replace(/\+/g, '-')
.replace(/\//g, '_')
.replace(/=+$/, '');
let uri = `ss://${userinfo}@${n.server}:${n.port}`;
if (n.network === 'ws') {
const parts = ['v2ray-plugin'];
if (n.tls) parts.push('tls');
parts.push('mode=websocket');
if (n.wsHost) parts.push(`host=${n.wsHost}`);
if (n.wsPath) parts.push(`path=${n.wsPath}`);
uri += `?plugin=${encodeURIComponent(parts.join(';'))}`;
}
return `${uri}#${encodeURIComponent(n.name)}`;
}

View File

@@ -0,0 +1,41 @@
import { inferTags, normalizeWsPath, readInsecure } from './util.js';
import type { ParsedShareLink } from './types.js';
// trojan://password@host:port?security=tls&type=ws&host=h&path=%2Fx&sni=s#name
export function parseTrojan(uri: string): ParsedShareLink {
const url = new URL(uri);
const server = url.hostname;
const port = parseInt(url.port || '443', 10);
const password = decodeURIComponent(url.username);
if (!server || !password) throw new Error('trojan 链接缺少 host/password');
const name = decodeURIComponent(url.hash.slice(1)) || 'Trojan';
const params = url.searchParams;
const network = params.get('type') === 'ws' ? 'ws' : 'tcp';
return {
name,
protocol: 'trojan',
server,
port,
network,
wsPath: network === 'ws' ? normalizeWsPath(params.get('path')) : null,
wsHost: network === 'ws' ? params.get('host') : null,
tls: true,
sni: params.get('sni') || server,
skipCertVerify: readInsecure(params),
password,
tags: inferTags(name),
};
}
export function encodeTrojan(n: ParsedShareLink): string {
const params = new URLSearchParams();
params.set('security', 'tls');
if (n.network === 'ws') {
params.set('type', 'ws');
if (n.wsHost) params.set('host', n.wsHost);
if (n.wsPath) params.set('path', n.wsPath);
}
if (n.sni) params.set('sni', n.sni);
return `trojan://${encodeURIComponent(n.password || '')}@${n.server}:${n.port}?${params.toString()}#${encodeURIComponent(n.name)}`;
}

View File

@@ -0,0 +1,23 @@
import type { Protocol } from '@proxy-station/shared';
/** 分享链接解析出的节点字段(与 nodeInputSchema 对齐,未落库) */
export interface ParsedShareLink {
name: string;
protocol: Protocol;
server: string;
port: number;
network: 'tcp' | 'ws';
wsPath?: string | null;
wsHost?: string | null;
tls: boolean;
sni?: string | null;
skipCertVerify?: boolean;
uuid?: string | null;
alterId?: number;
security?: string;
password?: string | null;
method?: string | null;
obfsType?: 'salamander' | null;
obfsPassword?: string | null;
tags?: string[];
}

View File

@@ -0,0 +1,27 @@
export function b64decode(s: string): string {
return Buffer.from(s.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');
}
export function b64encode(s: string): string {
return Buffer.from(s, 'utf8').toString('base64');
}
/** WS path 统一保证以 / 开头 */
export function normalizeWsPath(p: string | null | undefined): string | null {
if (!p) return null;
return p.startsWith('/') ? p : `/${p}`;
}
export function readInsecure(params: URLSearchParams): boolean {
const v = params.get('insecure') || params.get('allowInsecure') || params.get('skip-cert-verify');
return v === '1' || v === 'true';
}
/** 从节点名推断出口 tagwarp/direct供前端线路矩阵归位 */
export function inferTags(name: string): string[] {
const lower = name.toLowerCase();
const tags: string[] = [];
if (lower.includes('warp')) tags.push('warp');
else if (lower.includes('direct')) tags.push('direct');
return tags;
}

View File

@@ -0,0 +1,50 @@
import { b64decode, inferTags, normalizeWsPath } from './util.js';
import type { ParsedShareLink } from './types.js';
// vmess://base64({"v":"2","ps":name,"add":host,"port":"443","id":uuid,"aid":"0",
// "scy":"auto","net":"ws","type":"none","host":wsHost,"path":"/x","tls":"tls","sni":sni})
export function parseVmess(uri: string): ParsedShareLink {
const json = JSON.parse(b64decode(uri.slice('vmess://'.length)));
const name = json.ps || 'VMess';
const server = String(json.add || '');
const port = parseInt(String(json.port || '0'), 10);
const uuid = String(json.id || '');
if (!server || !port || !uuid) throw new Error('vmess 链接缺少 add/port/id');
const network = json.net === 'ws' ? 'ws' : 'tcp';
return {
name,
protocol: 'vmess',
server,
port,
network,
wsPath: network === 'ws' ? normalizeWsPath(json.path) : null,
wsHost: network === 'ws' ? json.host || null : null,
tls: json.tls === 'tls',
sni: json.sni || null,
uuid,
alterId: parseInt(String(json.aid ?? '0'), 10) || 0,
security: json.scy || 'auto',
tags: inferTags(name),
};
}
export function encodeVmess(n: ParsedShareLink): string {
const json: Record<string, string> = {
v: '2',
ps: n.name,
add: n.server,
port: String(n.port),
id: n.uuid || '',
aid: String(n.alterId ?? 0),
scy: n.security || 'auto',
net: n.network === 'ws' ? 'ws' : 'tcp',
type: 'none',
host: n.wsHost || '',
path: n.wsPath || '',
tls: n.tls ? 'tls' : '',
sni: n.sni || '',
alpn: '',
};
return 'vmess://' + Buffer.from(JSON.stringify(json)).toString('base64');
}

View File

@@ -0,0 +1,55 @@
import { describe, expect, it } from 'vitest';
import { parseSurgeConf, splitTopLevel } from './surge-parser.js';
describe('splitTopLevel', () => {
it('引号内逗号不切分', () => {
expect(splitTopLevel('select, "Hong Kong", Taiwan')).toEqual(['select', '"Hong Kong"', 'Taiwan']);
});
it('括号内逗号不切分AND 复合规则)', () => {
expect(splitTopLevel('AND,((PROTOCOL,UDP), (DOMAIN-SUFFIX,googlevideo.com)),REJECT-NO-DROP')).toEqual([
'AND',
'((PROTOCOL,UDP), (DOMAIN-SUFFIX,googlevideo.com))',
'REJECT-NO-DROP',
]);
});
});
describe('parseSurgeConf', () => {
const conf = `
[General]
ipv6 = false
[Proxy Group]
Auto = url-test, include-other-group=All, policy-regex-filter=SG|Singapore, url=http://x/gen, interval=300, tolerance=50, icon-url=http://icon
Pick = select, Auto, "Hong Kong", DIRECT
All = select, policy-path="placeholder", hidden=0
[Rule]
RULE-SET,https://example.com/a.list,Pick
DOMAIN-SUFFIX,example.com,"Hong Kong",no-resolve
FINAL,Pick,dns-failed
[MITM]
hostname = *.example.com
`;
const parsed = parseSurgeConf(conf);
it('组解析类型、成员、regex、include-other-group', () => {
const auto = parsed.groups.find((g) => g.name === 'Auto')!;
expect(auto).toMatchObject({ type: 'url-test', filterRegex: 'SG|Singapore', includeOtherGroup: 'All', interval: 300, tolerance: 50 });
const pick = parsed.groups.find((g) => g.name === 'Pick')!;
expect(pick.members).toEqual(['Auto', 'Hong Kong', 'DIRECT']);
expect(parsed.groups.find((g) => g.name === 'All')!.hasPolicyPath).toBe(true);
});
it('规则解析RULE-SET、带引号策略、FINAL 参数', () => {
expect(parsed.rules[0]).toMatchObject({ type: 'RULE-SET', value: 'https://example.com/a.list', policy: 'Pick' });
expect(parsed.rules[1]).toMatchObject({ type: 'DOMAIN-SUFFIX', policy: 'Hong Kong', params: ['no-resolve'] });
expect(parsed.rules[2]).toMatchObject({ type: 'FINAL', policy: 'Pick', params: ['dns-failed'] });
});
it('其他段落原文保留', () => {
expect(parsed.sections['MITM']).toBe('hostname = *.example.com');
expect(parsed.sections['General']).toBe('ipv6 = false');
});
});

View File

@@ -0,0 +1,159 @@
/**
* 解析 Surge .conf 模板:分段原文 + [Proxy Group] / [Rule] 的结构化结果。
* 只解析本项目建模所需的字段,未识别的组参数原样忽略。
*/
export interface ParsedGroup {
name: string;
type: 'select' | 'url-test' | 'fallback';
members: string[]; // 组名或 DIRECT/REJECT顺序保留
testUrl?: string;
interval?: number;
tolerance?: number;
filterRegex?: string;
includeOtherGroup?: string;
includeAllProxies?: boolean;
hasPolicyPath?: boolean; // 上游订阅占位AllServer→ 我们的「全部节点」组
}
export interface ParsedRule {
type: string;
value: string | null;
policy: string;
params: string[]; // 如 no-resolve / dns-failed / extended-matching
}
export interface ParsedSurgeConf {
sections: Record<string, string>; // 段名(不含中括号)→ 原文
groups: ParsedGroup[];
rules: ParsedRule[];
}
/** 按逗号切分,但忽略引号与括号内部的逗号 */
export function splitTopLevel(line: string): string[] {
const out: string[] = [];
let cur = '';
let depth = 0;
let quote: string | null = null;
for (const ch of line) {
if (quote) {
cur += ch;
if (ch === quote) quote = null;
continue;
}
if (ch === '"' || ch === "'") {
quote = ch;
cur += ch;
continue;
}
if (ch === '(') depth++;
if (ch === ')') depth--;
if (ch === ',' && depth === 0) {
out.push(cur.trim());
cur = '';
continue;
}
cur += ch;
}
if (cur.trim()) out.push(cur.trim());
return out;
}
function unquote(s: string): string {
if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
return s.slice(1, -1);
}
return s;
}
const KNOWN_GROUP_TYPES = new Set(['select', 'url-test', 'fallback']);
/** 这些参数不建模,序列化 Surge 时也不透传icon 等纯装饰) */
const RULE_PARAM_WHITELIST = new Set(['no-resolve', 'dns-failed', 'extended-matching', 'force-remote-dns']);
export function parseSurgeConf(text: string): ParsedSurgeConf {
const sections: Record<string, string[]> = {};
let current = '';
for (const raw of text.split(/\r?\n/)) {
const trimmed = raw.trim();
const m = trimmed.match(/^\[(.+)\]$/);
if (m) {
current = m[1];
sections[current] = [];
continue;
}
if (current) sections[current].push(raw);
}
const groups: ParsedGroup[] = [];
for (const raw of sections['Proxy Group'] ?? []) {
const line = raw.trim();
if (!line || line.startsWith('#') || line.startsWith('//')) continue;
const eq = line.indexOf('=');
if (eq === -1) continue;
const name = line.slice(0, eq).trim();
const parts = splitTopLevel(line.slice(eq + 1));
const type = parts[0];
if (!KNOWN_GROUP_TYPES.has(type)) continue;
const group: ParsedGroup = { name, type: type as ParsedGroup['type'], members: [] };
for (const part of parts.slice(1)) {
const kvEq = part.indexOf('=');
// 无 = 的项是成员(可能带引号)
if (kvEq === -1 || part.startsWith('"') || part.startsWith("'")) {
group.members.push(unquote(part));
continue;
}
const key = part.slice(0, kvEq).trim();
const value = unquote(part.slice(kvEq + 1).trim());
switch (key) {
case 'url':
group.testUrl = value;
break;
case 'interval':
group.interval = parseInt(value, 10) || undefined;
break;
case 'tolerance':
group.tolerance = parseInt(value, 10) || undefined;
break;
case 'policy-regex-filter':
group.filterRegex = value;
break;
case 'include-other-group':
group.includeOtherGroup = value;
break;
case 'include-all-proxies':
group.includeAllProxies = value === '1' || value === 'true';
break;
case 'policy-path':
group.hasPolicyPath = true;
break;
// no-alert / hidden / icon-url / update-interval / timeout 等不建模
}
}
groups.push(group);
}
const rules: ParsedRule[] = [];
for (const raw of sections['Rule'] ?? []) {
const line = raw.trim();
if (!line || line.startsWith('#') || line.startsWith('//')) continue;
const parts = splitTopLevel(line);
const type = parts[0];
if (!type) continue;
if (type === 'FINAL') {
rules.push({ type, value: null, policy: unquote(parts[1] ?? 'DIRECT'), params: parts.slice(2) });
continue;
}
if (parts.length < 3) continue;
const params = parts.slice(3).filter((p) => RULE_PARAM_WHITELIST.has(p));
rules.push({ type, value: parts[1], policy: unquote(parts[2]), params });
}
const rawSections: Record<string, string> = {};
for (const [name, lines] of Object.entries(sections)) {
if (name === 'Proxy' || name === 'Proxy Group' || name === 'Rule') continue;
rawSections[name] = lines.join('\n').trim();
}
return { sections: rawSections, groups, rules };
}

14
server/tsconfig.json Normal file
View File

@@ -0,0 +1,14 @@
{
"compilerOptions": {
"target": "ES2022",
"module": "ESNext",
"moduleResolution": "bundler",
"strict": true,
"skipLibCheck": true,
"esModuleInterop": true,
"resolveJsonModule": true,
"noEmit": true,
"types": ["node"]
},
"include": ["src"]
}

21
shared/package.json Normal file
View File

@@ -0,0 +1,21 @@
{
"name": "@proxy-station/shared",
"version": "0.1.0",
"private": true,
"type": "module",
"main": "src/index.ts",
"types": "src/index.ts",
"exports": {
".": "./src/index.ts"
},
"scripts": {
"build": "tsc --noEmit",
"typecheck": "tsc --noEmit"
},
"dependencies": {
"zod": "^3.24.1"
},
"devDependencies": {
"typescript": "^5.7.2"
}
}

119
shared/src/dto.ts Normal file
View File

@@ -0,0 +1,119 @@
import type { ClientType, Egress, Protocol } from './protocols.js';
export interface NodeDto {
id: string;
name: string;
protocol: Protocol;
server: string;
port: number;
network: 'tcp' | 'ws';
wsPath: string | null;
wsHost: string | null;
tls: boolean;
sni: string | null;
skipCertVerify: boolean;
uuid: string | null;
alterId: number;
security: string;
password: string | null;
method: string | null;
obfsType: string | null;
obfsPassword: string | null;
upMbps: number | null;
downMbps: number | null;
region: string | null;
tags: string[];
enabled: boolean;
sortOrder: number;
createdAt: number;
updatedAt: number;
}
/** 从节点 tags/名称推断的出口类型,仅前端展示用 */
export function nodeEgress(node: Pick<NodeDto, 'tags' | 'name'>): Egress {
const haystack = [...node.tags, node.name].join(' ').toLowerCase();
if (haystack.includes('warp')) return 'warp';
if (haystack.includes('direct')) return 'direct';
return 'unknown';
}
export interface ImportPreviewItem {
ok: boolean;
uri: string;
error?: string;
node?: Partial<NodeDto> & { name: string; protocol: Protocol };
}
export interface GroupMemberDto {
id: number;
kind: 'node' | 'group' | 'builtin';
nodeId: string | null;
refName: string | null;
sortOrder: number;
}
export interface GroupDto {
id: string;
name: string;
type: 'select' | 'url-test' | 'fallback';
testUrl: string | null;
interval: number | null;
tolerance: number | null;
filterRegex: string | null;
includeAllNodes: boolean;
enabled: boolean;
sortOrder: number;
source: 'template' | 'custom';
members: GroupMemberDto[];
}
export interface RuleDto {
id: string;
seq: number;
type: string;
value: string | null;
policy: string;
params: string[];
enabled: boolean;
source: 'template' | 'custom';
rulesetName?: string | null;
rulesetUrl?: string | null;
}
export interface RulesetDto {
id: string;
name: string;
surgeUrl: string;
clashUrl: string | null;
clashBehavior: string;
needsConvert: boolean;
}
export interface TokenDto {
id: string;
token: string;
name: string;
/** 分配给该订阅的节点 id空数组 = 全部节点 */
nodeIds: string[];
enabled: boolean;
createdAt: number;
lastAccessAt: number | null;
accessCount: number;
/** 各客户端订阅路径ShadowRocket 额外有 shadowrocketConf策略组与规则 */
urls: Record<ClientType, string> & { shadowrocketConf: string };
}
export interface ExcludedNode {
name: string;
reason: string;
}
export interface PreviewResult {
client: ClientType;
content: string;
excluded: ExcludedNode[];
}
export interface SettingsDto {
surgeSections: Record<string, string>;
}

3
shared/src/index.ts Normal file
View File

@@ -0,0 +1,3 @@
export * from './protocols.js';
export * from './schemas.js';
export * from './dto.js';

50
shared/src/protocols.ts Normal file
View File

@@ -0,0 +1,50 @@
export const PROTOCOLS = ['vmess', 'trojan', 'shadowsocks', 'hysteria2'] as const;
export type Protocol = (typeof PROTOCOLS)[number];
export const CLIENTS = ['surge', 'shadowrocket', 'clash'] as const;
export type ClientType = (typeof CLIENTS)[number];
export const CLIENT_LABELS: Record<ClientType, string> = {
surge: 'Surge (macOS)',
shadowrocket: 'ShadowRocket (iOS)',
clash: 'ClashMeta (Android)',
};
/**
* ShadowRocket 分两步导入:节点走订阅、策略组与规则走配置文件。
* 配置文件里的策略组用 `use=true` 引用订阅,因此 App 内的订阅名必须与此一致。
*/
export const SHADOWROCKET_SUB_NAME = 'Proxy Station';
export type Egress = 'direct' | 'warp' | 'unknown';
/** Surge 与 Clash 使用 IETF 命名Xray 分享链接使用简名 */
export const SS_CIPHER_ALIASES: Record<string, string> = {
'chacha20-poly1305': 'chacha20-ietf-poly1305',
'xchacha20-poly1305': 'xchacha20-ietf-poly1305',
};
export function normalizeSsCipher(method: string): string {
return SS_CIPHER_ALIASES[method] ?? method;
}
export interface NodeCapabilityInput {
protocol: Protocol;
network: 'tcp' | 'ws';
}
export interface CapabilityVerdict {
ok: boolean;
reason?: string;
}
/**
* 客户端能力矩阵:不支持的组合在下发订阅时自动屏蔽。
* Surge 的 ss 类型没有 WebSocket 传输(仅 simple-obfsSS over WS 线路必须排除。
*/
export function clientSupports(client: ClientType, node: NodeCapabilityInput): CapabilityVerdict {
if (client === 'surge' && node.protocol === 'shadowsocks' && node.network === 'ws') {
return { ok: false, reason: 'Surge 不支持 Shadowsocks over WebSocket' };
}
return { ok: true };
}

99
shared/src/schemas.ts Normal file
View File

@@ -0,0 +1,99 @@
import { z } from 'zod';
import { PROTOCOLS } from './protocols.js';
export const nodeInputSchema = z
.object({
name: z.string().min(1).max(64),
protocol: z.enum(PROTOCOLS),
server: z.string().min(1),
port: z.number().int().min(1).max(65535),
network: z.enum(['tcp', 'ws']).default('tcp'),
wsPath: z.string().startsWith('/').optional().nullable(),
wsHost: z.string().optional().nullable(),
tls: z.boolean().default(false),
sni: z.string().optional().nullable(),
skipCertVerify: z.boolean().default(false),
uuid: z.string().uuid().optional().nullable(),
alterId: z.number().int().min(0).default(0),
security: z.string().default('auto'),
password: z.string().optional().nullable(),
method: z.string().optional().nullable(),
obfsType: z.enum(['salamander']).optional().nullable(),
obfsPassword: z.string().optional().nullable(),
upMbps: z.number().int().positive().optional().nullable(),
downMbps: z.number().int().positive().optional().nullable(),
region: z.string().max(8).optional().nullable(),
tags: z.array(z.string()).default([]),
enabled: z.boolean().default(true),
sortOrder: z.number().int().default(0),
})
.superRefine((v, ctx) => {
if (v.protocol === 'vmess' && !v.uuid) {
ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['uuid'], message: 'VMess 需要 UUID' });
}
if ((v.protocol === 'trojan' || v.protocol === 'shadowsocks' || v.protocol === 'hysteria2') && !v.password) {
ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['password'], message: '该协议需要密码' });
}
if (v.protocol === 'shadowsocks' && !v.method) {
ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['method'], message: 'Shadowsocks 需要加密方式' });
}
if (v.network === 'ws' && !v.wsPath) {
ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['wsPath'], message: 'WebSocket 传输需要路径' });
}
});
export type NodeInput = z.input<typeof nodeInputSchema>;
export type NodeParsed = z.output<typeof nodeInputSchema>;
export const groupInputSchema = z.object({
name: z.string().min(1).max(64),
type: z.enum(['select', 'url-test', 'fallback']),
testUrl: z.string().url().optional().nullable(),
interval: z.number().int().positive().optional().nullable(),
tolerance: z.number().int().positive().optional().nullable(),
filterRegex: z.string().optional().nullable(),
includeAllNodes: z.boolean().default(false),
sortOrder: z.number().int().default(0),
members: z
.array(
z.object({
kind: z.enum(['node', 'group', 'builtin']),
nodeId: z.string().optional().nullable(),
refName: z.string().optional().nullable(),
})
)
.default([]),
});
export type GroupInput = z.input<typeof groupInputSchema>;
export const RULE_TYPES = [
'RULE-SET',
'DOMAIN-SET',
'DOMAIN',
'DOMAIN-SUFFIX',
'DOMAIN-KEYWORD',
'IP-CIDR',
'IP-CIDR6',
'IP-ASN',
'GEOIP',
'PROCESS-NAME',
'USER-AGENT',
'URL-REGEX',
'AND',
'OR',
'NOT',
'FINAL',
] as const;
export const ruleInputSchema = z.object({
type: z.enum(RULE_TYPES),
value: z.string().optional().nullable(),
policy: z.string().min(1),
params: z.array(z.string()).default([]),
enabled: z.boolean().default(true),
});
export type RuleInput = z.input<typeof ruleInputSchema>;
export const tokenInputSchema = z.object({
name: z.string().min(1).max(64),
});

11
shared/tsconfig.json Normal file
View File

@@ -0,0 +1,11 @@
{
"compilerOptions": {
"target": "ES2022",
"module": "ESNext",
"moduleResolution": "bundler",
"strict": true,
"skipLibCheck": true,
"noEmit": true
},
"include": ["src"]
}

12
web/index.html Normal file
View File

@@ -0,0 +1,12 @@
<!doctype html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Proxy Station</title>
</head>
<body>
<div id="app"></div>
<script type="module" src="/src/main.ts"></script>
</body>
</html>

25
web/package.json Normal file
View File

@@ -0,0 +1,25 @@
{
"name": "@proxy-station/web",
"version": "0.1.0",
"private": true,
"type": "module",
"scripts": {
"dev": "vite",
"build": "vite build",
"typecheck": "vue-tsc --noEmit"
},
"dependencies": {
"@fontsource/ibm-plex-mono": "^5.1.0",
"@proxy-station/shared": "workspace:*",
"naive-ui": "^2.40.4",
"pinia": "^2.3.0",
"vue": "^3.5.13",
"vue-router": "^4.5.0"
},
"devDependencies": {
"@vitejs/plugin-vue": "^5.2.1",
"typescript": "^5.7.2",
"vite": "^6.0.6",
"vue-tsc": "^2.2.0"
}
}

189
web/src/App.vue Normal file
View File

@@ -0,0 +1,189 @@
<script setup lang="ts">
import { computed } from 'vue';
import { useRoute, useRouter } from 'vue-router';
import { NConfigProvider, NMessageProvider, NDialogProvider } from 'naive-ui';
import { themeOverrides } from './theme';
const route = useRoute();
const router = useRouter();
const navItems = [
{ path: '/nodes', label: '节点' },
{ path: '/groups', label: '策略组' },
{ path: '/rules', label: '规则' },
{ path: '/subscriptions', label: '订阅' },
{ path: '/settings', label: '设置' },
];
const active = computed(() => route.path);
</script>
<template>
<NConfigProvider :theme-overrides="themeOverrides">
<NMessageProvider>
<NDialogProvider>
<div class="shell">
<header class="topbar">
<div class="topbar-inner">
<div class="brand">
<span class="brand-name">Proxy Station</span>
<span class="brand-strip"><i class="strip-direct" /><i class="strip-warp" /></span>
</div>
<nav class="nav">
<button
v-for="item in navItems"
:key="item.path"
class="nav-item"
:class="{ active: active.startsWith(item.path) }"
@click="router.push(item.path)"
>
{{ item.label }}
</button>
</nav>
<div class="legend">
<span class="legend-item"><i class="lamp lamp-direct" />直连出口</span>
<span class="legend-item"><i class="lamp lamp-warp" />WARP 出口</span>
</div>
</div>
</header>
<main class="content">
<RouterView />
</main>
</div>
</NDialogProvider>
</NMessageProvider>
</NConfigProvider>
</template>
<style scoped>
.shell {
min-height: 100vh;
}
.topbar {
background: var(--panel);
border-bottom: 1px solid var(--line);
position: sticky;
top: 0;
z-index: 10;
}
.topbar-inner {
max-width: 1240px;
margin: 0 auto;
padding: 0 32px;
display: flex;
align-items: stretch;
gap: 36px;
}
.brand {
display: flex;
flex-direction: column;
justify-content: center;
gap: 4px;
padding: 12px 0;
}
.brand-name {
font-size: 16px;
font-weight: 800;
letter-spacing: -0.01em;
white-space: nowrap;
}
/* 品牌下的线路色条:站名牌的双色带 */
.brand-strip {
display: flex;
height: 3px;
border-radius: 2px;
overflow: hidden;
}
.brand-strip i {
flex: 1;
}
.strip-direct {
background: var(--direct);
}
.strip-warp {
background: var(--warp);
}
.nav {
display: flex;
gap: 26px;
flex: 1;
}
/* 选中 = 粗下划线(站台线条),不加底不加边 */
.nav-item {
appearance: none;
border: none;
background: transparent;
color: var(--muted);
font: 600 14px var(--font-body);
padding: 0 2px;
border-bottom: 3px solid transparent;
border-top: 3px solid transparent;
cursor: pointer;
transition: color 0.1s;
}
.nav-item:hover {
color: var(--text);
}
.nav-item.active {
color: var(--ink);
border-bottom-color: var(--ink);
}
.legend {
display: flex;
align-items: center;
gap: 16px;
font-size: 12px;
color: var(--muted);
}
.legend-item {
display: flex;
align-items: center;
gap: 6px;
white-space: nowrap;
}
.content {
max-width: 1240px;
margin: 0 auto;
padding: 28px 32px 64px;
box-sizing: border-box;
}
@media (max-width: 720px) {
.topbar-inner {
padding: 0 16px;
gap: 16px;
}
.brand-name {
font-size: 14px;
}
.nav {
gap: 16px;
overflow-x: auto;
}
.legend {
display: none;
}
.content {
padding: 16px 16px 48px;
}
}
</style>

44
web/src/api/client.ts Normal file
View File

@@ -0,0 +1,44 @@
const ADMIN_TOKEN_KEY = 'proxy-station:admin-token';
export function getAdminToken(): string {
return localStorage.getItem(ADMIN_TOKEN_KEY) || '';
}
export function setAdminToken(token: string) {
if (token) localStorage.setItem(ADMIN_TOKEN_KEY, token);
else localStorage.removeItem(ADMIN_TOKEN_KEY);
}
export class ApiError extends Error {
constructor(
public status: number,
message: string
) {
super(message);
}
}
async function request<T>(method: string, path: string, body?: unknown): Promise<T> {
const headers: Record<string, string> = {};
const token = getAdminToken();
if (token) headers.Authorization = `Bearer ${token}`;
if (body !== undefined) headers['content-type'] = 'application/json';
const res = await fetch(path, {
method,
headers,
body: body === undefined ? undefined : JSON.stringify(body),
});
const data = await res.json().catch(() => null);
if (!res.ok) {
throw new ApiError(res.status, (data as any)?.error || `请求失败(${res.status}`);
}
return data as T;
}
export const api = {
get: <T>(path: string) => request<T>('GET', path),
post: <T>(path: string, body?: unknown) => request<T>('POST', path, body),
put: <T>(path: string, body?: unknown) => request<T>('PUT', path, body),
patch: <T>(path: string, body?: unknown) => request<T>('PATCH', path, body),
delete: <T>(path: string) => request<T>('DELETE', path),
};

View File

@@ -0,0 +1,62 @@
<script setup lang="ts">
import { computed } from 'vue';
import type { Egress } from '@proxy-station/shared';
const props = withDefaults(defineProps<{ egress: Egress; compact?: boolean }>(), { compact: false });
const label = computed(
() => ({ direct: '直连', warp: 'WARP', unknown: '未标注' })[props.egress]
);
</script>
<template>
<!-- compact空间紧张处只用语义圆点颜色即信息 -->
<span v-if="compact" class="dot-only" :title="label">
<i class="lamp" :class="{
'lamp-direct': egress === 'direct',
'lamp-warp': egress === 'warp',
'lamp-off': egress === 'unknown',
}" />
</span>
<span v-else class="badge" :class="`badge-${egress}`"><i class="lamp" :class="{
'lamp-direct': egress === 'direct',
'lamp-warp': egress === 'warp',
'lamp-off': egress === 'unknown',
}" />{{ label }}</span>
</template>
<style scoped>
/* 导视胶囊标签:淡色底 + 语义圆点 */
.badge {
display: inline-flex;
align-items: center;
gap: 6px;
flex-shrink: 0;
white-space: nowrap;
font-size: 12px;
font-weight: 600;
padding: 3px 10px;
border-radius: 999px;
}
.badge-direct {
background: var(--direct-dim);
color: var(--direct);
}
.badge-warp {
background: var(--warp-dim);
color: var(--warp);
}
.badge-unknown {
background: #eeeeea;
color: var(--muted);
}
.dot-only {
display: inline-flex;
align-items: center;
flex-shrink: 0;
}
</style>

View File

@@ -0,0 +1,121 @@
<script setup lang="ts">
import { ref } from 'vue';
import { NModal, NInput, NButton, NSpace, NTag, useMessage } from 'naive-ui';
import { useNodesStore, type ImportResult } from '../stores/nodes';
const props = defineProps<{ show: boolean }>();
const emit = defineEmits<{ (e: 'update:show', v: boolean): void; (e: 'imported'): void }>();
const store = useNodesStore();
const message = useMessage();
const text = ref('');
const preview = ref<ImportResult | null>(null);
const busy = ref(false);
async function doPreview() {
if (!text.value.trim()) return;
busy.value = true;
try {
preview.value = await store.importText(text.value, false);
} catch (e: any) {
message.error(e.message);
} finally {
busy.value = false;
}
}
async function doCommit() {
busy.value = true;
try {
const result = await store.importText(text.value, true);
message.success(`已导入 ${result.succeeded} 个节点`);
text.value = '';
preview.value = null;
emit('imported');
emit('update:show', false);
} catch (e: any) {
message.error(e.message);
} finally {
busy.value = false;
}
}
function close() {
preview.value = null;
emit('update:show', false);
}
</script>
<template>
<NModal :show="show" preset="card" title="批量导入分享链接" style="max-width: 680px" @update:show="close">
<p class="hint">每行一条链接支持 vmess:// trojan:// ss:// hysteria2://。重名节点自动加后缀。</p>
<NInput
v-model:value="text"
type="textarea"
:rows="8"
class="mono"
placeholder="vmess://…&#10;trojan://…"
@input="preview = null"
/>
<div v-if="preview" class="preview">
<div v-for="(item, i) in preview.items" :key="i" class="preview-row">
<NTag :type="item.ok ? 'success' : 'error'" size="small">{{ item.ok ? '可导入' : '失败' }}</NTag>
<span v-if="item.ok" class="preview-name">
{{ item.node!.name }}
<span class="mono preview-detail">{{ item.node!.protocol }} · {{ item.node!.server }}:{{ item.node!.port }}</span>
</span>
<span v-else class="preview-error">{{ item.error }}<span class="mono preview-detail">{{ item.uri.slice(0, 48) }}</span></span>
</div>
</div>
<template #footer>
<NSpace justify="end">
<NButton @click="close">取消</NButton>
<NButton :loading="busy" :disabled="!text.trim()" @click="doPreview">解析预览</NButton>
<NButton
type="primary"
:loading="busy"
:disabled="!preview || preview.succeeded === 0"
@click="doCommit"
>
导入 {{ preview?.succeeded ?? 0 }} 个节点
</NButton>
</NSpace>
</template>
</NModal>
</template>
<style scoped>
.hint {
color: var(--muted);
font-size: 12px;
margin: 0 0 8px;
}
.preview {
margin-top: 12px;
display: flex;
flex-direction: column;
gap: 6px;
max-height: 220px;
overflow-y: auto;
}
.preview-row {
display: flex;
align-items: center;
gap: 8px;
font-size: 13px;
}
.preview-detail {
color: var(--muted);
font-size: 12px;
margin-left: 8px;
}
.preview-error {
color: var(--danger);
}
</style>

View File

@@ -0,0 +1,184 @@
<script setup lang="ts">
import { computed, reactive, watch } from 'vue';
import {
NModal,
NForm,
NFormItem,
NInput,
NInputNumber,
NSelect,
NSwitch,
NButton,
NSpace,
useMessage,
} from 'naive-ui';
import { nodeInputSchema, PROTOCOLS, type NodeDto, type NodeInput } from '@proxy-station/shared';
const props = defineProps<{ show: boolean; node?: NodeDto | null }>();
const emit = defineEmits<{
(e: 'update:show', v: boolean): void;
(e: 'submit', input: NodeInput, id?: string): void;
(e: 'delete', id: string): void;
}>();
const message = useMessage();
const blank = (): NodeInput => ({
name: '',
protocol: 'vmess',
server: '',
port: 443,
network: 'ws',
wsPath: '/',
wsHost: null,
tls: true,
sni: null,
skipCertVerify: false,
uuid: null,
alterId: 0,
security: 'auto',
password: null,
method: 'chacha20-poly1305',
obfsType: null,
obfsPassword: null,
region: null,
tags: [],
enabled: true,
sortOrder: 0,
});
const form = reactive<NodeInput>(blank());
watch(
() => props.show,
(show) => {
if (!show) return;
Object.assign(form, blank(), props.node ?? {});
}
);
const isEdit = computed(() => !!props.node);
const protocolOptions = PROTOCOLS.map((p) => ({ label: p, value: p }));
const tagOptions = [
{ label: 'direct直连出口', value: 'direct' },
{ label: 'warpWARP 出口)', value: 'warp' },
];
const showWs = computed(() => form.protocol !== 'hysteria2');
const showVmess = computed(() => form.protocol === 'vmess');
const showPassword = computed(() => form.protocol !== 'vmess');
const showSs = computed(() => form.protocol === 'shadowsocks');
const showHy2 = computed(() => form.protocol === 'hysteria2');
function submit() {
const result = nodeInputSchema.safeParse({ ...form });
if (!result.success) {
message.error(result.error.issues[0]?.message || '表单校验失败');
return;
}
emit('submit', { ...form }, props.node?.id);
}
</script>
<template>
<NModal
:show="show"
preset="card"
:title="isEdit ? `编辑节点 · ${node?.name}` : '添加节点'"
style="max-width: 560px"
@update:show="emit('update:show', $event)"
>
<NForm label-placement="left" label-width="92">
<NFormItem label="名称" required>
<NInput v-model:value="form.name" placeholder="如 SG-vmess-warp" />
</NFormItem>
<NFormItem label="协议" required>
<NSelect v-model:value="form.protocol" :options="protocolOptions" :disabled="isEdit" />
</NFormItem>
<NFormItem label="服务器" required>
<NInput v-model:value="form.server" placeholder="域名或 IP" class="mono" />
</NFormItem>
<NFormItem label="端口" required>
<NInputNumber v-model:value="form.port" :min="1" :max="65535" style="width: 100%" />
</NFormItem>
<template v-if="showVmess">
<NFormItem label="UUID" required>
<NInput v-model:value="form.uuid" class="mono" />
</NFormItem>
</template>
<template v-if="showPassword">
<NFormItem label="密码" required>
<NInput v-model:value="form.password" type="password" show-password-on="click" class="mono" />
</NFormItem>
</template>
<template v-if="showSs">
<NFormItem label="加密方式" required>
<NInput v-model:value="form.method" placeholder="chacha20-poly1305" class="mono" />
</NFormItem>
</template>
<template v-if="showHy2">
<NFormItem label="混淆">
<NSelect
v-model:value="form.obfsType"
:options="[
{ label: '无', value: null as any },
{ label: 'salamander', value: 'salamander' },
]"
/>
</NFormItem>
<NFormItem v-if="form.obfsType === 'salamander'" label="混淆密码" required>
<NInput v-model:value="form.obfsPassword" type="password" show-password-on="click" class="mono" />
</NFormItem>
</template>
<template v-if="showWs">
<NFormItem label="传输">
<NSelect
v-model:value="form.network"
:options="[
{ label: 'TCP', value: 'tcp' },
{ label: 'WebSocket', value: 'ws' },
]"
/>
</NFormItem>
<template v-if="form.network === 'ws'">
<NFormItem label="WS 路径" required>
<NInput v-model:value="form.wsPath" placeholder="/xxxxxx" class="mono" />
</NFormItem>
<NFormItem label="WS Host">
<NInput v-model:value="form.wsHost" placeholder="默认与服务器相同" class="mono" />
</NFormItem>
</template>
</template>
<NFormItem label="TLS">
<NSwitch v-model:value="form.tls" :disabled="form.protocol === 'hysteria2'" />
</NFormItem>
<NFormItem v-if="form.tls" label="SNI">
<NInput v-model:value="form.sni" placeholder="默认与服务器相同" class="mono" />
</NFormItem>
<NFormItem label="出口标签">
<NSelect v-model:value="form.tags" multiple :options="tagOptions" placeholder="direct / warp用于线路矩阵归位" />
</NFormItem>
<NFormItem label="站点代号">
<NInput v-model:value="form.region" placeholder="如 SGLARN留空则按域名推断" />
</NFormItem>
<NFormItem label="启用">
<NSwitch v-model:value="form.enabled" />
</NFormItem>
</NForm>
<template #footer>
<NSpace justify="space-between">
<NButton v-if="isEdit" type="error" quaternary @click="emit('delete', node!.id)">删除节点</NButton>
<span v-else />
<NSpace>
<NButton @click="emit('update:show', false)">取消</NButton>
<NButton type="primary" @click="submit">{{ isEdit ? '保存' : '添加' }}</NButton>
</NSpace>
</NSpace>
</template>
</NModal>
</template>

View File

@@ -0,0 +1,51 @@
<script setup lang="ts">
import { computed } from 'vue';
import type { Protocol } from '@proxy-station/shared';
const props = defineProps<{ protocol: Protocol }>();
const LETTERS: Record<Protocol, string> = {
vmess: 'V',
trojan: 'T',
shadowsocks: 'S',
hysteria2: 'H',
};
const letter = computed(() => LETTERS[props.protocol]);
</script>
<template>
<span class="proto-dot" :class="`proto-${protocol}`" :title="protocol">{{ letter }}</span>
</template>
<style scoped>
/* 线路色圆标:导视系统的线路标识 */
.proto-dot {
display: inline-flex;
align-items: center;
justify-content: center;
width: 22px;
height: 22px;
border-radius: 50%;
flex-shrink: 0;
font-size: 11px;
font-weight: 700;
color: #fff;
}
.proto-vmess {
background: var(--proto-vmess);
}
.proto-trojan {
background: var(--proto-trojan);
}
.proto-shadowsocks {
background: var(--proto-shadowsocks);
}
.proto-hysteria2 {
background: var(--proto-hysteria2);
}
</style>

View File

@@ -0,0 +1,91 @@
<script setup lang="ts">
import { ref, watch } from 'vue';
import { NButton, NDrawer, NDrawerContent, NSpace, NSpin, NTag, useMessage } from 'naive-ui';
import type { RuleDto } from '@proxy-station/shared';
import { api } from '../api/client';
const props = defineProps<{ show: boolean; rule: RuleDto | null }>();
const emit = defineEmits<{ (e: 'update:show', v: boolean): void }>();
const message = useMessage();
const content = ref('');
const lineCount = ref(0);
const fetchedAt = ref(0);
const stale = ref(false);
const loading = ref(false);
async function load(refresh = false) {
if (!props.rule?.value) return;
loading.value = true;
try {
const result = await api.get<{ content: string; fetchedAt: number; stale: boolean; lineCount: number }>(
`/api/rulesets/${props.rule.value}/content${refresh ? '?refresh=1' : ''}`
);
content.value = result.content;
lineCount.value = result.lineCount;
fetchedAt.value = result.fetchedAt;
stale.value = result.stale;
} catch (e: any) {
message.error(e.message);
content.value = '';
} finally {
loading.value = false;
}
}
watch(
() => props.show,
(show) => {
if (show) load();
}
);
</script>
<template>
<NDrawer :show="show" :width="560" @update:show="emit('update:show', $event)">
<NDrawerContent :title="rule?.rulesetName ?? '规则集预览'" closable>
<template #header>
<NSpace align="center" size="small">
<span>{{ rule?.rulesetName }}</span>
<NTag v-if="lineCount" size="small" :bordered="false">{{ lineCount }} </NTag>
<NTag v-if="stale" size="small" type="warning" :bordered="false">缓存已过期上游暂不可达</NTag>
</NSpace>
</template>
<div class="meta">
<code class="mono url">{{ rule?.rulesetUrl }}</code>
<NSpace size="small" style="margin: 8px 0">
<span v-if="fetchedAt" class="fetched">拉取于 {{ new Date(fetchedAt).toLocaleString() }}</span>
<NButton size="tiny" secondary :loading="loading" @click="load(true)">刷新</NButton>
</NSpace>
</div>
<NSpin :show="loading">
<pre class="content mono">{{ content || '(无内容)' }}</pre>
</NSpin>
</NDrawerContent>
</NDrawer>
</template>
<style scoped>
.url {
font-size: 11px;
color: var(--muted);
word-break: break-all;
}
.fetched {
font-size: 11px;
color: var(--muted);
}
.content {
font-size: 11px;
line-height: 1.6;
background: var(--bg);
border-radius: 6px;
padding: 12px;
max-height: calc(100vh - 220px);
overflow: auto;
white-space: pre-wrap;
word-break: break-all;
}
</style>

View File

@@ -0,0 +1,236 @@
<script setup lang="ts">
import { computed, ref, watch } from 'vue';
import { NButton, NCheckbox, NInput, NModal, NSpace, useMessage } from 'naive-ui';
import { nodeEgress, type NodeDto, type TokenDto } from '@proxy-station/shared';
import { stationOf } from './stations';
import ProtoDot from './ProtoDot.vue';
import EgressBadge from './EgressBadge.vue';
import { nodeDisplayName } from '../utils/nodeName';
const props = defineProps<{ show: boolean; token?: TokenDto | null; nodes: NodeDto[] }>();
const emit = defineEmits<{
(e: 'update:show', v: boolean): void;
(e: 'submit', payload: { name: string; nodeIds: string[] }, id?: string): void;
}>();
const message = useMessage();
const name = ref('');
const selected = ref<Set<string>>(new Set());
const isEdit = computed(() => !!props.token);
const enabledNodes = computed(() => props.nodes.filter((n) => n.enabled));
/** 按站点分组,与线路矩阵一致 */
const stations = computed(() => {
const map = new Map<string, NodeDto[]>();
for (const n of enabledNodes.value) {
const key = stationOf(n);
if (!map.has(key)) map.set(key, []);
map.get(key)!.push(n);
}
return [...map.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([code, list]) => ({ code, nodes: list }));
});
watch(
() => props.show,
(show) => {
if (!show) return;
name.value = props.token?.name ?? '';
// 空数组语义是「全部」,编辑时展开成全选,用户能直观看到勾选状态
const ids = props.token?.nodeIds ?? [];
selected.value = new Set(ids.length ? ids : enabledNodes.value.map((n) => n.id));
}
);
const allSelected = computed(() => selected.value.size === enabledNodes.value.length);
const selectedCount = computed(() => selected.value.size);
function toggleNode(id: string, checked: boolean) {
const next = new Set(selected.value);
if (checked) next.add(id);
else next.delete(id);
selected.value = next;
}
function toggleStation(code: string, checked: boolean) {
const next = new Set(selected.value);
const ids = stations.value.find((s) => s.code === code)!.nodes.map((n) => n.id);
for (const id of ids) {
if (checked) next.add(id);
else next.delete(id);
}
selected.value = next;
}
function stationState(code: string): { all: boolean; some: boolean } {
const ids = stations.value.find((s) => s.code === code)!.nodes.map((n) => n.id);
const hit = ids.filter((id) => selected.value.has(id)).length;
return { all: hit === ids.length, some: hit > 0 && hit < ids.length };
}
function toggleAll(checked: boolean) {
selected.value = checked ? new Set(enabledNodes.value.map((n) => n.id)) : new Set();
}
function submit() {
if (!name.value.trim()) {
message.error('请填写订阅名称');
return;
}
if (selected.value.size === 0) {
message.error('至少选择一个节点');
return;
}
// 全选时存空数组:语义为「不限制」,之后新增的节点会自动包含进来
const nodeIds = allSelected.value ? [] : [...selected.value];
emit('submit', { name: name.value.trim(), nodeIds }, props.token?.id);
}
</script>
<template>
<NModal
:show="show"
preset="card"
:title="isEdit ? `编辑订阅 · ${token?.name}` : '新建订阅'"
style="max-width: 620px"
@update:show="emit('update:show', $event)"
>
<div class="field">
<label class="field-label">订阅名称</label>
<NInput v-model:value="name" placeholder="设备或用户名,如 kid-macbook / 朋友-A" />
</div>
<div class="field">
<div class="field-head">
<label class="field-label">可用节点</label>
<div class="field-actions">
<span class="count">已选 {{ selectedCount }} / {{ enabledNodes.length }}</span>
<NButton size="tiny" quaternary @click="toggleAll(true)">全选</NButton>
<NButton size="tiny" quaternary @click="toggleAll(false)">清空</NButton>
</div>
</div>
<p class="field-hint">
只有勾选的节点会下发给这个订阅全选时后续新增的节点会自动包含进来
</p>
<div class="stations">
<section v-for="st in stations" :key="st.code" class="station">
<NCheckbox
:checked="stationState(st.code).all"
:indeterminate="stationState(st.code).some"
@update:checked="(v: boolean) => toggleStation(st.code, v)"
>
<span class="station-code">{{ st.code }}</span>
<span class="station-count">{{ st.nodes.length }} </span>
</NCheckbox>
<div class="node-list">
<NCheckbox
v-for="n in st.nodes"
:key="n.id"
:checked="selected.has(n.id)"
class="node-item"
@update:checked="(v: boolean) => toggleNode(n.id, v)"
>
<span class="node-line">
<ProtoDot :protocol="n.protocol" />
<span class="node-name">{{ nodeDisplayName(n) }}</span>
<EgressBadge :egress="nodeEgress(n)" />
</span>
</NCheckbox>
</div>
</section>
</div>
</div>
<template #footer>
<NSpace justify="end">
<NButton @click="emit('update:show', false)">取消</NButton>
<NButton type="primary" @click="submit">{{ isEdit ? '保存' : '创建' }}</NButton>
</NSpace>
</template>
</NModal>
</template>
<style scoped>
.field {
margin-bottom: 18px;
}
.field-head {
display: flex;
align-items: baseline;
justify-content: space-between;
gap: 12px;
}
.field-label {
display: block;
font-size: 13px;
font-weight: 600;
margin-bottom: 6px;
}
.field-actions {
display: flex;
align-items: center;
gap: 4px;
}
.count {
font-size: 12px;
color: var(--muted);
margin-right: 4px;
}
.field-hint {
font-size: 12px;
color: var(--muted);
margin: 0 0 10px;
}
.stations {
max-height: 380px;
overflow-y: auto;
border: 1px solid var(--line);
border-radius: 10px;
padding: 12px 14px;
}
.station + .station {
margin-top: 14px;
padding-top: 14px;
border-top: 1px solid var(--line-soft);
}
.station-code {
font-weight: 700;
font-size: 13px;
margin-right: 8px;
}
.station-count {
font-size: 11px;
color: var(--muted);
}
.node-list {
display: flex;
flex-direction: column;
gap: 2px;
margin: 6px 0 0 24px;
}
.node-item {
padding: 3px 0;
}
.node-line {
display: inline-flex;
align-items: center;
gap: 8px;
}
.node-name {
font-size: 13px;
}
</style>

View File

@@ -0,0 +1,23 @@
import type { NodeDto } from '@proxy-station/shared';
/**
* 站点归组:优先 region 字段否则从域名猜测cc.sg.example.com → SG
* 最后回落到 server 本身。
*/
export function stationOf(node: NodeDto): string {
if (node.region) return node.region.toUpperCase();
const parts = node.server.split('.');
if (parts.length >= 4 && parts[1].length <= 4) return parts[1].toUpperCase();
return node.server;
}
/** 站点展示名:国旗 + 国家 + 站点代号 */
const STATION_LABELS: Record<string, string> = {
SG: '🇸🇬 SG AWS',
LA: '🇺🇸 US LA',
RN: '🇺🇸 US RN',
};
export function stationLabel(code: string): string {
return STATION_LABELS[code] ?? code;
}

10
web/src/main.ts Normal file
View File

@@ -0,0 +1,10 @@
import { createApp } from 'vue';
import { createPinia } from 'pinia';
import App from './App.vue';
import { router } from './router';
import '@fontsource/ibm-plex-mono/400.css';
import '@fontsource/ibm-plex-mono/500.css';
import './styles/tokens.css';
createApp(App).use(createPinia()).use(router).mount('#app');

View File

@@ -0,0 +1,353 @@
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue';
import {
NButton,
NCard,
NForm,
NFormItem,
NInput,
NInputNumber,
NModal,
NSelect,
NSpace,
NSwitch,
NTag,
useDialog,
useMessage,
} from 'naive-ui';
import { nodeEgress, type GroupDto, type GroupInput } from '@proxy-station/shared';
import { useGroupsStore } from '../stores/groups';
import { useNodesStore } from '../stores/nodes';
import EgressBadge from '../components/EgressBadge.vue';
import { nodeDisplayName } from '../utils/nodeName';
const store = useGroupsStore();
const nodesStore = useNodesStore();
const message = useMessage();
const dialog = useDialog();
onMounted(() => {
store.fetchAll();
nodesStore.fetchAll();
});
const showForm = ref(false);
const editing = ref<GroupDto | null>(null);
const form = ref<GroupInput>(blankForm());
const memberSelection = ref<string[]>([]);
function blankForm(): GroupInput {
return {
name: '',
type: 'select',
testUrl: null,
interval: null,
tolerance: null,
filterRegex: null,
includeAllNodes: false,
sortOrder: 0,
members: [],
};
}
/** 成员选项builtin + 其他组 + 节点,用前缀区分 */
const memberOptions = computed(() => [
{ type: 'group' as const, label: '— 内置策略 —', key: 'h1', children: ['DIRECT', 'REJECT'].map((b) => ({ label: b, value: `builtin:${b}` })) },
{
type: 'group' as const,
label: '— 策略组 —',
key: 'h2',
children: store.groups.filter((g) => g.id !== editing.value?.id).map((g) => ({ label: g.name, value: `group:${g.name}` })),
},
{
type: 'group' as const,
label: '— 节点 —',
key: 'h3',
children: nodesStore.nodes.map((n) => ({ label: n.name, value: `node:${n.id}` })),
},
]);
function openCreate() {
editing.value = null;
form.value = blankForm();
memberSelection.value = [];
showForm.value = true;
}
function openEdit(group: GroupDto) {
editing.value = group;
form.value = {
name: group.name,
type: group.type,
testUrl: group.testUrl,
interval: group.interval,
tolerance: group.tolerance,
filterRegex: group.filterRegex,
includeAllNodes: group.includeAllNodes,
sortOrder: group.sortOrder,
members: [],
};
memberSelection.value = group.members.map((m) =>
m.kind === 'node' ? `node:${m.nodeId}` : m.kind === 'builtin' ? `builtin:${m.refName}` : `group:${m.refName}`
);
showForm.value = true;
}
async function submit() {
form.value.members = memberSelection.value.map((v) => {
const [kind, ...rest] = v.split(':');
const ref = rest.join(':');
return kind === 'node' ? { kind: 'node' as const, nodeId: ref } : { kind: kind as 'group' | 'builtin', refName: ref };
});
try {
if (editing.value) await store.update(editing.value.id, form.value);
else await store.create(form.value);
showForm.value = false;
message.success('已保存');
} catch (e: any) {
message.error(e.message);
}
}
function confirmDelete(group: GroupDto) {
dialog.warning({
title: '删除策略组',
content: `确认删除「${group.name}」?引用它的规则策略不会自动更新。`,
positiveText: '删除',
negativeText: '取消',
onPositiveClick: () => store.remove(group.id),
});
}
/** 排序:客户端订阅里的策略组顺序即此顺序 */
async function move(group: GroupDto, dir: -1 | 1) {
const ids = store.groups.map((g) => g.id);
const i = ids.indexOf(group.id);
const j = i + dir;
if (j < 0 || j >= ids.length) return;
[ids[i], ids[j]] = [ids[j], ids[i]];
await store.reorder(ids);
}
/** regex 组实时预览:当前节点里有哪些会被圈中 */
function matchedNodes(group: GroupDto) {
if (!group.filterRegex) return [];
try {
const re = new RegExp(group.filterRegex);
return nodesStore.nodes.filter((n) => re.test(n.name));
} catch {
return [];
}
}
function memberLabel(m: GroupDto['members'][number]): string {
if (m.kind === 'node') return nodesStore.nodes.find((n) => n.id === m.nodeId)?.name ?? '(已删除节点)';
return m.refName ?? '';
}
</script>
<template>
<div>
<div class="page-head">
<h1 class="display page-title">策略组</h1>
<NButton type="primary" @click="openCreate">添加策略组</NButton>
</div>
<p class="hint">顺序即客户端里策略组的排列顺序停用的组不会下发引用它的规则一并跳过</p>
<div class="group-grid">
<NCard v-for="(g, i) in store.groups" :key="g.id" size="small" class="group-card" :class="{ off: !g.enabled }">
<template #header>
<span class="group-order mono">{{ String(i + 1).padStart(2, '0') }}</span>
<span class="group-name">{{ g.name }}</span>
<NTag size="small" :bordered="false" style="margin-left: 8px">{{ g.type }}</NTag>
</template>
<template #header-extra>
<NSpace size="small" align="center">
<NButton size="tiny" quaternary :disabled="i === 0" @click="move(g, -1)"></NButton>
<NButton size="tiny" quaternary :disabled="i === store.groups.length - 1" @click="move(g, 1)"></NButton>
<NSwitch size="small" :value="g.enabled" @update:value="(v: boolean) => store.toggle(g.id, v)" />
<NButton size="tiny" quaternary @click="openEdit(g)">编辑</NButton>
<NButton v-if="g.source === 'custom'" size="tiny" quaternary type="error" @click="confirmDelete(g)">删除</NButton>
</NSpace>
</template>
<div v-if="g.includeAllNodes" class="group-line">
<span class="group-label">收纳</span>全部启用节点
</div>
<div v-if="g.filterRegex" class="group-line">
<span class="group-label">筛选</span>
<span class="mono regex">{{ g.filterRegex.length > 48 ? g.filterRegex.slice(0, 48) + '…' : g.filterRegex }}</span>
</div>
<div v-if="g.filterRegex" class="group-line group-line-block">
<div v-if="matchedNodes(g).length" class="matched-wrap">
<div class="matched-count"><span class="group-label">命中</span>{{ matchedNodes(g).length }} 个节点</div>
<div class="matched-list">
<div v-for="n in matchedNodes(g)" :key="n.id" class="matched-row" :title="n.name">
<EgressBadge :egress="nodeEgress(n)" compact />
<span class="matched-name">{{ nodeDisplayName(n) }}</span>
</div>
</div>
</div>
<span v-else class="muted"><span class="group-label">命中</span>当前没有节点名匹配</span>
</div>
<div v-if="g.members.length" class="group-line">
<span class="group-label">成员</span>
<span class="members">{{ g.members.map(memberLabel).join('、') }}</span>
</div>
</NCard>
</div>
<NModal
:show="showForm"
preset="card"
:title="editing ? `编辑策略组 · ${editing.name}` : '添加策略组'"
style="max-width: 560px"
@update:show="showForm = $event"
>
<NForm label-placement="left" label-width="96">
<NFormItem label="名称" required>
<NInput v-model:value="form.name" />
</NFormItem>
<NFormItem label="类型">
<NSelect
v-model:value="form.type"
:options="['select', 'url-test', 'fallback'].map((t) => ({ label: t, value: t }))"
/>
</NFormItem>
<NFormItem label="成员(有序)">
<NSelect v-model:value="memberSelection" multiple filterable :options="memberOptions" placeholder="选择节点、组或内置策略" />
</NFormItem>
<NFormItem label="收纳全部节点">
<NSwitch v-model:value="form.includeAllNodes" />
</NFormItem>
<NFormItem label="名称筛选正则">
<NInput v-model:value="form.filterRegex" placeholder="如 SG|Singapore配合收纳全部节点或成员组" class="mono" />
</NFormItem>
<template v-if="form.type !== 'select'">
<NFormItem label="测速 URL">
<NInput v-model:value="form.testUrl" placeholder="http://cp.cloudflare.com/generate_204" class="mono" />
</NFormItem>
<NFormItem label="间隔(秒)">
<NInputNumber v-model:value="form.interval" :min="10" style="width: 100%" />
</NFormItem>
<NFormItem label="容差ms">
<NInputNumber v-model:value="form.tolerance" :min="0" style="width: 100%" />
</NFormItem>
</template>
</NForm>
<template #footer>
<NSpace justify="end">
<NButton @click="showForm = false">取消</NButton>
<NButton type="primary" @click="submit">保存</NButton>
</NSpace>
</template>
</NModal>
</div>
</template>
<style scoped>
.page-head {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 20px;
}
.page-title {
font-size: 20px;
margin: 0;
}
.hint {
color: var(--muted);
font-size: 12px;
margin: -12px 0 16px;
}
/* 同行卡片等宽等高 */
.group-grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
gap: 12px;
}
.group-card.off {
opacity: 0.55;
}
.group-order {
font-size: 11px;
color: var(--muted);
margin-right: 10px;
}
.group-name {
font-weight: 600;
}
.group-line {
font-size: 12px;
margin-bottom: 6px;
line-height: 1.7;
display: flex;
align-items: baseline;
}
.group-label {
color: var(--muted);
margin-right: 10px;
flex-shrink: 0;
}
.regex {
color: var(--warp);
font-size: 11px;
word-break: break-all;
}
/* 命中清单:一行一个,节点名与出口标签左右对齐 */
.matched-wrap {
flex: 1;
min-width: 0;
}
/* 命中区整块换行,让清单占满卡片宽度 */
.group-line-block {
display: block;
}
.matched-count {
color: var(--muted);
margin-bottom: 3px;
}
/* 全部铺开不滚动;两列等宽,无左缩进 */
.matched-list {
display: grid;
grid-template-columns: repeat(2, minmax(0, 1fr));
gap: 0 12px;
}
.matched-row {
display: flex;
align-items: center;
gap: 7px;
padding: 2.5px 0;
min-width: 0;
}
.matched-name {
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
min-width: 0;
}
.members {
color: var(--text);
}
.muted {
color: var(--muted);
}
</style>

300
web/src/pages/NodesPage.vue Normal file
View File

@@ -0,0 +1,300 @@
<script setup lang="ts">
import { computed, h, onMounted, ref } from 'vue';
import {
NButton,
NDataTable,
NEmpty,
NSpace,
NSwitch,
useDialog,
useMessage,
type DataTableColumns,
} from 'naive-ui';
import { nodeEgress, type NodeDto, type NodeInput, type Protocol } from '@proxy-station/shared';
import { useNodesStore } from '../stores/nodes';
import { stationLabel, stationOf } from '../components/stations';
import EgressBadge from '../components/EgressBadge.vue';
import ProtoDot from '../components/ProtoDot.vue';
import NodeFormModal from '../components/NodeFormModal.vue';
import ImportModal from '../components/ImportModal.vue';
import { copyText } from '../utils/clipboard';
import { nodeDisplayName } from '../utils/nodeName';
const store = useNodesStore();
const message = useMessage();
const dialog = useDialog();
const showForm = ref(false);
const showImport = ref(false);
const editing = ref<NodeDto | null>(null);
onMounted(() => store.fetchAll());
const PROTOCOL_ORDER: Protocol[] = ['vmess', 'trojan', 'shadowsocks', 'hysteria2'];
const EGRESS_ORDER = { direct: 0, warp: 1, unknown: 2 };
/** 站点展示域名去掉子域首段cc.sg.example.com → sg.example.com */
function baseDomain(server: string): string {
const parts = server.split('.');
return parts.length >= 4 ? parts.slice(1).join('.') : server;
}
/** 按站点分段,段内先按协议、再按出口排序 */
const sections = computed(() => {
const byStation = new Map<string, NodeDto[]>();
for (const n of store.nodes) {
const key = stationOf(n);
if (!byStation.has(key)) byStation.set(key, []);
byStation.get(key)!.push(n);
}
return [...byStation.entries()]
.sort(([a], [b]) => a.localeCompare(b))
.map(([code, list]) => ({
code,
label: stationLabel(code),
domain: baseDomain(list[0].server),
nodes: [...list].sort(
(a, b) =>
PROTOCOL_ORDER.indexOf(a.protocol) - PROTOCOL_ORDER.indexOf(b.protocol) ||
EGRESS_ORDER[nodeEgress(a)] - EGRESS_ORDER[nodeEgress(b)]
),
}));
});
function openCreate() {
editing.value = null;
showForm.value = true;
}
function openEdit(node: NodeDto) {
editing.value = node;
showForm.value = true;
}
async function handleSubmit(input: NodeInput, id?: string) {
try {
if (id) await store.update(id, input);
else await store.create(input);
showForm.value = false;
message.success(id ? '已保存' : '已添加');
} catch (e: any) {
message.error(e.message);
}
}
function handleDelete(id: string) {
const node = store.nodes.find((n) => n.id === id);
dialog.warning({
title: '删除节点',
content: `确认删除「${node?.name}」?引用它的策略组成员会一并移除。`,
positiveText: '删除',
negativeText: '取消',
onPositiveClick: async () => {
await store.remove(id);
showForm.value = false;
message.success('已删除');
},
});
}
async function copyUri(node: NodeDto) {
try {
const uri = await store.exportUri(node.id);
if (await copyText(uri)) message.success('分享链接已复制');
else message.warning('浏览器阻止了自动复制,请改用 HTTPS 或 localhost 访问');
} catch (e: any) {
message.error(e.message);
}
}
/** 用分享链接唤起本机已安装的客户端,把这条线路导进去 */
async function connect(node: NodeDto) {
try {
const uri = await store.exportUri(node.id);
window.location.href = uri;
} catch (e: any) {
message.error(e.message);
}
}
const columns = computed<DataTableColumns<NodeDto>>(() => [
{
title: '名称',
key: 'name',
ellipsis: { tooltip: true },
// 出口词由「出口」列承担,这里隐去避免重复
render: (row) => nodeDisplayName(row),
},
{
title: '协议',
key: 'protocol',
width: 148,
render: (row) =>
h('span', { class: 'proto-cell' }, [
h(ProtoDot, { protocol: row.protocol }),
h('span', {}, row.protocol),
]),
},
{
title: '出口',
key: 'egress',
width: 92,
render: (row) => h(EgressBadge, { egress: nodeEgress(row) }),
},
{
title: '服务器',
key: 'server',
ellipsis: { tooltip: true },
render: (row) => h('span', { class: 'mono cell-mono' }, `${row.server}:${row.port}`),
},
{
title: '路径',
key: 'wsPath',
width: 108,
render: (row) => h('span', { class: 'mono cell-mono' }, row.wsPath ?? '—'),
},
{
title: '启用',
key: 'enabled',
width: 72,
render: (row) =>
h(NSwitch, {
size: 'small',
value: row.enabled,
onUpdateValue: (v: boolean) => store.toggle(row.id, v),
}),
},
{
title: '',
key: 'actions',
width: 176,
render: (row) =>
h(NSpace, { size: 2, wrap: false }, () => [
h(NButton, { size: 'tiny', quaternary: true, onClick: () => copyUri(row) }, () => '复制'),
h(NButton, { size: 'tiny', quaternary: true, onClick: () => connect(row) }, () => '连接'),
h(NButton, { size: 'tiny', quaternary: true, onClick: () => openEdit(row) }, () => '编辑'),
]),
},
]);
</script>
<template>
<div>
<div class="page-head">
<h1 class="display page-title">节点</h1>
<NSpace>
<NButton ghost @click="showImport = true">批量导入</NButton>
<NButton type="primary" @click="openCreate">添加节点</NButton>
</NSpace>
</div>
<NEmpty
v-if="!store.loading && store.nodes.length === 0"
description="还没有节点。粘贴分享链接批量导入,或手动添加。"
style="margin-top: 80px"
>
<template #extra>
<NButton type="primary" @click="showImport = true">批量导入</NButton>
</template>
</NEmpty>
<section v-for="st in sections" :key="st.code" class="station">
<header class="station-head">
<span class="station-name display">{{ st.label }}</span>
<span class="station-domain mono">{{ st.domain }}</span>
<span class="station-count">{{ st.nodes.length }} 条线路</span>
</header>
<div class="strip"><i class="strip-direct" /><i class="strip-warp" /></div>
<NDataTable
:columns="columns"
:data="st.nodes"
:bordered="false"
:single-line="false"
size="small"
:row-key="(n: NodeDto) => n.id"
/>
</section>
<NodeFormModal v-model:show="showForm" :node="editing" @submit="handleSubmit" @delete="handleDelete" />
<ImportModal v-model:show="showImport" />
</div>
</template>
<style scoped>
.page-head {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 20px;
flex-wrap: wrap;
gap: 12px;
}
.page-title {
font-size: 20px;
margin: 0;
}
.station + .station {
margin-top: 26px;
}
.station-head {
display: flex;
align-items: baseline;
gap: 12px;
padding: 0 2px 9px;
}
.station-name {
font-size: 17px;
white-space: nowrap;
}
.station-domain {
font-size: 12px;
color: var(--muted);
flex: 1;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.station-count {
font-size: 12px;
color: var(--muted);
white-space: nowrap;
}
/* 站牌双色条:琥珀 = 直连,青 = WARP */
.strip {
display: flex;
height: 3px;
border-radius: 2px;
overflow: hidden;
margin-bottom: 8px;
}
.strip i {
flex: 1;
}
.strip-direct {
background: var(--direct);
}
.strip-warp {
background: var(--warp);
}
:deep(.proto-cell) {
display: inline-flex;
align-items: center;
gap: 8px;
white-space: nowrap;
}
:deep(.cell-mono) {
font-size: 12px;
}
</style>

266
web/src/pages/RulesPage.vue Normal file
View File

@@ -0,0 +1,266 @@
<script setup lang="ts">
import { computed, h, onMounted, ref } from 'vue';
import {
NButton,
NDataTable,
NModal,
NForm,
NFormItem,
NInput,
NSelect,
NSpace,
NSwitch,
NTag,
useDialog,
useMessage,
type DataTableColumns,
} from 'naive-ui';
import { RULE_TYPES, type RuleDto, type RuleInput } from '@proxy-station/shared';
import { useRulesStore } from '../stores/rules';
import { useGroupsStore } from '../stores/groups';
import RulesetPreviewDrawer from '../components/RulesetPreviewDrawer.vue';
const store = useRulesStore();
const groupsStore = useGroupsStore();
const message = useMessage();
const dialog = useDialog();
onMounted(() => {
store.fetchAll();
groupsStore.fetchAll();
});
const showForm = ref(false);
const editing = ref<RuleDto | null>(null);
const previewRule = ref<RuleDto | null>(null);
const showPreview = ref(false);
function openPreview(rule: RuleDto) {
previewRule.value = rule;
showPreview.value = true;
}
const form = ref<RuleInput>({ type: 'DOMAIN-SUFFIX', value: '', policy: 'Proxy', params: [], enabled: true });
const policyOptions = computed(() => [
...['DIRECT', 'REJECT', 'REJECT-DROP', 'REJECT-NO-DROP'].map((p) => ({ label: p, value: p })),
...groupsStore.groups.map((g) => ({ label: g.name, value: g.name })),
]);
const typeOptions = RULE_TYPES.filter((t) => t !== 'RULE-SET' && t !== 'DOMAIN-SET' && t !== 'FINAL').map((t) => ({
label: t,
value: t,
}));
function openCreate() {
editing.value = null;
form.value = { type: 'DOMAIN-SUFFIX', value: '', policy: 'Proxy', params: [], enabled: true };
showForm.value = true;
}
function openEdit(rule: RuleDto) {
editing.value = rule;
form.value = {
type: rule.type as RuleInput['type'],
value: rule.value,
policy: rule.policy,
params: rule.params,
enabled: rule.enabled,
};
showForm.value = true;
}
async function submit() {
try {
if (editing.value) await store.update(editing.value.id, form.value);
else await store.create(form.value);
showForm.value = false;
message.success('已保存');
} catch (e: any) {
message.error(e.message);
}
}
function confirmDelete(rule: RuleDto) {
dialog.warning({
title: '删除规则',
content: `确认删除这条 ${rule.type} 规则?`,
positiveText: '删除',
negativeText: '取消',
onPositiveClick: () => store.remove(rule.id),
});
}
function confirmReset() {
dialog.warning({
title: '重置为模板规则',
content: '模板来源的规则将恢复为初始状态,你添加的自定义规则会保留。继续?',
positiveText: '重置',
negativeText: '取消',
onPositiveClick: async () => {
await store.reset();
message.success('已重置');
},
});
}
async function move(rule: RuleDto, dir: -1 | 1) {
const ids = store.rules.map((r) => r.id);
const i = ids.indexOf(rule.id);
const j = i + dir;
if (j < 0 || j >= ids.length) return;
[ids[i], ids[j]] = [ids[j], ids[i]];
await store.reorder(ids);
}
async function changePolicy(rule: RuleDto, policy: string) {
await store.update(rule.id, {
type: rule.type as RuleInput['type'],
value: rule.value,
policy,
params: rule.params,
enabled: rule.enabled,
});
}
const columns = computed<DataTableColumns<RuleDto>>(() => [
{ title: '#', key: 'seq', width: 56, render: (_row, i) => h('span', { class: 'mono', style: 'color:var(--muted);font-size:12px' }, String(i + 1)) },
{
title: '类型',
key: 'type',
width: 130,
render: (row) =>
h(
NTag,
{ size: 'small', bordered: false, type: row.type === 'RULE-SET' || row.type === 'DOMAIN-SET' ? 'info' : 'default' },
() => row.type
),
},
{
title: '匹配值',
key: 'value',
ellipsis: { tooltip: true },
render: (row) =>
row.rulesetName
? h('span', { style: 'cursor:pointer', onClick: () => openPreview(row), title: '点击预览规则集内容' }, [
h('span', { style: 'text-decoration:underline dotted var(--muted)' }, row.rulesetName),
h('span', { class: 'mono', style: 'color:var(--muted);font-size:11px;margin-left:8px' }, row.rulesetUrl ?? ''),
])
: h('span', { class: 'mono', style: 'font-size:12px' }, row.value ?? '—'),
},
{
title: '策略',
key: 'policy',
width: 170,
render: (row) =>
h(NSelect, {
size: 'small',
value: row.policy,
options: policyOptions.value,
consistentMenuWidth: false,
onUpdateValue: (v: string) => changePolicy(row, v),
}),
},
{
title: '来源',
key: 'source',
width: 76,
render: (row) => h('span', { style: 'color:var(--muted);font-size:12px' }, row.source === 'template' ? '模板' : '自定义'),
},
{
title: '启用',
key: 'enabled',
width: 70,
render: (row) => h(NSwitch, { size: 'small', value: row.enabled, onUpdateValue: (v: boolean) => store.toggle(row.id, v) }),
},
{
title: '',
key: 'actions',
width: 170,
render: (row, i) =>
h(NSpace, { size: 2 }, () => [
h(NButton, { size: 'tiny', quaternary: true, disabled: i === 0, onClick: () => move(row, -1) }, () => '↑'),
h(NButton, { size: 'tiny', quaternary: true, disabled: i === store.rules.length - 1, onClick: () => move(row, 1) }, () => '↓'),
...(row.type !== 'RULE-SET' && row.type !== 'DOMAIN-SET' && row.type !== 'FINAL'
? [h(NButton, { size: 'tiny', quaternary: true, onClick: () => openEdit(row) }, () => '编辑')]
: []),
...(row.source === 'custom'
? [h(NButton, { size: 'tiny', quaternary: true, type: 'error', onClick: () => confirmDelete(row) }, () => '删除')]
: []),
]),
},
]);
</script>
<template>
<div>
<div class="page-head">
<h1 class="display page-title">规则</h1>
<NSpace>
<NButton ghost @click="confirmReset">重置为模板</NButton>
<NButton type="primary" @click="openCreate">添加规则</NButton>
</NSpace>
</div>
<p class="hint">规则自上而下匹配RULE-SETDOMAIN-SET 引用外部规则集点击名称可预览内容末尾 FINAL 是兜底策略</p>
<NDataTable
:columns="columns"
:data="store.rules"
:loading="store.loading"
:bordered="false"
size="small"
:row-key="(r: RuleDto) => r.id"
:max-height="640"
virtual-scroll
/>
<RulesetPreviewDrawer v-model:show="showPreview" :rule="previewRule" />
<NModal
:show="showForm"
preset="card"
:title="editing ? '编辑规则' : '添加自定义规则'"
style="max-width: 480px"
@update:show="showForm = $event"
>
<NForm label-placement="left" label-width="72">
<NFormItem label="类型">
<NSelect v-model:value="form.type" :options="typeOptions" />
</NFormItem>
<NFormItem label="匹配值">
<NInput v-model:value="form.value" placeholder=" example.com / 1.2.3.0/24" class="mono" />
</NFormItem>
<NFormItem label="策略">
<NSelect v-model:value="form.policy" :options="policyOptions" filterable />
</NFormItem>
</NForm>
<template #footer>
<NSpace justify="end">
<NButton @click="showForm = false">取消</NButton>
<NButton type="primary" @click="submit">保存</NButton>
</NSpace>
</template>
</NModal>
</div>
</template>
<style scoped>
.page-head {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 8px;
flex-wrap: wrap;
gap: 12px;
}
.page-title {
font-size: 20px;
margin: 0;
}
.hint {
color: var(--muted);
font-size: 12px;
margin: 0 0 16px;
}
</style>

View File

@@ -0,0 +1,92 @@
<script setup lang="ts">
import { onMounted, ref, watch } from 'vue';
import { NButton, NCard, NInput, NSpace, NTabPane, NTabs, useMessage } from 'naive-ui';
import { getAdminToken, setAdminToken } from '../api/client';
import { useSubscriptionsStore } from '../stores/subscriptions';
const store = useSubscriptionsStore();
const message = useMessage();
const sections = ref<Record<string, string>>({});
const adminToken = ref(getAdminToken());
const activeSection = ref('General');
onMounted(async () => {
await store.fetchAll();
});
watch(
() => store.settings,
(s) => {
if (!s) return;
sections.value = { ...s.surgeSections };
},
{ immediate: true }
);
async function saveSections() {
await store.saveSettings({ surgeSections: sections.value });
message.success('已保存');
}
function saveAdminToken() {
setAdminToken(adminToken.value.trim());
message.success(adminToken.value.trim() ? '已保存到本浏览器' : '已清除');
}
</script>
<template>
<div>
<h1 class="display page-title">设置</h1>
<NCard title="管理鉴权" size="small" class="block">
<p class="hint">
服务端设置了 ADMIN_TOKEN 环境变量时管理接口需要携带同样的 token此处保存的值仅存在本浏览器 localStorage
</p>
<NSpace>
<NInput v-model:value="adminToken" type="password" show-password-on="click" placeholder="ADMIN_TOKEN" class="mono" style="width: 320px" />
<NButton @click="saveAdminToken">保存</NButton>
</NSpace>
</NCard>
<NCard title="Surge 原文段落" size="small" class="block">
<p class="hint">
这些段落按原文透传进 Surge 配置[General][MITM] 此处直接编辑文本ShadowRocketClashMeta 不使用这些内容
</p>
<NTabs v-model:value="activeSection" type="line" size="small">
<NTabPane v-for="(content, name) in sections" :key="name" :name="String(name)" :tab="String(name)">
<NInput
v-model:value="sections[String(name)]"
type="textarea"
:rows="16"
class="mono section-editor"
/>
</NTabPane>
</NTabs>
<NButton type="primary" style="margin-top: 12px" @click="saveSections">保存段落</NButton>
</NCard>
</div>
</template>
<style scoped>
.page-title {
font-size: 20px;
margin: 0 0 20px;
}
.block {
margin-bottom: 16px;
max-width: 860px;
}
.hint {
color: var(--muted);
font-size: 12px;
margin: 0 0 12px;
}
.section-editor :deep(textarea) {
font-family: var(--font-mono) !important;
font-size: 12px;
}
</style>

View File

@@ -0,0 +1,404 @@
<script setup lang="ts">
import { nextTick, onMounted, ref, watch } from 'vue';
import { NButton, NPopover, NSpace, NSwitch, useDialog, useMessage } from 'naive-ui';
import { SHADOWROCKET_SUB_NAME, type TokenDto } from '@proxy-station/shared';
import { useSubscriptionsStore } from '../stores/subscriptions';
import { useNodesStore } from '../stores/nodes';
import { copyText } from '../utils/clipboard';
import TokenFormModal from '../components/TokenFormModal.vue';
const store = useSubscriptionsStore();
const nodesStore = useNodesStore();
const message = useMessage();
const dialog = useDialog();
onMounted(() => {
store.fetchAll();
nodesStore.fetchAll();
});
const showForm = ref(false);
const editing = ref<TokenDto | null>(null);
function openCreate() {
editing.value = null;
showForm.value = true;
}
function openEdit(token: TokenDto) {
editing.value = token;
showForm.value = true;
}
async function handleSubmit(payload: { name: string; nodeIds: string[] }, id?: string) {
try {
if (id) await store.updateToken(id, payload);
else await store.createToken(payload);
showForm.value = false;
message.success(id ? '已保存' : '订阅已创建');
} catch (e: any) {
message.error(e.message);
}
}
function confirmDelete(token: TokenDto) {
dialog.warning({
title: '删除订阅',
content: `删除「${token.name}」后,使用该 URL 的客户端将无法再更新配置。`,
positiveText: '删除',
negativeText: '取消',
onPositiveClick: () => store.removeToken(token.id),
});
}
/** 订阅完整 URL当前页面 origin + 后端返回的路径 */
function fullUrl(path: string): string {
return `${window.location.origin}${path}`;
}
/** 节点范围文案:空数组表示不限制 */
function scopeLabel(t: TokenDto): string {
const total = nodesStore.nodes.filter((n) => n.enabled).length;
return t.nodeIds.length === 0 ? `全部节点 · ${total}` : `${t.nodeIds.length} / ${total} 节点`;
}
async function copy(text: string) {
if (await copyText(text)) {
message.success('已复制');
} else {
manualCopyText.value = text;
message.warning('浏览器阻止了自动复制,请手动复制下方链接');
}
}
/** 自动复制失败时的兜底展示 */
const manualCopyText = ref('');
const manualCopyInput = ref<HTMLInputElement | null>(null);
watch(manualCopyText, async (v) => {
if (!v) return;
await nextTick();
manualCopyInput.value?.focus();
manualCopyInput.value?.select();
});
</script>
<template>
<div>
<div class="page-head">
<h1 class="display page-title">订阅</h1>
<NButton type="primary" @click="openCreate">新建订阅</NButton>
</div>
<div class="token-grid">
<article v-for="t in store.tokens" :key="t.id" class="token" :class="{ off: !t.enabled }">
<header class="token-head">
<div class="token-title">
<span class="token-name">{{ t.name }}</span>
<span class="token-scope">{{ scopeLabel(t) }}</span>
</div>
<NSpace size="small" align="center">
<NSwitch size="small" :value="t.enabled" @update:value="(v: boolean) => store.toggleToken(t.id, v)" />
<NButton size="tiny" quaternary @click="openEdit(t)">编辑</NButton>
<NButton size="tiny" quaternary type="error" @click="confirmDelete(t)">删除</NButton>
</NSpace>
</header>
<div class="rows">
<div class="row">
<span class="row-client">Surge<span class="row-os">macOS</span></span>
<code class="mono row-url">{{ fullUrl(t.urls.surge) }}</code>
<NButton size="tiny" quaternary @click="copy(fullUrl(t.urls.surge))">复制</NButton>
</div>
<div class="row">
<span class="row-client">
ShadowRocket<span class="row-os">iOS</span>
<NPopover trigger="hover" placement="bottom-start" style="max-width: 320px">
<template #trigger>
<button class="info" aria-label="导入说明">?</button>
</template>
<p class="pop-title">分两步导入</p>
<p class="pop-body">
App 订阅里添加节点链接并把订阅命名为
<code class="mono pop-code">{{ SHADOWROCKET_SUB_NAME }}</code>
配置文件按这个名字引用节点名字必须完全一致
</p>
<p class="pop-body"> 配置里添加规则链接并启用</p>
</NPopover>
</span>
<div class="row-split">
<div class="split-line">
<span class="split-tag">节点</span>
<code class="mono row-url">{{ fullUrl(t.urls.shadowrocket) }}</code>
<NButton size="tiny" quaternary @click="copy(fullUrl(t.urls.shadowrocket))">复制</NButton>
</div>
<div class="split-line">
<span class="split-tag">规则</span>
<code class="mono row-url">{{ fullUrl(t.urls.shadowrocketConf) }}</code>
<NButton size="tiny" quaternary @click="copy(fullUrl(t.urls.shadowrocketConf))">复制</NButton>
</div>
</div>
</div>
<div class="row">
<span class="row-client">ClashMeta<span class="row-os">Android</span></span>
<code class="mono row-url">{{ fullUrl(t.urls.clash) }}</code>
<NButton size="tiny" quaternary @click="copy(fullUrl(t.urls.clash))">复制</NButton>
</div>
</div>
<footer class="token-foot">
最近访问 {{ t.lastAccessAt ? new Date(t.lastAccessAt).toLocaleString() : '从未' }} · {{ t.accessCount }}
</footer>
</article>
</div>
<!-- 自动复制失败时的兜底全选好的输入框长按或 Cmd+C 即可 -->
<div v-if="manualCopyText" class="manual-copy">
<span class="manual-copy-label">手动复制这条链接</span>
<input
ref="manualCopyInput"
class="mono manual-copy-input"
:value="manualCopyText"
readonly
@focus="($event.target as HTMLInputElement).select()"
/>
<NButton size="tiny" quaternary @click="manualCopyText = ''">关闭</NButton>
</div>
<TokenFormModal v-model:show="showForm" :token="editing" :nodes="nodesStore.nodes" @submit="handleSubmit" />
</div>
</template>
<style scoped>
.page-head {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 20px;
}
.page-title {
font-size: 20px;
margin: 0;
}
.token-grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(560px, 1fr));
gap: 14px;
}
.token {
background: var(--panel);
border: 1px solid var(--line);
border-radius: 10px;
overflow: hidden;
}
.token.off {
opacity: 0.55;
}
.token-head {
display: flex;
align-items: center;
justify-content: space-between;
gap: 12px;
padding: 13px 18px;
border-bottom: 1px solid var(--line-soft);
}
.token-title {
display: flex;
align-items: baseline;
gap: 10px;
min-width: 0;
}
.token-name {
font-size: 15px;
font-weight: 700;
}
/* 节点范围徽标 */
.token-scope {
font-size: 11px;
color: var(--warp);
background: var(--warp-dim);
padding: 2px 8px;
border-radius: 999px;
white-space: nowrap;
}
.rows {
padding: 6px 18px 10px;
}
.row {
display: flex;
align-items: center;
gap: 12px;
padding: 8px 0;
}
.row + .row {
border-top: 1px solid var(--line-soft);
}
.row-client {
width: 128px;
flex-shrink: 0;
font-size: 13px;
font-weight: 600;
display: flex;
align-items: center;
gap: 6px;
}
.row-os {
font-size: 10px;
font-weight: 500;
color: var(--muted);
}
.info {
appearance: none;
border: 1px solid var(--line);
background: transparent;
color: var(--muted);
width: 16px;
height: 16px;
flex: 0 0 16px; /* 不参与 flex 收缩,否则会被压成椭圆 */
box-sizing: border-box;
border-radius: 50%;
font-size: 10px;
line-height: 1;
cursor: help;
padding: 0;
display: inline-flex;
align-items: center;
justify-content: center;
}
.info:hover {
color: var(--text);
border-color: var(--muted);
}
.row-url {
flex: 1;
min-width: 0;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
font-size: 11px;
color: var(--text);
background: var(--bg);
padding: 5px 9px;
border-radius: 6px;
}
/* ShadowRocket 的两条链接 */
.row-split {
flex: 1;
min-width: 0;
display: flex;
flex-direction: column;
gap: 5px;
}
.split-line {
display: flex;
align-items: center;
gap: 8px;
}
.split-tag {
font-size: 11px;
color: var(--muted);
width: 26px;
flex-shrink: 0;
}
.token-foot {
padding: 9px 18px;
border-top: 1px solid var(--line-soft);
font-size: 11px;
color: var(--muted);
background: var(--bg);
}
.pop-title {
margin: 0 0 6px;
font-size: 12.5px;
font-weight: 600;
}
.pop-body {
margin: 0 0 6px;
font-size: 12px;
line-height: 1.7;
color: var(--muted);
}
.pop-code {
color: var(--text);
background: var(--bg);
padding: 1px 5px;
border-radius: 4px;
font-size: 11px;
}
.manual-copy {
display: flex;
align-items: center;
gap: 10px;
margin-top: 14px;
padding: 10px 14px;
background: var(--direct-dim);
border: 1px solid var(--direct);
border-radius: 10px;
}
.manual-copy-label {
font-size: 12.5px;
color: var(--direct);
white-space: nowrap;
}
.manual-copy-input {
flex: 1;
min-width: 0;
font-size: 12px;
padding: 6px 10px;
border: 1px solid var(--line);
border-radius: 6px;
background: var(--panel);
color: var(--text);
}
@media (max-width: 720px) {
.token-grid {
grid-template-columns: 1fr;
}
.row {
flex-direction: column;
align-items: stretch;
gap: 6px;
}
.row-client {
width: auto;
}
}
</style>

13
web/src/router.ts Normal file
View File

@@ -0,0 +1,13 @@
import { createRouter, createWebHistory } from 'vue-router';
export const router = createRouter({
history: createWebHistory(),
routes: [
{ path: '/', redirect: '/nodes' },
{ path: '/nodes', component: () => import('./pages/NodesPage.vue'), meta: { title: '节点' } },
{ path: '/groups', component: () => import('./pages/GroupsPage.vue'), meta: { title: '策略组' } },
{ path: '/rules', component: () => import('./pages/RulesPage.vue'), meta: { title: '规则' } },
{ path: '/subscriptions', component: () => import('./pages/SubscriptionsPage.vue'), meta: { title: '订阅' } },
{ path: '/settings', component: () => import('./pages/SettingsPage.vue'), meta: { title: '设置' } },
],
});

41
web/src/stores/groups.ts Normal file
View File

@@ -0,0 +1,41 @@
import { defineStore } from 'pinia';
import type { GroupDto, GroupInput } from '@proxy-station/shared';
import { api } from '../api/client';
export const useGroupsStore = defineStore('groups', {
state: () => ({
groups: [] as GroupDto[],
loading: false,
}),
actions: {
async fetchAll() {
this.loading = true;
try {
this.groups = await api.get<GroupDto[]>('/api/groups');
} finally {
this.loading = false;
}
},
async create(input: GroupInput) {
await api.post('/api/groups', input);
await this.fetchAll();
},
async update(id: string, input: GroupInput) {
await api.put(`/api/groups/${id}`, input);
await this.fetchAll();
},
async remove(id: string) {
await api.delete(`/api/groups/${id}`);
this.groups = this.groups.filter((g) => g.id !== id);
},
async toggle(id: string, enabled: boolean) {
await api.patch(`/api/groups/${id}/enabled`, { enabled });
const group = this.groups.find((g) => g.id === id);
if (group) group.enabled = enabled;
},
async reorder(ids: string[]) {
await api.put('/api/groups/reorder', { ids });
await this.fetchAll();
},
},
});

53
web/src/stores/nodes.ts Normal file
View File

@@ -0,0 +1,53 @@
import { defineStore } from 'pinia';
import type { NodeDto, NodeInput } from '@proxy-station/shared';
import { api } from '../api/client';
export interface ImportResult {
committed: boolean;
total: number;
succeeded: number;
items: { ok: boolean; uri: string; error?: string; node?: Partial<NodeDto> & { name: string } }[];
}
export const useNodesStore = defineStore('nodes', {
state: () => ({
nodes: [] as NodeDto[],
loading: false,
}),
actions: {
async fetchAll() {
this.loading = true;
try {
this.nodes = await api.get<NodeDto[]>('/api/nodes');
} finally {
this.loading = false;
}
},
async create(input: NodeInput) {
await api.post('/api/nodes', input);
await this.fetchAll();
},
async update(id: string, input: NodeInput) {
await api.put(`/api/nodes/${id}`, input);
await this.fetchAll();
},
async remove(id: string) {
await api.delete(`/api/nodes/${id}`);
this.nodes = this.nodes.filter((n) => n.id !== id);
},
async toggle(id: string, enabled: boolean) {
await api.patch(`/api/nodes/${id}/enabled`, { enabled });
const node = this.nodes.find((n) => n.id === id);
if (node) node.enabled = enabled;
},
async importText(text: string, commit: boolean): Promise<ImportResult> {
const result = await api.post<ImportResult>('/api/nodes/import', { text, commit });
if (commit) await this.fetchAll();
return result;
},
async exportUri(id: string): Promise<string> {
const { uri } = await api.get<{ uri: string }>(`/api/nodes/${id}/uri`);
return uri;
},
},
});

49
web/src/stores/rules.ts Normal file
View File

@@ -0,0 +1,49 @@
import { defineStore } from 'pinia';
import type { RuleDto, RuleInput, RulesetDto } from '@proxy-station/shared';
import { api } from '../api/client';
export const useRulesStore = defineStore('rules', {
state: () => ({
rules: [] as RuleDto[],
rulesets: [] as RulesetDto[],
loading: false,
}),
actions: {
async fetchAll() {
this.loading = true;
try {
[this.rules, this.rulesets] = await Promise.all([
api.get<RuleDto[]>('/api/rules'),
api.get<RulesetDto[]>('/api/rulesets'),
]);
} finally {
this.loading = false;
}
},
async create(input: RuleInput) {
await api.post('/api/rules', input);
await this.fetchAll();
},
async update(id: string, input: RuleInput) {
await api.put(`/api/rules/${id}`, input);
await this.fetchAll();
},
async remove(id: string) {
await api.delete(`/api/rules/${id}`);
this.rules = this.rules.filter((r) => r.id !== id);
},
async toggle(id: string, enabled: boolean) {
await api.patch(`/api/rules/${id}/enabled`, { enabled });
const rule = this.rules.find((r) => r.id === id);
if (rule) rule.enabled = enabled;
},
async reorder(ids: string[]) {
await api.put('/api/rules/reorder', { ids });
await this.fetchAll();
},
async reset() {
await api.post('/api/rules/reset');
await this.fetchAll();
},
},
});

View File

@@ -0,0 +1,49 @@
import { defineStore } from 'pinia';
import type { TokenDto } from '@proxy-station/shared';
import { api } from '../api/client';
export interface SettingsData {
surgeSections: Record<string, string>;
}
export const useSubscriptionsStore = defineStore('subscriptions', {
state: () => ({
tokens: [] as TokenDto[],
settings: null as SettingsData | null,
loading: false,
}),
actions: {
async fetchAll() {
this.loading = true;
try {
[this.tokens, this.settings] = await Promise.all([
api.get<TokenDto[]>('/api/tokens'),
api.get<SettingsData>('/api/settings'),
]);
} finally {
this.loading = false;
}
},
async createToken(payload: { name: string; nodeIds: string[] }) {
await api.post('/api/tokens', payload);
await this.fetchAll();
},
async updateToken(id: string, payload: { name: string; nodeIds: string[] }) {
await api.put(`/api/tokens/${id}`, payload);
await this.fetchAll();
},
async removeToken(id: string) {
await api.delete(`/api/tokens/${id}`);
this.tokens = this.tokens.filter((t) => t.id !== id);
},
async toggleToken(id: string, enabled: boolean) {
await api.patch(`/api/tokens/${id}/enabled`, { enabled });
const token = this.tokens.find((t) => t.id === id);
if (token) token.enabled = enabled;
},
async saveSettings(patch: Partial<SettingsData>) {
await api.put('/api/settings', patch);
await this.fetchAll();
},
},
});

98
web/src/styles/tokens.css Normal file
View File

@@ -0,0 +1,98 @@
/* 站牌导视(轨道交通导视系统):白底粗黑、线路色圆标、站名牌。
颜色语义:琥珀 = direct 直连出口,青 = WARP 净出口;协议各有线路色。 */
:root {
--bg: #f7f7f4;
--panel: #ffffff;
--panel-raised: #ffffff;
--line: #e2e2dd;
--line-soft: #ecece8;
--direct: #b26a00;
--direct-dim: #faf1e2;
--warp: #007a72;
--warp-dim: #e2f2f0;
--text: #212529;
--muted: #6e7073;
--danger: #c0392b;
/* 重点色:深藏青(站名牌、主按钮、导航下划线),比纯黑柔和 */
--ink: #2b3f5c;
--ink-hover: #24354e;
/* 协议线路色(导视系统的线路标识) */
--proto-vmess: #275ad1;
--proto-trojan: #8348c7;
--proto-shadowsocks: #2f7d3b;
--proto-hysteria2: #c23d5d;
--font-body: -apple-system, 'PingFang SC', 'Helvetica Neue', 'Segoe UI', sans-serif;
--font-mono: 'IBM Plex Mono', ui-monospace, 'SF Mono', Menlo, monospace;
}
html,
body {
margin: 0;
background: var(--bg);
color: var(--text);
font-family: var(--font-body);
-webkit-font-smoothing: antialiased;
}
/* 页面大标题:导视级粗黑 */
.display {
font-weight: 800;
letter-spacing: -0.01em;
}
.mono {
font-family: var(--font-mono);
}
/* 导视小标签:加粗 + 字距 */
.label {
font-size: 11px;
font-weight: 700;
letter-spacing: 0.1em;
color: var(--muted);
}
.egress-direct {
color: var(--direct);
}
.egress-warp {
color: var(--warp);
}
/* 语义圆点(图例、标签内) */
.lamp {
display: inline-block;
width: 7px;
height: 7px;
border-radius: 50%;
flex-shrink: 0;
}
.lamp-direct {
background: var(--direct);
}
.lamp-warp {
background: var(--warp);
}
.lamp-off {
background: #b9bab5;
}
:focus-visible {
outline: 2px solid var(--text);
outline-offset: 2px;
}
@media (prefers-reduced-motion: reduce) {
*,
*::before,
*::after {
animation-duration: 0.01ms !important;
transition-duration: 0.01ms !important;
}
}

46
web/src/theme.ts Normal file
View File

@@ -0,0 +1,46 @@
import type { GlobalThemeOverrides } from 'naive-ui';
/* 站牌导视主题:白底粗黑 + 胶囊按钮 + 墨黑主按钮 */
export const themeOverrides: GlobalThemeOverrides = {
common: {
bodyColor: '#f7f7f4',
cardColor: '#ffffff',
modalColor: '#ffffff',
popoverColor: '#ffffff',
tableColor: '#ffffff',
tableHeaderColor: '#ffffff',
borderColor: '#e2e2dd',
dividerColor: '#ecece8',
primaryColor: '#2b3f5c',
primaryColorHover: '#24354e',
primaryColorPressed: '#1d2b40',
primaryColorSuppl: '#2b3f5c',
infoColor: '#275ad1',
successColor: '#007a72',
warningColor: '#b26a00',
warningColorHover: '#9a5c00',
errorColor: '#c0392b',
textColorBase: '#212529',
textColor1: '#212529',
textColor2: '#3c3e42',
textColor3: '#6e7073',
fontFamily: "-apple-system, 'PingFang SC', 'Helvetica Neue', 'Segoe UI', sans-serif",
fontFamilyMono: "'IBM Plex Mono', ui-monospace, 'SF Mono', Menlo, monospace",
borderRadius: '10px',
borderRadiusSmall: '6px',
},
Button: {
fontWeight: '600',
borderRadiusMedium: '999px',
borderRadiusSmall: '999px',
borderRadiusTiny: '999px',
borderRadiusLarge: '999px',
},
Tag: {
borderRadius: '999px',
},
DataTable: {
thFontWeight: '700',
thTextColor: '#6e7073',
},
};

View File

@@ -0,0 +1,45 @@
/**
* 复制文本到剪贴板。
*
* navigator.clipboard 仅在安全上下文HTTPS 或 localhost可用
* 通过局域网 IP 以 HTTP 访问时它是 undefined此时回落到 execCommand。
*/
export async function copyText(text: string): Promise<boolean> {
if (navigator.clipboard && window.isSecureContext) {
try {
await navigator.clipboard.writeText(text);
return true;
} catch {
// 继续尝试回落方案
}
}
try {
const ta = document.createElement('textarea');
ta.value = text;
// 置于视口内但不可见,否则 iOS Safari 不会执行复制
ta.setAttribute('readonly', '');
ta.style.position = 'fixed';
ta.style.top = '0';
ta.style.left = '0';
ta.style.width = '1px';
ta.style.height = '1px';
ta.style.padding = '0';
ta.style.border = 'none';
ta.style.outline = 'none';
ta.style.boxShadow = 'none';
ta.style.background = 'transparent';
ta.style.opacity = '0';
document.body.appendChild(ta);
ta.focus();
ta.select();
ta.setSelectionRange(0, text.length); // iOS 需要显式指定范围
const ok = document.execCommand('copy');
document.body.removeChild(ta);
return ok;
} catch {
return false;
}
}

12
web/src/utils/nodeName.ts Normal file
View File

@@ -0,0 +1,12 @@
import type { NodeDto } from '@proxy-station/shared';
/** 名字末尾的出口词Direct / Warp / 直连 / WARP前面可以是空格、点号或连字符 */
const TRAILING_EGRESS = /[\s·_-]+(direct|warp|)\s*$/iu;
/**
* 界面上与出口标签并排时的节点名:剥掉名字里的出口词,避免和标签重复。
* 只影响显示——下发给客户端的名字保持原样,用户要靠它区分同协议的两条线路。
*/
export function nodeDisplayName(node: Pick<NodeDto, 'name'>): string {
return node.name.replace(TRAILING_EGRESS, '').trim();
}

13
web/tsconfig.json Normal file
View File

@@ -0,0 +1,13 @@
{
"compilerOptions": {
"target": "ES2022",
"module": "ESNext",
"moduleResolution": "bundler",
"strict": true,
"skipLibCheck": true,
"noEmit": true,
"jsx": "preserve",
"lib": ["ES2022", "DOM", "DOM.Iterable"]
},
"include": ["src/**/*.ts", "src/**/*.vue"]
}

16
web/vite.config.ts Normal file
View File

@@ -0,0 +1,16 @@
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';
export default defineConfig({
plugins: [vue()],
server: {
port: 5173,
// 监听 0.0.0.0:局域网设备可访问开发中的管理界面
host: true,
proxy: {
'/api': 'http://localhost:3000',
// 精确到 /sub/,避免把前端路由 /subscriptions 也代理走
'^/sub/': 'http://localhost:3000',
},
},
});