前言

参考：

https://community.hetzner.com/tutorials/ssh-notification-with-ntfy

功能

1. 登录通知：当用户通过SSH登录时，向Gotify发送通知，包含

   • 登录用户
   • IP
   • 主机名
   • 地理位置
   • 时间

2. 排除项：排除来自局域网和服务器自己公网ip的连接

通知示例：

用户 elvish 从 114.51.14.11 登录到 Ubuntu-24.04-server
时间: 2026-01-01 10:00:00 CST
🌍 位置: Shanghai, Shanghai, CN 🇨🇳

说明

1. 地理位置服务使用ipinfo.io的API通过ip地址反推，有速率限制
2. 脚本会在每次SSH登录时执行，包括非交互式登录（如SCP、SFTP等）

使用说明

1. 创建脚本：

sudo nano /usr/local/bin/ssh-login-notify.sh

粘贴以下内容：

#!/bin/bash

USER_NAME=$PAM_USER
HOST_NAME=$(hostname)
TIME_NOW=$(TZ=Asia/Shanghai date "+%Y-%m-%d %H:%M:%S %Z")
GOTIFY_URL="http://127.0.0.1:8118"  # <- 更改此处的地址和token
GOTIFY_TOKEN="<GOTIFY_TOKEN>"

# 获取IP地址 - 修复SFTP连接显示问题
if [ -n "$SSH_CONNECTION" ]; then
  IP_ADDRESS=$(echo $SSH_CONNECTION | awk '{print $1}')
else
  # 回退到who命令，但过滤掉无效的输出
  IP_ADDRESS=$(who | awk '{print $5}' | grep -Eo '([0-9]{1,3}\.){3}[0-9]{1,3}' | head -n 1)
fi

[ -z "$IP_ADDRESS" ] && IP_ADDRESS="unknown"

# 获取服务器的公网IP地址
get_server_public_ip() {
  # 尝试通过不同方式获取公网IP
  local public_ip=""
  
  # 方法1: 使用dig查询DNS
  public_ip=$(dig +short myip.opendns.com @resolver1.opendns.com 2>/dev/null)
  
  # 方法2: 使用curl查询外部服务
  if [ -z "$public_ip" ]; then
    public_ip=$(curl -s http://ifconfig.me 2>/dev/null)
  fi
  
  # 方法3: 使用hostname命令
  if [ -z "$public_ip" ]; then
    public_ip=$(hostname -I | awk '{print $1}' 2>/dev/null)
  fi
  
  echo "$public_ip"
}

# 检查是否为局域网、回环地址或服务器自身公网IP
is_local_or_self_ip() {
  local ip=$1
  # 回环地址
  if [[ $ip == "127.0.0.1" || $ip == "::1" || $ip == "localhost" ]]; then
    return 0
  fi
  
  # 私有IP地址范围
  if [[ $ip =~ ^10\. ]] || \
     [[ $ip =~ ^172\.(1[6-9]|2[0-9]|3[0-1])\. ]] || \
     [[ $ip =~ ^192\.168\. ]] || \
     [[ $ip =~ ^169\.254\. ]]; then
    return 0
  fi
  
  # 获取服务器公网IP
  local server_public_ip=$(get_server_public_ip)
  
  # 检查是否为服务器自身公网IP
  if [[ "$ip" == "$server_public_ip" ]]; then
    return 0
  fi
  
  # 不是本地IP或自身公网IP
  return 1
}

# 如果是局域网、回环地址或服务器自身公网IP，直接退出
if is_local_or_self_ip "$IP_ADDRESS"; then
  exit 0
fi

# 如果是会话关闭，退出
if [[ $PAM_TYPE == 'close_session' ]]; then
  exit 0
fi

# 获取地理位置信息（可选）
GEO_INFO=""
if [[ "$IP_ADDRESS" != "unknown" && "$IP_ADDRESS" != "127.0.0.1" && "$IP_ADDRESS" != ::1 ]]; then
  GEO_JSON=$(curl -s "https://ipinfo.io/$IP_ADDRESS/json")
  CITY=$(echo "$GEO_JSON" | jq -r '.city')
  REGION=$(echo "$GEO_JSON" | jq -r '.region')
  COUNTRY=$(echo "$GEO_JSON" | jq -r '.country')
  ORG=$(echo "$GEO_JSON" | jq -r '.org')
  
  # 将国家代码转换为国旗表情符号的函数
  flag() {
    local code="${1^^}"
    local first=$(( $(printf "%d" "'${code:0:1}") - 65 + 0x1F1E6 ))
    local second=$(( $(printf "%d" "'${code:1:1}") - 65 + 0x1F1E6 ))
    printf '%b' "$(printf '\\U%08X\\U%08X' "$first" "$second")"
  }
  
  # 使用Unicode编码的表情符号
  EARTH_ICON=$(printf '\U1F30D')
  GEO_INFO="$EARTH_ICON 位置: $CITY, $REGION, $COUNTRY $(flag $COUNTRY)"
fi

# 构建消息内容
TITLE="SSH登录提醒 - $HOST_NAME"
MESSAGE="用户 $USER_NAME 从 $IP_ADDRESS 登录到 $HOST_NAME
时间: $TIME_NOW
$GEO_INFO"

# 发送到Gotify
if [ -n "$SSH_CONNECTION" ] || [ -n "$SFTP_CONNECTION" ]; then
  curl -s -o /dev/null \
    -X POST \
    -F "title=${TITLE}" \
    -F "message=${MESSAGE}" \
    -F "priority=5" \
    "${GOTIFY_URL}/message?token=${GOTIFY_TOKEN}"
fi

2. 设置执行权限：

sudo chmod +x /usr/local/bin/ssh-login-notify.sh

3. 安装依赖（如果尚未安装）：

sudo apt update && sudo apt install jq dnsutils curl -y

4. 配置PAM：

编辑SSH的PAM配置文件：

sudo nano /etc/pam.d/sshd

在文件末尾添加：

session optional pam_exec.so /usr/local/bin/ssh-login-notify.sh

5. 重启SSH服务：

sudo systemctl restart sshd

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://elvish.me/posts/experience/porkbun-order-not-completed-after-payment-solution

Subject: Payment Completed but Domain Still in Cart

Dear Porkbun Support Team,

I am writing to report an issue with my recent domain registration attempt. Today, I tried to register the domain example.com and completed the payment via Alipay. The payment was successfully deducted from my account, but the domain remains in my shopping cart and has not been registered.

Here are the details for your reference:

· Domain: example.com
· Porkbun Invoice/Order #: XXXXXXX
· Alipay Transaction ID: XXXXXXXXXXXXXXXX
· Merchant Order ID: src_XXXXXXXXXXXXXXXX
· Issue: The invoice in my Porkbun account shows a payment of $0, but the payment was successfully processed via Alipay.

I confirmed that the payment was deducted from my Alipay account, and I have also seen similar reports from other users on Reddit experiencing the same issue with payments via Alipay. I believe this is a technical error on your platform, and I would appreciate your assistance in resolving it promptly.

Could you please investigate this issue and complete the registration for the domain example.com as soon as possible? If additional verification is required from my end, please let me know.

Thank you for your attention to this matter. I look forward to your prompt response.

Best regards,
Elvish

Dear NAME,

Thank you for your reply. I would like to clarify that the payment for the domain has already been successfully deducted from my Alipay account.

I notice that you use the Stripe platform to process Alipay payments. Could you please check the status of the specific order src_XXXXXXXXXXXXXXXX in your Stripe merchant dashboard?

I have taken a screenshot of the successful transaction from my Alipay account and also downloaded the official electronic transaction receipt. The original document (protected by a digital signature) is in Chinese. I have attached both the original Chinese receipt and an English translation to this email for your review.

If any other documentation is needed from my side to verify this payment, I am happy to provide it.

If there is an ongoing issue with this specific payment method on your end, I would appreciate it if you could initiate a refund for this transaction (src_XXXXXXXXXXXXXXXX) via your Stripe backend. Once the refund is confirmed, I am willing to complete the purchase for the domain using an alternative method, such as PayPal.

I look forward to your assistance in resolving this matter promptly.

Best regards,

## Urgent: Payment Verified but Order Incomplete - Order #【你的订单号】 & Stripe Charge src_【商家订单号】

Dear Porkbun Support Team,

I am writing to report a payment issue. The payment for my domain 【域名】 was successfully deducted from my Alipay account, but the domain remains in my cart and the invoice (#【你的订单号】) shows as unpaid.

I understand you use Stripe. Could you please check the status of the specific Stripe charge src_【商家订单号】 in your merchant dashboard?

For verification, I have attached:
1. A screenshot of the successful Alipay transaction.
2. The official Alipay e-receipt (original in Chinese + English translation).

If this payment cannot be applied to my order, please refund this charge (src_【商家订单号】) via your Stripe backend. I am then willing to repay immediately via PayPal or another method.

I look forward to your prompt resolution. Thank you.

Best regards,
【你的名字】

【在邮件里附上支付宝扣款截图和中英文电子流水回单】

览毕，何不一言？

引入

前几天看见有人把《明日方舟：终末地》的LOGO改成了开机动画

https://www.bilibili.com/video/BV1jPNKzkEvE

正好之前也自己改过一个COD里 ATLAS 的的开机动画，用了快一年了，正好换新换换口味，顺便复习一下制作的步骤

制作步骤

1.剪切视频

原动画作者在 视频 下面给出了网盘的视频源文件

下周后根据需要剪辑，剪掉两头多余的部分和中间同一画面停留过长的地方。

2.视频切分为帧

使用 ffmpeg 将视频切分为每帧一张图片，根据实际情况调整帧率

ffmpeg -i input.mp4 -vf "fps=30" %0d.png

3.整理文件名

对于这个只有一段的动画，将图片放到part0文件夹中

在图片目录打开PowerShell粘贴下方代码块中的内容进行规范命名。

Get-ChildItem -Filter *.png | ForEach-Object {
    if ($_.BaseName -match '^\d+$') {
        $num = [int]$_.BaseName
        $newName = "{0:D3}{1}" -f $num, $_.Extension
        if ($_.Name -ne $newName) {
            Rename-Item -Path $_.FullName -NewName $newName
            Write-Host "已重命名: $($_.Name) -> $newName" -ForegroundColor Green
        }
    }
}

4.新建配置文件

在part0同级目录新建desc.txt

1080 1440 30
c 1 0 part0 000000

::: note 参数解析：

第一行：全局基础属性

1080 1440 30

这行定义了动画的全局基础显示属性，格式为：[WIDTH] [HEIGHT] [FPS]

• 1080 (WIDTH)：动画的宽度，单位是像素。与图片分辨率一致即可。
• 1440 (HEIGHT)：动画的高度，单位是像素。
• 30 (FPS)：动画的帧率，代表每秒播放 30 张图片。

第二行：动画段落播放控制

格式均为：[TYPE] [COUNT] [PAUSE] [PATH] [BACKGROUND_COLOR] [CLOCK]

c 1 0 part0 000000 -1

• c (TYPE)：代表 "complete"（完整播放）。**即使系统在后台已经加载完毕，这一段也必须强制完整播完，不允许打断。另外可选： p：代表 "play"（可打断播放）。只要系统加载完毕准备好进入锁屏/桌面，无论这一段有没有播完，都会立刻被系统强制打断并结束开机画面。
• 1 (COUNT)：播放次数。1 代表这一段动画（part0 文件夹里的图片）只播放 1 次。
• 0 (PAUSE)：播放结束后的暂停时间，单位是帧数。停顿为 0（播完立刻进入下一阶段）
• part0 (PATH)：该段动画读取对应压缩包里的 part0 文件夹。
• #000000 (BACKGROUND)：这一段播放时的屏幕背景颜色，这里是纯黑色。
• -1 (CLOCK)：时钟显示的 Y 坐标（通常用于手表系统）。-1 代表隐藏/不显示时钟。

:::

5.打包为bootanimation.zip

part0和desc.txt打包为一个.zip文件

压缩时选择压缩程度：仅储存

最终结构：

bootanimation.zip
├── part0
│   ├── 001.png
│   ├── 002.png
│   ├── 003.png
│   └── ...
└── desc.txt

这是我制作的版本，可以 下载 参考：

刷入手机

由于我手机刷了第三方类原生的Rising OS系统，可以直接在设置中选择自定义的bootanimation.zip作为开机动画

对于一般已获取root的手机，可以构建一个简单的magisk模块刷入，覆盖系统原有的bootanimation即可

引入

由于家宽公网 IPv4 每隔24~48小时，就会被运营商强制断线重连，导致CDN在回源时可能找不到源站。

尝试通过缩短A记录的TTL来缓解此现象，但是大陆的网络环境，各地运营商DNS层层缓存，这样没有作用

只能退而求其次，尽量控制让IP变动的时候在晚上，减少影响

本来可以通过软路由的定时任务来轻松解决的，但是我用于拨号的华为路由器没有这样的功能

因此，Vibe coding了一个脚本，适用于华为AX3 Pro路由器的自动重新拨号

::: note 这个脚本仅在 AX3 Pro 进行过测试，其他型号的同种控制台应该也能使用。可能需要修改脚本中的div id :::

分析

本希望通过抓包登录和重启路由器的接口，但华为路由器采用了SCRAM (Salted Challenge Response Authentication Mechanism，加盐挑战响应认证机制) 或类似的安全握手协议，而不是直接发送明文密码。

因此每次登录时 firstnonce、csrf_token 和计算出来的 clientproof 都是动态变化的

如果希望通过脚本完成加盐挑战响应，需要解析来自路由器网页的js，比较麻烦

也尝试了通过抓包重启光猫也能达到目的（请求体是简单的明文），但是重启光猫时会导致座机也重启，晚上会发出声响

最后决定使用 Playwright 无头浏览器自动化点击来重新拨号

1.安装依赖

pip install playwright 
playwright install chromium 
playwright install-deps

2.创建脚本

在第 15 行填入登录密码

from playwright.sync_api import sync_playwright
import time

def reboot_router():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()

        try:
            print("Opening router dashboard...")
            page.goto("http://192.168.3.1/")

            page.wait_for_load_state('networkidle')

            print("Logging in with password...")
            page.fill('#userpassword_ctrl', '<PASSWORD>') # <--把此处改为你的登录密码
            page.click('#loginbtn')

            time.sleep(3)

            print("Logged in，executing reconnecting action...")
            page.click('#internet')
            page.click('#internet_reconnect')
            print("Success.The network is about to reconnect...")
            time.sleep(2)

        except Exception as e:
            print(f"An error occurred: {e}")
        finally:
            browser.close()

if __name__ == "__main__":
    reboot_router()

3.设置定时任务

通过cronjob设置

crontab -e

# 添加脚本路径，设置每天凌晨3点执行
0 3 * * * /bin/bash -c "cd /path/to/script && source venv/bin/activate && python main.py >> reboot.log 2>&1"

在1panel中设置

导航到 计划任务-创建

• 执行周期: 如每天 3 小时 0 分钟
• 解释器: python3
• 脚本内容: 路径选择，并填入脚本路径

想法

有时候觉得分享文章的时候默认的连接比较长

正好手上有短域名部署了Sink短链服务

https://github.com/miantiao-me/sink

想到可以通过云函数功能配合Webhook事件来请求Sink的API生成短链，并用于文章分享

Mix-space 后端部分

1.创建 Function

在 Mix-space后台-附加功能-配置与云函数新增一个函数

• 名称: sink
• 引用: shiro
• 类型: Function
• Secret 环境变量:

在编辑器中填入以下内容:

export default async function handler(ctx) {
  const { req, secret, broadcast } = ctx;
  const method = req.method;
  if (!secret.sink_hostname || !secret.sink_token || !secret.blog_url) {
    return { error: "Missing configuration" };
  }

  if (method === 'GET') {
    const { id, type } = req.query;
    if (!id || !type) {
      return "ID and type are required";
    }
    const shortId = parseInt(id.slice(-8), 16).toString(36).slice(-4);
    const prefix = type.toLowerCase();
    if (prefix !== 'p' && prefix !== 'n') return "Invalid type";
    const slug = `${prefix}${shortId}`;
    return `${secret.sink_hostname}/${slug}`;
  }

  if (!secret.webhook_secret || req.query.secret !== secret.webhook_secret) {
    return { error: "Unauthorized webhook request" };
  }

  const data = req.body;
  const event = req.headers['x-webhook-event'];
  if (!event || !data) return { message: "Empty payload" };

  const docId = data._id || data.id;
  if (!docId) return { error: "ID not found" };

  const shortId = parseInt(docId.slice(-8), 16).toString(36).slice(-4);
  const getSlug = (ev) => {
    if (ev.startsWith('POST_')) return `p${shortId}`;
    if (ev.startsWith('NOTE_')) return `n${shortId}`;
    return null;
  };

  const targetSlug = getSlug(event);
  if (!targetSlug) return { message: "Ignored event" };

  let apiUrl = "";
  let requestBody = {};
  let actionName = "";

  if (event === 'POST_CREATE' || event === 'NOTE_CREATE') {
    actionName = "生成";
    apiUrl = `https://${secret.sink_hostname}/api/link/create`;
    let targetUrl = "";
    if (event === 'POST_CREATE') {
      const categorySlug = data.category?.slug || 'default';
      targetUrl = `${secret.blog_url}/posts/${categorySlug}/${data.slug}`;
    } else {
      targetUrl = `${secret.blog_url}/notes/${data.nid}`;
    }
    requestBody = {
      url: targetUrl,
      slug: targetSlug,
      comment: `MixSpace - ${data.title || 'Untitled'}`
    };
  } else if (event === 'POST_DELETE' || event === 'NOTE_DELETE') {
    actionName = "删除";
    apiUrl = `https://${secret.sink_hostname}/api/link/delete`;
    requestBody = { slug: targetSlug };
  } else {
    return { message: "Unsupported action" };
  }

  try {
    const response = await fetch(apiUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${secret.sink_token}`
      },
      body: JSON.stringify(requestBody)
    });

    const responseText = await response.text();
    let result = {};
    if (responseText) {
      try {
        result = JSON.parse(responseText);
      } catch (e) {
        result = { raw: responseText };
      }
    }

    return { success: response.ok, slug: targetSlug, result };
  } catch (err) {
    return { error: "Request failed", message: err.message };
  }
}

设计逻辑

最开始计划的逻辑是slug留空给sink生成，这样能保证短链尽可能短，并且不会重复。

但是根据 Sink API 文档 可知，在请求删除一个短链时请求体参数需要slug，虽然可以先 LIST 找到 slug 再 DELETE，但是在短链变多后会变得很麻烦，LIST 只能分页查询。

因此需要能根据文章的唯一 _id 反推 slug。

_id 实际上是 MongoDB 的 ObjectId。它是一个 24 位的十六进制字符串。前 8 位：是时间戳（精确到秒）。由文章创建时间决定。中间 10 位：是机器标识码和进程 ID（通常是随机生成的）。最后 6 位：是一个自增计数器（每次插入新数据时加 1）。

因此，短链生成的逻辑是：

1. 在计算出的4位前面加上 p 或 n 用于标识 post或note ，最终得到的slug形如 pabva 和 n1afc

NOTE

为什么不直接取id的后四位？

id是一串16进制字符，那么它的命名空间只有0-9,a-f，这导致命名空间大幅减少，使得两篇文章slug重复的可能性增大，并且也不够美观。

当前方案slug重复的可能性有多大？

理论上存在，但对于个人博客来说，实际重复风险极低，基本可以忽略不计。
数学原理: Base36 包含 36 个字符（0-9，a-z）。截取最后 4 位，意味着共有 36⁴ = 1,679,616（约 167 万）种唯一的组合。

底层机制：MongoDB ID 的尾部是一个严格自增的计数器。当你截取转换后的后 4 位时，实际上是在做类似取模的循环。这意味着，除非博客文章和日记总数达到 167 万篇，否则在单台服务器上几乎不可能发生“转了一圈又撞上”的情况。

2.添加Webhook

在 附加功能-Webhooks-添加Webhook

• Payload URL: https://example.com/api/v2/fn/shiro/sink?secret=<YOUR_WEBHOOK_TOKEN>
• Secret 留空 (因为我似乎发现填写了此值也会显示"未配置Secret"，故弃用，直接填在URL后面)
• 触发事件：POST_CREEAT POST_DELETE NOTE_CREAT NOTE_DELETE
• 触发范围：系统事件
• 启用状态：启用

NOTE

点击 发送测试 会提示失败，因为测试的payload与实际payload不同，实际使用时不会报错。

新建一篇文章测试，点击右上角发布，查看webhook日志，在Response中有以下字段，代表创建短链成功：

      "shortLink": "https://rua.ee/pkrw6"

3.前端获取短链

云函数中定义了一个API，在浏览器中输入地址可以获取已知id文章或手记的短链

GET https://example.com/api/v2/fn/shiro/sink?id=<id>&type=p

• id 为文章或手记的唯一id
• type 为类型， p 代表 posts，n 代表 notes

前端部分

由于更改的文件过多，本想通过提供github commit 链接做参考

但是我的仓库为了尊重原作者的工作也是 private，故给出以下详细提示词，可以使用 AI Agent 辅助完成修改

这个份提示词适用于单域名部署的Yohaku站点，如果你采用的是双域名的部署方式，可能需要修改 第 5 行 的描述

这是Codex GPT 5.5-Medium 给出的plan，执行修改后一次成功，您可以复制给AI Agent尝试

# 通过短链分享文章/手记

## Summary
- 将 posts 和 notes 的桌面侧栏、移动底栏分享入口统一改为“通过短链分享”。
- 点击后请求 `/api/v2/fn/shiro/sink?id=<id>&type=<type>`，复制返回的短链到剪贴板，并用项目 toast 显示“已复制短链。”
- 移除原来的系统分享 API、分享弹窗降级逻辑和不再使用的 `ShareModal`。

## Key Changes
- 在 `PostActionAside.tsx` 中替换 `ShareMark` 和 `ShareButton`：
  - 从当前 post 数据读取 `id`。
  - 请求 `type=p`。
  - 删除 `navigator.share`、`useModalStack`、`ShareModal`、`routeBuilder`、`Routes`、`urlBuilder` 相关依赖。
- 在 `NoteActionAside.tsx` 中替换 `ShareTab` 和 `WashiShareButton`：
  - 从当前 note 数据读取 `id`。
  - 请求 `type=n`。
  - 删除 `navigator.share`、`useModalStack`、`ShareModal`、`buildNotePath`、`urlBuilder` 相关分享依赖。
- 新增一个小型共享 helper，供 post/note 复用：
  - 调用 `$fetch('/api/v2/fn/shiro/sink', { query: { id, type } })`。
  - 接受纯字符串响应；也兼容常见 JSON 响应字段如 `url`、`link`、`shortUrl`、`shortLink`、`data`。
  - 成功后 `navigator.clipboard.writeText(shortLink)`，再 `toast.success(t('copy_short_link_success'))`。
  - 获取或复制失败时 `toast.error(t('copy_short_link_failed'))`。
- 删除 `apps/web/src/components/modules/shared/ShareModal.tsx`，前提是替换后全局无引用。

## i18n
- 更新所有 locale 的 `common.json`：
  - `aria_share_post`: 改为“通过短链分享”语义。
  - `aria_share_note`: 改为“通过短链分享”语义。
  - 新增并使用 `copy_short_link_success`，中文值为 `已复制短链。`
  - 新增并使用 `copy_short_link_failed`，用于接口或剪贴板失败提示。
- 覆盖 `zh`、`zh-TW`、`en`、`ja`、`ko`，保持 message key 同步。

## Test Plan
- 运行 `pnpm --dir apps/web vitest run src/messages/message-usage.test.ts`，确认新增 i18n key 被引用且没有未使用 key。
- 运行 `pnpm --dir apps/web lint` 或至少对相关文件执行类型/ lint 检查。
- 手动验证：
  - post 页面桌面侧栏点击分享，请求带 `type=p` 和 post `id`，剪贴板得到短链，toast 显示成功文案。
  - post 页面移动底栏同样生效。
  - note 页面桌面侧栏/嵌入侧栏点击分享，请求带 `type=n` 和 note `id`。
  - note 页面移动底栏同样生效。
  - API 失败或剪贴板失败时显示失败 toast，不再弹出系统分享面板或 ShareModal。

## Assumptions
- 短链接口是同源相对路径，可从浏览器直接请求。
- 接口成功响应中至少会返回短链字符串，或返回包含短链字段的 JSON；实现会兼容这两类形态。
- “posts 和 notes 侧栏”包含当前文件里的桌面侧栏入口，也包含对应移动底栏分享按钮，因为原分享逻辑在两端各有一份。

::: warning

此方法已弃用，因为这个好像才是正解

https://github.com/mx-space/snippets/blob/main/shiro/functions/status.ts

:::

最近在折腾Mix-space的云函数功能，在配置status函数的过程中遇到了一些问题，分享一下解决过程以及自己的一些新想法

优化原作者提供的status函数

在配置Yohaku的status云函数时注意到上传状态报错204

https://github.com/mx-space/snippets/blob/main/shiro/functions/status.ts

注释掉第 61 行可正常使用

  const status = {
    emoji,
    icon,
    desc,
    ttl,
    untilAt: Date.now() + ttl * 1000,
  } as Status
  ctx.storage.cache.set(cacheKey, JSON.stringify(status), ttl)
  // ctx.status(204)

  ctx.broadcast('shiro#status', status)
}

简易的多平台Agent客户端

1.Android 客户端

由于目前没用安卓客户端，所以根据 live-dashboard 魔改了一个基于无障碍权限获取前台应用名称的安卓客户端：

https://github.com/Elvish064/Process-Reporter

可在 Release 中下载编译好的版本

2.Windows 客户端

顺手也改了一个win版本，可自行通过pyinstaller打包为exe可执行文件

import ctypes
import ctypes.wintypes
import ipaddress
import json
import logging
import logging.handlers
import os
import socket
import subprocess
import sys
import threading
import time
import urllib.parse
from pathlib import Path

import psutil
import requests

if getattr(sys, "frozen", False):
    base_dir = Path(sys.executable).parent
else:
    base_dir = Path(__file__).parent

# ---------------------------------------------------------------------------
# Logging - console always; file handler toggleable (2-day rotation)
# ---------------------------------------------------------------------------
LOG_FILE = base_dir / "agent.log"
_file_handler: logging.Handler | None = None

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[logging.StreamHandler()],
)
log = logging.getLogger("agent")


def set_file_logging(enabled: bool) -> None:
    """Toggle file logging with 2-day rotation."""
    global _file_handler
    if enabled and _file_handler is None:
        _file_handler = logging.handlers.TimedRotatingFileHandler(
            LOG_FILE, when="midnight", backupCount=1, encoding="utf-8",
        )
        _file_handler.setFormatter(
            logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")
        )
        logging.getLogger().addHandler(_file_handler)
    elif not enabled and _file_handler is not None:
        logging.getLogger().removeHandler(_file_handler)
        _file_handler.close()
        _file_handler = None


# ---------------------------------------------------------------------------
# Win32 API bindings
# ---------------------------------------------------------------------------
user32 = ctypes.windll.user32  # type: ignore[attr-defined]

GetForegroundWindow = user32.GetForegroundWindow
GetForegroundWindow.restype = ctypes.wintypes.HWND

GetWindowTextW = user32.GetWindowTextW
GetWindowTextW.argtypes = [ctypes.wintypes.HWND, ctypes.wintypes.LPWSTR, ctypes.c_int]
GetWindowTextW.restype = ctypes.c_int

GetWindowTextLengthW = user32.GetWindowTextLengthW
GetWindowTextLengthW.argtypes = [ctypes.wintypes.HWND]
GetWindowTextLengthW.restype = ctypes.c_int

GetWindowThreadProcessId = user32.GetWindowThreadProcessId
GetWindowThreadProcessId.argtypes = [ctypes.wintypes.HWND, ctypes.POINTER(ctypes.wintypes.DWORD)]
GetWindowThreadProcessId.restype = ctypes.wintypes.DWORD


def get_foreground_info() -> tuple[str, str] | None:
    """Return (process_name, window_title) of the current foreground window."""
    hwnd = GetForegroundWindow()
    if not hwnd:
        return None
    length = GetWindowTextLengthW(hwnd)
    title = ""
    if length > 0:
        buf = ctypes.create_unicode_buffer(length + 1)
        GetWindowTextW(hwnd, buf, length + 1)
        title = buf.value.strip()
    pid = ctypes.wintypes.DWORD()
    GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
    try:
        proc = psutil.Process(pid.value)
        proc_name = proc.name()
    except (psutil.NoSuchProcess, psutil.AccessDenied):
        proc_name = "unknown"
    return proc_name, title

def format_report_desc(app_id: str, window_title: str) -> str:
    """Return the reported desc: title first, then process name without .exe."""
    title = (window_title or "").strip()
    if title:
        return title[:256]
    app = (app_id or "").strip() or "unknown"
    if app.lower().endswith(".exe"):
        app = app[:-4]
    return app or "unknown"


# ---------------------------------------------------------------------------
# Config - stored next to the exe for easy cleanup
# ---------------------------------------------------------------------------
CONFIG_PATH = base_dir / "config.json"

_DEFAULT_CFG = {
    "server_url": "",
    "token": "",
    "emoji": "",
    "heartbeat_seconds": 60,
    "sensitive_words_regex": "",
    "enable_log": False,
}

MONITOR_POLL_SECONDS = 5


def load_config() -> dict:
    """Load config.json, return config dict (may be empty on error)."""
    try:
        with open(CONFIG_PATH, "r", encoding="utf-8") as f:
            cfg = json.load(f)
    except FileNotFoundError:
        return dict(_DEFAULT_CFG)
    except (PermissionError, json.JSONDecodeError) as e:
        log.error("config.json: %s", e)
        return dict(_DEFAULT_CFG)

    if not isinstance(cfg, dict):
        return dict(_DEFAULT_CFG)

    normalized = dict(_DEFAULT_CFG)

    for key in ("server_url", "token", "emoji", "sensitive_words_regex"):
        value = cfg.get(key, _DEFAULT_CFG[key])
        normalized[key] = value.strip() if isinstance(value, str) else _DEFAULT_CFG[key]

    enable_log = cfg.get("enable_log", _DEFAULT_CFG["enable_log"])
    normalized["enable_log"] = enable_log if isinstance(enable_log, bool) else _DEFAULT_CFG["enable_log"]

    val = cfg.get("heartbeat_seconds", _DEFAULT_CFG["heartbeat_seconds"])
    if not isinstance(val, (int, float)) or val < 10 or val > 600:
        val = _DEFAULT_CFG["heartbeat_seconds"]
    normalized["heartbeat_seconds"] = int(val)

    return normalized


def save_config(cfg: dict) -> bool:
    """Save config to config.json atomically with restricted permissions."""
    import tempfile
    try:
        data = json.dumps(cfg, indent=2, ensure_ascii=False).encode("utf-8")
        fd = tempfile.NamedTemporaryFile(
            dir=CONFIG_PATH.parent, prefix=".config_", suffix=".tmp",
            delete=False,
        )
        tmp_path = Path(fd.name)
        try:
            fd.write(data)
            fd.flush()
            os.fsync(fd.fileno())
            fd.close()
            os.chmod(tmp_path, 0o600)
            tmp_path.replace(CONFIG_PATH)
        except BaseException:
            fd.close()
            tmp_path.unlink(missing_ok=True)
            raise
        return True
    except Exception as e:
        log.error("Config save failed: %s", e)
        return False


def validate_config(cfg: dict) -> str | None:
    """Validate config. Return error message or None if valid."""
    url = cfg.get("server_url", "").strip()
    token = cfg.get("token", "").strip()
    sensitive_regex = cfg.get("sensitive_words_regex", "").strip()
    
    if not url:
        return "上报接口 URL 不能为空"
    if not token or token == "YOUR_TOKEN_HERE":
        return "Token 不能为空"
        
    if sensitive_regex:
        import re
        try:
            re.compile(sensitive_regex)
        except re.error:
            return "标题敏感词排除正则表达式无效"

    parsed = urllib.parse.urlparse(url)
    scheme = parsed.scheme.lower()
    hostname = parsed.hostname
    if scheme not in ("http", "https"):
        return "上报接口 URL 必须使用 http:// 或 https://"
    if not hostname:
        return "上报接口 URL 无效"

    if scheme == "http":
        try:
            addrinfos = socket.getaddrinfo(hostname, None, socket.AF_UNSPEC, socket.SOCK_STREAM)
        except socket.gaierror:
            return f"无法解析域名: {hostname}"
        for info in addrinfos:
            ip = ipaddress.ip_address(info[4][0])
            if ip.is_global:
                return "HTTP 仅允许内网地址，公网请使用 HTTPS"

    return None


# ---------------------------------------------------------------------------
# Windows autostart
# ---------------------------------------------------------------------------
AUTOSTART_NAME = "LiveDashboardAgent"
AUTOSTART_RUN_KEY = r"Software\Microsoft\Windows\CurrentVersion\Run"


def _get_autostart_command() -> str:
    """Return the command line used for login autostart."""
    if getattr(sys, "frozen", False):
        return subprocess.list2cmdline([str(Path(sys.executable).resolve())])
    return subprocess.list2cmdline([sys.executable, str(Path(__file__).resolve())])


def _has_registry_autostart() -> bool:
    """Return whether the current user has a Run-key startup entry."""
    try:
        import winreg
        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, AUTOSTART_RUN_KEY) as key:
            value, _ = winreg.QueryValueEx(key, AUTOSTART_NAME)
    except FileNotFoundError:
        return False
    except OSError as e:
        log.warning("Autostart registry query failed: %s", e)
        return False
    return isinstance(value, str) and bool(value.strip())


def _set_registry_autostart(enabled: bool) -> bool:
    """Enable/disable login autostart through the current-user Run key."""
    try:
        import winreg
        with winreg.CreateKey(winreg.HKEY_CURRENT_USER, AUTOSTART_RUN_KEY) as key:
            if enabled:
                winreg.SetValueEx(
                    key, AUTOSTART_NAME, 0, winreg.REG_SZ, _get_autostart_command()
                )
            else:
                try:
                    winreg.DeleteValue(key, AUTOSTART_NAME)
                except FileNotFoundError:
                    pass
        return True
    except OSError as e:
        log.error("Autostart registry update failed: %s", e)
        return False


def _has_legacy_startup_task() -> bool:
    """Return whether the legacy scheduled task based autostart exists."""
    try:
        result = subprocess.run(
            ["schtasks", "/query", "/tn", AUTOSTART_NAME],
            capture_output=True,
            text=True,
            check=False,
            timeout=5,
        )
    except (OSError, subprocess.SubprocessError) as e:
        log.debug("Autostart task query failed: %s", e)
        return False
    return result.returncode == 0


def _remove_legacy_startup_task() -> bool:
    """Remove the legacy scheduled task if it exists."""
    if not _has_legacy_startup_task():
        return True
    try:
        result = subprocess.run(
            ["schtasks", "/delete", "/tn", AUTOSTART_NAME, "/f"],
            capture_output=True,
            text=True,
            check=False,
            timeout=10,
        )
    except (OSError, subprocess.SubprocessError) as e:
        log.warning("Legacy startup task removal failed: %s", e)
        return False
    if result.returncode == 0:
        return True
    output = (result.stderr or result.stdout).strip()
    if output:
        log.warning("Legacy startup task removal failed: %s", output)
    return False


def is_autostart_enabled() -> bool:
    """Return whether the agent is configured to launch at Windows logon."""
    return _has_registry_autostart() or _has_legacy_startup_task()


def show_message(title: str, message: str, error: bool = False) -> None:
    """Show a best-effort native message box for user-facing actions."""
    try:
        flags = 0x10 if error else 0x40
        ctypes.windll.user32.MessageBoxW(None, message, title, flags)  # type: ignore[attr-defined]
    except Exception:
        log.info("%s: %s", title, message)


# ---------------------------------------------------------------------------
# Settings Dialog
# ---------------------------------------------------------------------------
def show_settings_dialog(current_config: dict | None = None) -> dict | None:
    """Show tkinter settings dialog. Returns new config or None if cancelled."""
    try:
        import tkinter as tk
        from tkinter import ttk, messagebox
    except ImportError:
        log.error("tkinter 不可用，请手动编辑 %s", CONFIG_PATH)
        return None

    cfg = current_config or dict(_DEFAULT_CFG)
    result: list[dict | None] = [None]

    root = tk.Tk()
    root.title("Live Dashboard - 设置")
    root.resizable(False, False)

    frame = ttk.Frame(root, padding=20)
    frame.pack(fill="both", expand=True)

    ttk.Label(frame, text="上报接口 URL:").grid(row=0, column=0, sticky="w", pady=6)
    url_var = tk.StringVar(value=cfg.get("server_url", ""))
    ttk.Entry(frame, textvariable=url_var, width=45).grid(row=0, column=1, pady=6, padx=(8, 0))

    ttk.Label(frame, text="Token:").grid(row=1, column=0, sticky="w", pady=6)
    token_var = tk.StringVar(value=cfg.get("token", ""))
    ttk.Entry(frame, textvariable=token_var, width=45, show="*").grid(row=1, column=1, pady=6, padx=(8, 0))

    ttk.Label(frame, text="Emoji:").grid(row=2, column=0, sticky="w", pady=6)
    emoji_var = tk.StringVar(value=cfg.get("emoji", ""))
    ttk.Entry(frame, textvariable=emoji_var, width=45).grid(row=2, column=1, pady=6, padx=(8, 0))

    ttk.Label(frame, text="心跳间隔 (秒):").grid(row=3, column=0, sticky="w", pady=6)
    heartbeat_var = tk.IntVar(value=cfg.get("heartbeat_seconds", 60))
    ttk.Spinbox(frame, textvariable=heartbeat_var, from_=10, to=600, width=10).grid(row=3, column=1, sticky="w", pady=6, padx=(8, 0))

    ttk.Label(frame, text="标题敏感词排除 (正则):").grid(row=4, column=0, sticky="w", pady=6)
    sensitive_var = tk.StringVar(value=cfg.get("sensitive_words_regex", ""))
    ttk.Entry(frame, textvariable=sensitive_var, width=45).grid(row=4, column=1, pady=6, padx=(8, 0))

    log_var = tk.BooleanVar(value=cfg.get("enable_log", False))
    ttk.Checkbutton(frame, text="开启日志文件 (保留 2 天)", variable=log_var).grid(
        row=5, column=0, columnspan=2, sticky="w", pady=6
    )

    def on_save():
        new_cfg = {
            "server_url": url_var.get().strip(),
            "token": token_var.get().strip(),
            "emoji": emoji_var.get().strip(),
            "heartbeat_seconds": heartbeat_var.get(),
            "sensitive_words_regex": sensitive_var.get().strip(),
            "enable_log": log_var.get(),
        }
        err = validate_config(new_cfg)
        if err:
            messagebox.showerror("配置错误", err, parent=root)
            return
        if save_config(new_cfg):
            result[0] = new_cfg
            root.destroy()
        else:
            messagebox.showerror("保存失败", "无法写入 config.json", parent=root)

    btn_frame = ttk.Frame(frame)
    btn_frame.grid(row=6, column=0, columnspan=2, pady=16)
    ttk.Button(btn_frame, text="保存", command=on_save).pack(side="left", padx=12)
    ttk.Button(btn_frame, text="取消", command=root.destroy).pack(side="left", padx=12)

    # Center on screen
    root.update_idletasks()
    w, h = root.winfo_reqwidth(), root.winfo_reqheight()
    x = (root.winfo_screenwidth() - w) // 2
    y = (root.winfo_screenheight() - h) // 2
    root.geometry(f"+{x}+{y}")
    root.lift()
    root.focus_force()

    root.mainloop()
    return result[0]


# ---------------------------------------------------------------------------
# Reporter
# ---------------------------------------------------------------------------
class Reporter:
    """Handles sending reports to the backend with exponential backoff."""

    MAX_BACKOFF = 60
    PAUSE_AFTER_FAILURES = 5
    PAUSE_DURATION = 300

    def __init__(self, server_url: str, token: str, emoji: str, ttl: int):
        self.endpoint = server_url
        self.token = token
        self.emoji = emoji
        self.ttl = ttl
        self.session = requests.Session()
        self.session.headers.update({
            "Content-Type": "application/json",
            "Accept": "application/json",
            "User-Agent": (
                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                "AppleWebKit/537.36 (KHTML, like Gecko) "
                "Chrome/124.0.0.0 Safari/537.36"
            ),
        })
        self._consecutive_failures = 0
        self._current_backoff = 0
        self._pause_until = 0.0

    def send(self, desc: str) -> bool:
        if self.pause_remaining > 0:
            return False

        payload = {
            "key": self.token,
            "emoji": self.emoji,
            "desc": desc[:256],
            "ttl": self.ttl,
        }
        try:
            resp = self.session.post(self.endpoint, json=payload, timeout=10)
            if resp.status_code in (200, 201, 409):
                self._consecutive_failures = 0
                self._current_backoff = 0
                self._pause_until = 0.0
                return True
            log.warning("Server %d: %s", resp.status_code, resp.text[:200])
        except requests.RequestException as e:
            log.warning("Request failed: %s", e)

        self._consecutive_failures += 1
        if self._current_backoff == 0:
            self._current_backoff = 5
        else:
            self._current_backoff = min(self._current_backoff * 2, self.MAX_BACKOFF)

        if self._consecutive_failures >= self.PAUSE_AFTER_FAILURES:
            log.warning("Failed %d times, pausing %ds", self._consecutive_failures, self.PAUSE_DURATION)
            self._pause_until = time.monotonic() + self.PAUSE_DURATION
            self._consecutive_failures = 0
            self._current_backoff = 0
        return False

    @property
    def backoff(self) -> float:
        return self._current_backoff

    @property
    def pause_remaining(self) -> float:
        remaining = self._pause_until - time.monotonic()
        if remaining <= 0:
            self._pause_until = 0.0
            return 0.0
        return remaining

    @property
    def retry_delay(self) -> float:
        return self.pause_remaining or self.backoff


# ---------------------------------------------------------------------------
# System Tray
# ---------------------------------------------------------------------------
shutdown_event = threading.Event()


def _make_tray_icon(color: str = "green") -> "PIL.Image.Image":
    """Generate a colored circle icon for the system tray."""
    from PIL import Image, ImageDraw
    size = 64
    img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
    draw = ImageDraw.Draw(img)
    colors = {"green": (76, 175, 80), "orange": (255, 152, 0), "gray": (158, 158, 158)}
    rgb = colors.get(color, colors["gray"])
    draw.ellipse([8, 8, size - 8, size - 8], fill=(*rgb, 255))
    return img


class TrayAgent:
    """System tray with Chinese UI, hover tooltip, and integrated settings."""

    def __init__(self):
        import pystray
        self._pystray = pystray
        self._lock = threading.Lock()
        self._status = "初始化中"
        self._current_target = ""
        self._icon: pystray.Icon | None = None
        self._settings_requested = False
        self._icons = {
            "green": _make_tray_icon("green"),
            "orange": _make_tray_icon("orange"),
            "gray": _make_tray_icon("gray"),
        }

    def _build_menu(self):
        p = self._pystray
        return p.Menu(
            p.MenuItem(lambda _: f"状态: {self._get_status()}", None, enabled=False),
            p.MenuItem(lambda _: f"当前: {self._get_current() or '无'}", None, enabled=False),
            p.Menu.SEPARATOR,
            p.MenuItem("日志文件", self._toggle_log,
                       checked=lambda _: _file_handler is not None),
            p.MenuItem("开机自启", self._toggle_autostart,
                       checked=lambda _: is_autostart_enabled()),
            p.MenuItem("设置", self._open_settings),
            p.Menu.SEPARATOR,
            p.MenuItem("退出", self._quit),
        )

    def _get_status(self) -> str:
        with self._lock:
            return self._status

    def _get_current(self) -> str:
        with self._lock:
            return self._current_target

    def update_status(self, status: str, current_target: str | None = None):
        with self._lock:
            self._status = status
            if current_target is not None:
                self._current_target = current_target
            current_target_value = self._current_target
        if self._icon:
            color = {"在线": "green"}.get(status, "gray")
            self._icon.icon = self._icons[color]
            # Hover tooltip shows current app + status.
            tip = "Live Dashboard"
            if current_target_value:
                tip += f"\n当前: {current_target_value}"
            tip += f"\n{status}"
            self._icon.title = tip[:127]

    def _toggle_log(self):
        enabled = _file_handler is None
        set_file_logging(enabled)
        cfg = load_config()
        cfg["enable_log"] = enabled
        save_config(cfg)
        if self._icon:
            self._icon.update_menu()

    def _toggle_autostart(self):
        enabled = is_autostart_enabled()
        if enabled:
            registry_ok = _set_registry_autostart(False)
            legacy_ok = _remove_legacy_startup_task()
            if registry_ok and legacy_ok:
                log.info("Autostart disabled")
            else:
                show_message(
                    "Live Dashboard",
                    "关闭开机自启时未能清理全部启动项。\n请检查任务计划程序中的 LiveDashboardAgent。",
                    error=True,
                )
        else:
            if _set_registry_autostart(True):
                log.info("Autostart enabled")
            else:
                show_message(
                    "Live Dashboard",
                    "无法开启开机自启，请检查当前账户是否有写入启动项的权限。",
                    error=True,
                )
        if self._icon:
            self._icon.update_menu()

    def _open_settings(self):
        self._settings_requested = True
        if self._icon:
            self._icon.stop()

    def _quit(self):
        shutdown_event.set()
        if self._icon:
            self._icon.stop()
        logging.shutdown()
        os._exit(0)

    @property
    def settings_requested(self) -> bool:
        return self._settings_requested

    def run(self):
        """Run the tray icon (blocking; call from main thread)."""
        icon_path = base_dir / "icon.ico"
        if icon_path.exists():
            from PIL import Image
            with Image.open(icon_path) as im:
                icon_img = im.copy()
        else:
            icon_img = _make_tray_icon("gray")
        self._icon = self._pystray.Icon(
            "live-dashboard",
            icon_img,
            "Live Dashboard",
            menu=self._build_menu(),
        )
        self._icon.run()


# ---------------------------------------------------------------------------
# Monitor loop
# ---------------------------------------------------------------------------
def _monitor_loop(cfg: dict, reporter: Reporter, tray: TrayAgent | None) -> None:
    heartbeat_interval = cfg["heartbeat_seconds"]
    
    sensitive_regex_str = cfg.get("sensitive_words_regex", "")
    sensitive_regex = None
    if sensitive_regex_str:
        import re
        try:
            sensitive_regex = re.compile(sensitive_regex_str)
        except re.error:
            pass

    prev_app: str | None = None
    prev_title: str | None = None
    last_report_time: float = 0

    log.info(
        "Monitoring - poll=%ds, heartbeat=%ds",
        MONITOR_POLL_SECONDS, heartbeat_interval,
    )

    while not shutdown_event.is_set():
        try:
            now = time.time()

            info = get_foreground_info()
            if info is None:
                shutdown_event.wait(MONITOR_POLL_SECONDS)
                continue

            app_id, title = info

            if sensitive_regex and sensitive_regex.search(title):
                title = ""

            # Keep tray status responsive; current item is updated only after a successful report.
            if tray:
                tray.update_status("在线")

            changed = app_id != prev_app or title != prev_title
            heartbeat_due = (now - last_report_time) >= heartbeat_interval

            if changed or heartbeat_due:
                reported_target = format_report_desc(app_id, title)
                success = reporter.send(reported_target)
                if success:
                    prev_app = app_id
                    prev_title = title
                    last_report_time = now
                    if tray:
                        tray.update_status("在线", reported_target)
                    if changed:
                        log.info("Reported: %s", reported_target)
                elif reporter.retry_delay > 0:
                    shutdown_event.wait(reporter.retry_delay)
                    continue

            shutdown_event.wait(MONITOR_POLL_SECONDS)

        except Exception as e:
            log.error("Error: %s", e, exc_info=True)
            shutdown_event.wait(MONITOR_POLL_SECONDS)

    log.info("Monitor stopped")


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------
def main() -> None:
    log.info("Live Dashboard Windows Agent")

    while True:
        cfg = load_config()

        # No valid config 鈫?show settings dialog
        if not cfg.get("server_url") or not cfg.get("token") or cfg.get("token") == "YOUR_TOKEN_HERE":
            cfg = show_settings_dialog(cfg)
            if cfg is None:
                return
            cfg = load_config()

        err = validate_config(cfg)
        if err:
            log.warning("Invalid config: %s", err)
            cfg = show_settings_dialog(cfg)
            if cfg is None:
                return
            cfg = load_config()
            continue

        # Apply log preference
        set_file_logging(cfg.get("enable_log", False))
        if cfg.get("enable_log"):
            log.info("HTTP: %s", "HTTPS" if cfg["server_url"].startswith("https") else "HTTP (内网)")

        reporter = Reporter(
            cfg["server_url"],
            cfg["token"],
            cfg.get("emoji", ""),
            cfg["heartbeat_seconds"],
        )

        tray: TrayAgent | None = None
        try:
            tray = TrayAgent()
        except ImportError:
            log.warning("pystray/Pillow not installed, running without tray")
        except Exception as e:
            log.warning("Tray init failed: %s", e)

        if tray:
            monitor = threading.Thread(
                target=_monitor_loop, args=(cfg, reporter, tray), daemon=True
            )
            monitor.start()
            tray.run()  # Blocks until quit or settings
            shutdown_event.set()
            monitor.join(timeout=5)

            if tray.settings_requested:
                shutdown_event.clear()
                new_cfg = show_settings_dialog(cfg)
                if new_cfg is None:
                    continue  # Cancelled, restart with old config
                continue  # Restart with new config
            else:
                break  # Quit
        else:
            try:
                _monitor_loop(cfg, reporter, None)
            except KeyboardInterrupt:
                pass
            break

    log.info("Agent stopped")


if __name__ == "__main__":
    main()

同级目录创建配置文件config.json:

{
  "server_url": "https://example.com/api/v2/fn/shiro/status",
  "token": "<YOUR_API_KEY>",
  "emoji": "💻",
  "heartbeat_seconds": 60,
  "sensitive_words_regex": "(?:敏感词1|敏感词2|敏感词3)|(?:[a-zA-Z]:\\\\[^<>:\"/|?*]*)", //正则式过滤敏感和文件路径
  "enable_log": false
}

优化函数以处理多Agent

为了处理两个设备同时对api上报的情况，修改了以下函数，默认优先展示电脑的状态：

interface Status {
  emoji: string
  icon?: string
  desc?: string
  ttl: number
  untilAt: number
  device: 'desktop' | 'phone'
  updatedAt: number
}

type Device = Status['device']

const cachePrefix = 'shiro:status'
const legacyCacheKey = 'shiro:status'
const desktopCacheKey = `${cachePrefix}:desktop`
const phoneCacheKey = `${cachePrefix}:phone`

const DEFAULT_TTL = 86400 // 1 day
const MAX_TTL = 7 * 86400 // 7 days

function getBody(ctx: Context) {
  const body = ctx.req.body

  if (!body) return {}

  if (typeof body === 'string') {
    try {
      return JSON.parse(body)
    } catch {
      return {}
    }
  }

  return body
}

function assertAuth(ctx: Context) {
  const body = getBody(ctx)
  const authKey = ctx.secret?.key

  if (ctx.isAuthenticated) return

  if (!authKey) {
    ctx.throws(500, 'Missing auth key')
  }

  if (body.key !== authKey) {
    ctx.throws(401, 'Unauthorized')
  }
}

export default async function handler(ctx: Context) {
  const method = String(ctx.req.method || '').toLowerCase()

  switch (method) {
    case 'get':
      return await GET(ctx)

    case 'post':
      assertAuth(ctx)
      return await POST(ctx)

    case 'delete':
      assertAuth(ctx)
      return await DELETE(ctx)

    case 'options':
      return OPTIONS()

    default:
      ctx.throws(405, 'Method Not Allowed')
  }
}

function getCacheKeyByDevice(device: Device) {
  return device === 'desktop' ? desktopCacheKey : phoneCacheKey
}

function normalizeEmoji(input: unknown) {
  let text = String(input ?? '').trim()

  try {
    if (/%[0-9A-Fa-f]{2}/.test(text)) {
      text = decodeURIComponent(text)
    }
  } catch {
    // ignore
  }

  try {
    if (/\\u[0-9A-Fa-f]{4}/.test(text)) {
      text = JSON.parse(`"${text.replace(/"/g, '\\"')}"`)
    }
  } catch {
    // ignore
  }

  return text
    .normalize('NFC')
    .replace(/\uFE0F/g, '')
    .trim()
}

function detectDevice(rawEmoji: unknown): Device | null {
  const emoji = normalizeEmoji(rawEmoji)

  if (emoji.includes('💻')) return 'desktop'
  if (emoji.includes('📱')) return 'phone'

  return null
}

function normalizeTTL(input: unknown) {
  const ttl = Number(input ?? DEFAULT_TTL)

  if (!Number.isFinite(ttl) || ttl <= 0) {
    return DEFAULT_TTL
  }

  return Math.min(Math.floor(ttl), MAX_TTL)
}

function parseStatus(raw: unknown): Status | null {
  if (!raw) return null

  try {
    const status = typeof raw === 'string' ? JSON.parse(raw) : raw

    if (!status || typeof status !== 'object') return null
    if (typeof status.emoji !== 'string') return null
    if (typeof status.untilAt !== 'number') return null

    if (status.untilAt <= Date.now()) return null

    return status as Status
  } catch {
    return null
  }
}

async function getStatusByKey(ctx: Context, key: string) {
  const raw = await ctx.storage.cache.get(key)
  return parseStatus(raw)
}

async function getActiveStatus(ctx: Context): Promise<Status | null> {
  const desktopStatus = await getStatusByKey(ctx, desktopCacheKey)
  const phoneStatus = await getStatusByKey(ctx, phoneCacheKey)

  // 两个设备都有效时，优先返回电脑状态
  if (desktopStatus) return desktopStatus
  if (phoneStatus) return phoneStatus

  return null
}

async function DELETE(ctx: Context) {
  await ctx.storage.cache.del(desktopCacheKey)
  await ctx.storage.cache.del(phoneCacheKey)

  // 顺手清理旧版本遗留缓存
  await ctx.storage.cache.del(legacyCacheKey)

  ctx.broadcast('shiro#status', null)

  return null
}

async function POST(ctx: Context) {
  const body = getBody(ctx)

  const rawEmoji = body.emoji
  const emoji = normalizeEmoji(rawEmoji)

  if (!emoji) {
    ctx.throws(400, 'Missing emoji')
  }

  const device = detectDevice(emoji)

  if (!device) {
    ctx.throws(
      400,
      `Emoji must contain 📱 or 💻, received: ${JSON.stringify(rawEmoji)}`
    )
  }

  const ttl = normalizeTTL(body.ttl)
  const now = Date.now()

  const status: Status = {
    emoji,
    icon: typeof body.icon === 'string' ? body.icon : undefined,
    desc: typeof body.desc === 'string' ? body.desc : undefined,
    ttl,
    untilAt: now + ttl * 1000,
    updatedAt: now,
    device,
  }

  await ctx.storage.cache.set(
    getCacheKeyByDevice(device),
    JSON.stringify(status),
    ttl
  )

  const activeStatus = await getActiveStatus(ctx)

  ctx.broadcast('shiro#status', activeStatus)

  return activeStatus ? JSON.stringify(activeStatus) : null
}

async function GET(ctx: Context) {
  const activeStatus = await getActiveStatus(ctx)

  return activeStatus ? JSON.stringify(activeStatus) : null
}

function OPTIONS() {
  return null
}

:::note 这里通过 emoji 📱和💻来区分 Android 和 Windows Agent，这是为了前端展示美观。你也可以换为其他字符。 :::

享受被视奸的快感吧

在Github Action构建完 Yohaku 部署到服务器后自动清除CDN缓存，以立即应用新的更改

适用于

https://github.com/innei-dev/yohaku-deploy-action/

:::note 使用下面的代码注意评估源站的承受能力 :::

需要添加的Secret有：

修改depoly.yml

//约第 236 行附近

ClearCDNCache:
    name: Clear Tencent EdgeOne CDN cache
    runs-on: ubuntu-latest
    needs: deploy
    steps:
      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Tencent Cloud SDK
        run: npm install tencentcloud-sdk-nodejs --no-save --no-package-lock

      - name: Purge cache with Tencent Cloud SDK
        env:
          TENCENT_CLOUD_SECRET_ID: ${{ secrets.TENCENT_CLOUD_SECRET_ID }}
          TENCENT_CLOUD_SECRET_KEY: ${{ secrets.TENCENT_CLOUD_SECRET_KEY }}
          TENCENT_CDN_DOMAIN: ${{ secrets.TENCENT_CDN_DOMAIN }}
          TENCENT_EDGEONE_ZONE_ID: ${{ secrets.TENCENT_EDGEONE_ZONE_ID }}
        run: |
          cat > clearCache.js <<'EOF'
          const tencentcloud = require("tencentcloud-sdk-nodejs");

          const requiredEnv = [
            "TENCENT_CLOUD_SECRET_ID",
            "TENCENT_CLOUD_SECRET_KEY",
            "TENCENT_CDN_DOMAIN",
            "TENCENT_EDGEONE_ZONE_ID",
          ];

          const missingEnv = requiredEnv.filter((name) => !process.env[name] || !process.env[name].trim());
          if (missingEnv.length > 0) {
            console.error(`Missing required environment variables: ${missingEnv.join(", ")}`);
            process.exit(1);
          }

          const TeoClient = tencentcloud.teo.v20220901.Client;
          const client = new TeoClient({
            credential: {
              secretId: process.env.TENCENT_CLOUD_SECRET_ID,
              secretKey: process.env.TENCENT_CLOUD_SECRET_KEY,
            },
            region: "",
            profile: {
              httpProfile: {
                endpoint: "teo.tencentcloudapi.com",
              },
            },
          });

          const params = {
            Targets: [process.env.TENCENT_CDN_DOMAIN.trim()],
            Type: "purge_host",
            ZoneId: process.env.TENCENT_EDGEONE_ZONE_ID.trim(),
          };

          async function main() {
            const data = await client.CreatePurgeTask(params);
            console.log(JSON.stringify(data, null, 2));

            const failedList = data?.FailedList ?? data?.Response?.FailedList ?? [];
            if (Array.isArray(failedList) && failedList.length > 0) {
              console.error("Tencent EdgeOne purge task contains failed targets:");
              console.error(JSON.stringify(failedList, null, 2));
              process.exit(1);
            }
          }

          main().catch((error) => {
            console.error("Tencent EdgeOne purge failed:", error);
            process.exit(1);
          });
          EOF

          node clearCache.js

//约第 315 行附近
    needs: [ClearCDNCache, build]

修改后推送触发Action，查看日志，输出

{
  "RequestId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxx",
  "FailedList": [],
  "JobId": "xxxxxxxxx"
}

代表清除缓存成功。

引入

部署完Yohaku后注意到mx-space管理后台只能设置Github, Weibo, 哔哩哔哩, 网易云音乐这四个社交链接。但是在 Innei 的主页可以看到不止这四个链接

分析

:::warning 以下做法仅供参考，因为有可能可以在云函数部分配置，但是我没找到 :::

通过在mx-space后台更新社交链接时打开控制台或抓包易知： 浏览器通过请求 PATCH https://example.com/api/v2/owner 来更新社交链接

请求体为

{
  "socialIds": {
    "github": "username",
    "bilibili": "id"
    // ...
  }
}

分析源代码SocialIcon.tsx：

//第 19 行附近
export const socialIconSet: Record<
  string,
  [string, ReactNode, string, (id: string) => string]
> = {
  github: [
    'Github',
    <i className="i-mingcute-github-line" />,
    '#181717',
    (id) => `https://github.com/${id}`,
  ],
  twitter: [
    'Twitter',
    <i className="i-mingcute-twitter-line" />,
    '#1DA1F2',
    (id) => `https://twitter.com/${id}`,
  ],
  x: ['X', <XIcon />, 'rgba(36,46,54,1.00)', (id) => `https://x.com/${id}`],
  telegram: [
    'Telegram',
    <i className="i-mingcute-telegram-line" />,
    '#0088cc',
    (id) => `https://t.me/${id}`,
  ],
  mail: [
    'Email',
    <i className="i-mingcute-mail-line" />,
    '#D44638',
    (id) => `mailto:${id}`,
  ],
  get email() {
    return this.mail
  },
  get feed() {
    return this.rss
  },
  rss: ['RSS', <i className="i-mingcute-rss-line" />, '#FFA500', (id) => id],
  bilibili: [
    '哔哩哔哩',
    <BilibiliIcon />,
    '#00A1D6',
    (id) => `https://space.bilibili.com/${id}`,
  ],
  netease: [
    '网易云音乐',
    <NeteaseCloudMusicIcon />,
    '#C20C0C',
    (id) => `https://music.163.com/#/user/home?id=${id}`,
  ],
  qq: [
    'QQ',
    <i className="i-mingcute-qq-fill" />,
    '#1e6fff',
    (id) => `https://wpa.qq.com/msgrd?v=3&uin=${id}&site=qq&menu=yes`,
  ],
  wechat: [
    '微信',
    <i className="i-mingcute-wechat-fill" />,
    '#2DC100',
    (id) => id,
  ],
  weibo: [
    '微博',
    <i className="i-mingcute-weibo-line" />,
    '#E6162D',
    (id) => `https://weibo.com/${id}`,
  ],
  discord: [
    'Discord',
    <i className="i-mingcute-discord-fill" />,
    '#7289DA',
    (id) => `https://discord.gg/${id}`,
  ],
  bluesky: [
    'Bluesky',
    <BlueskyIcon />,
    '#0085FF',
    (id) => `https://bsky.app/profile/${id}`,
  ],
  steam: [
    'Steam',
    <SteamIcon />,
    '#0F1C30',
    (id) => `https://steamcommunity.com/id/${id}`,
  ],
}

可知，还可以定义的有

• Twitter
• X
• Telegram
• QQ
• Wechat
• mail
• RSS
• Bluesky
• Discord
• Steam

:::note 由于QQ临时会话的接口已不再适用，可以改为直接跳转到 id，并填入 添加好友 或 入群链接

  qq: [
    'QQ',
    <i className="i-mingcute-qq-fill" />,
    '#1e6fff',
    (id) => id,
  ],

:::

添加更多链接

因此可以通过 Reqable 抓包然后加上这部分内容再发送给服务器更新社交链接

示例：

{
  "socialIds": {
    "github": "Elvish064",
    "bilibili": "1613372234",
    "X": "Elvish064",
    "telegram": "Elvish064",
    "qq": "https://qm.qq.com/cgi-bin/qm/qr?k=bLl4uuTl3BK2rKissNgVgdHyk22korJ4&jump_from=webapi&authKey=XIkvyvxvUHQ+MrpO3evV827wT3bHzxNtEYTzxKvqgbInpbPe4scR3S2JJuQSa3nY",
    "mail": "elvish@elvish.me",
    "rss": "https://www.elvish.me/feed"
  }
}

现在刷新一下主页，应该也有一排数个社交链接了。

引入

原版的Yohaku只能展示一个ICP，在云函数部分配置:

{
  "footer": {
    "otherInfo": {
      "date": "2024-{{now}}",
      "icp": {
        "text": "萌 ICP 备 20250030 号",
        "link": "https://icp.gov.moe/?keyword=20250030"
      }
    },
    //....

但是对于既有萌ICP，又有标准ICP备案的情况就左右为难了

修改源码

通过修改两个文件可以实现展示多个备案号：

在app.config.d.ts的 36 行附近添加新定义的moeicp

//第 36 行附近
  export interface OtherInfo {
    date: string
    icp?: {
      text: string
      link: string
    }
    moeicp?: {
      text: string
      link: string
    }
  }

在FooterInfo.tsx的 36 行附近添加新定义的moeicp

//第 35 行附近
  const { date: dateRaw, icp } = otherInfo || {}
  const { date: dateRaw, icp, moeicp } = otherInfo || {}
  const displayMoeIcp = moeicp
  
//第 98 行附近
            {(icp || displayMoeIcp) && (
              <div className="mt-0.5 flex flex-wrap items-center gap-4">
                {icp && (
                  <StyledLink external href={icp.link} rel="noreferrer">
                    {icp.text}
                  </StyledLink>
                )}
                {displayMoeIcp && (
                  <StyledLink external href={displayMoeIcp.link} rel="noreferrer">
                    {displayMoeIcp.text}
                  </StyledLink>
                )}
              </div>
            )}

//第 155 行附近
   </span>
        {(icp || displayMoeIcp) && (
          <span className="flex items-center gap-4 text-sm text-neutral-6">
            {icp && (
              <StyledLink external href={icp.link} rel="noreferrer">
                {icp.text}
              </StyledLink>
            )}
            {displayMoeIcp && (
              <StyledLink external href={displayMoeIcp.link} rel="noreferrer">
                {displayMoeIcp.text}
              </StyledLink>
            )}
          </span>
        )}
      </div>

新增配置文件

增加云函数部分的配置，以展示两个备案号了

{
  "footer": {
    "otherInfo": {
      "date": "2020-{{now}}",
      "icp": {
        "text": "渝 ICP 备 2025073510 号",
        "link": "https://beian.miit.gov.cn/"
      },
      "moeicp": {
        "text": "萌 ICP 备 20250030 号",
        "link": "https://icp.gov.moe/?keyword=20250030"
      }
    },
    //....