koishi-plugin-cnb-bot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 harcochen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# Koishi CNB 报障助手
+
+Koishi 插件版 CNB 报障助手。用户发送 `debug [故障描述]` 后上传一个 `.zip` 或 `.log` 文件；插件把原始文件上传到 CNB、创建 Issue、请求配置好的 NPC 分析，并把已验证的分析结果发回会话。
+
+## 安装
+
+需要 Node.js 18 或更高版本。在 Koishi 项目目录运行 `npm install ../cnb-bot-koishi`（按本机目录调整路径），然后在 Koishi 配置中加载 `koishi-plugin-cnb-bot`。确保已经启用数据库服务（例如 `@koishijs/plugin-database-sqlite`），默认无需指令前缀，直接发送 `debug`；如果自定义了 Koishi 的全局指令前缀，请按实际配置调用。
+
+本插件需要 Koishi v4 和支持文件消息的聊天适配器。QQ OneBot 用户需要确认适配器能接收群文件/文件消息，并支持合并转发；不支持合并转发的平台会收到普通文本结果。
+
+### Docker 挂载安装
+
+挂载源码目录并通过 `portal:` 安装时，需要先在插件目录执行 `npm install` 和 `npm run build`，确保挂载目录包含 `lib/index.js`。`package.json` 的入口指向这个构建文件，Koishi 不会直接加载 `src/index.ts`。安装依赖时请使用与容器兼容的 Node.js 环境。
+
+如果控制台提示“此插件未声明配置项”，请先确认容器中实际加载的入口存在且导出了 `Config`；加载失败也可能出现这一提示。本插件已声明配置 Schema。补齐构建产物后，重载 Koishi 应用（或重启 Koishi 容器），让控制台重新读取插件配置。
+
+## 配置
+
+| 配置 | 说明 |
+| --- | --- |
+| `cnb_repository` | CNB 仓库路径，例如 `group/repo`。必填 |
+| `cnb_token` | CNB 令牌，需要 `repo-issue:rw`、`repo-notes:r`、`repo-notes:rw` 权限 |
+| `group_whitelist` | 启用功能的群号；留空时所有群都不启用 |
+| `private_whitelist` | 私信用户白名单；留空时允许所有人私信报障 |
+| `npc_mention` | Issue 评论中用于触发 NPC 的提及文本，默认 `@CodeBuddy` |
+| `npc_author_ids` / `npc_author_usernames` | NPC 评论作者白名单。至少配置一项，并核对仓库中实际的作者 ID 或 username |
+| `assistant_name` | 在聊天中显示的分析助手名称 |
+| `log_location_hint` | 开始报障时附加的日志位置说明 |
+| `log_wait_minutes` | 等待日志上传时间，默认 10 分钟 |
+| `analysis_wait_minutes` | 等待 NPC 分析时间，默认 20 分钟 |
+| `recovery_confirm_minutes` | 等待用户确认问题是否解决，默认 30 分钟 |
+| `max_log_file_mib` | 单个日志文件大小上限，默认 20 MiB |
+| `poll_interval_seconds` | NPC 评论轮询间隔，默认 10 秒 |
+| `issue_check_interval_seconds` | 用户确认阶段的 Issue 检查间隔，默认 30 秒 |
+| `cnb_api_endpoint` / `cnb_web_endpoint` | CNB API 和网页地址，必须使用 HTTPS |
+| `file_url_host_allowlist` | 可选的日志下载域名白名单；即使留空，也会拒绝内网和保留地址 |
+
+其余配置用于控制结果发送重试次数、发送超时和历史保留天数。
+
+## 指令
+
+| 指令 | 作用 |
+| --- | --- |
+| `debug [描述]` | 开始报障，描述作为 Issue 标题 |
+| `debug status` | 查看当前报障进度 |
+| `debug analyze` | 补充信息后请求 NPC 重新分析 |
+| `debug resolve` | 确认问题已解决并关闭 Issue |
+| `debug cancel` | 取消当前报障；已创建的 Issue 保留 |
+| `debug help` | 查看指令说明 |
+
+Issue 创建后，在群里 @机器人并附上文字，或在私信中直接发送文字，可以把补充说明写入 Issue 评论。每个用户在同一个群或私信会话中同时只能有一个未结束的报障。
+
+## 隐私与文件处理
+
+上传的日志原样提交给 CNB。插件不解压、不读取、不扫描，也不脱敏日志；故障描述作为 Issue 标题，用户主动发送的补充文字会作为评论提交。开始报障时会提醒用户确认文件不含隐私内容。
+
+日志下载仅接受 `.zip` 和 `.log`，受大小上限约束。HTTP(S) 下载会检查每次重定向、域名白名单和解析到的 IP 地址，拒绝本机、内网及保留地址。临时文件存放在 Koishi 项目目录下的 `data/koishi-plugin-cnb-bot/`，成功上传或报障结束后会删除。
+
+报障状态存储在 Koishi 配置的数据库中，其中包括平台、机器人、群/频道、用户、Issue 编号和处理状态。插件不读取群聊历史；只有发起报障后用户主动提交的描述、日志附件和补充文字会进入 CNB。插件重启后会恢复未完成的流程。CNB Issue 创建请求若因连接中断而无法确认，插件会暂停并提示管理员按追踪编号核对，避免重复创建。
+
+## 开发
+
+```sh
+npm install
+npm run build
+```
+
+## GitHub Actions 打包和发布
+
+提交分支或创建 PR 会触发 `ci.yml`：通过 `npm ci` 安装锁定依赖并构建，检查插件入口、配置 Schema 和发布文件，再把 `.tgz` 安装包保存到 Actions 的 `npm-package` artifact。
+
+推送 `v版本号` 标签会触发 `publish.yml`，自动构建、检查、打包并发布到 npm。标签必须与 `package.json` 的版本一致，例如版本 `0.1.1` 对应标签 `v0.1.1`。正式版本使用 `latest`，包含预发布标识的版本使用 `next`。
+
+### 首次配置
+
+本工作流使用 [npm Trusted Publisher](https://docs.npmjs.com/trusted-publishers/)，通过 GitHub OIDC 认证，无需配置 npm Token Secret。
+
+如果 npm 上还没有 `koishi-plugin-cnb-bot`，先在本机登录 npm 并发布第一个版本：
+
+```sh
+npm login --registry=https://registry.npmjs.org
+npm publish --access public --registry=https://registry.npmjs.org
+```
+
+然后打开 npm 包的 Settings，在 Trusted Publisher 中选择 GitHub Actions，填写：
+
+| 字段 | 值 |
+| --- | --- |
+| Organization or user | `HarcoChen` |
+| Repository | `cnb-bot-koishi` |
+| Workflow filename | `publish.yml`，只填写文件名 |
+| Environment name | 留空 |
+| Allowed actions（如显示） | 允许直接执行 `npm publish` |
+
+保存后，把工作流和 `package-lock.json` 提交到 GitHub。首次发布已占用的版本号不能重复发布。
+
+### 发布后续版本
+
+确认当前工作区的代码已经提交，再执行：
+
+```sh
+npm version patch
+git push origin main
+git push origin v0.1.1
+```
+
+`npm version patch` 会同时更新 `package.json` 和锁文件、创建版本提交及 `v版本号` 标签。上面的 `v0.1.1` 是从 `0.1.0` 升级的示例，请替换为命令实际生成的标签；推送后，在 GitHub 的 Actions 页面查看发布结果。发布成功后可以从 npm 安装，也可以下载 Actions 保存的 `.tgz` 文件。

package/lib/client.d.ts

@@ -0,0 +1,33 @@
+export declare class CNBAPIError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+export declare class CNBNetworkError extends Error {
+    constructor(message: string);
+}
+export interface Asset {
+    asset_link: string;
+    download_url?: string;
+    name?: string;
+}
+export declare class CNBClient {
+    private token;
+    readonly api: string;
+    readonly web: string;
+    readonly repository: string;
+    constructor(apiEndpoint: string, webEndpoint: string, repository: string, token: string);
+    private repoPath;
+    private json;
+    issueUrl(number: string): string;
+    uploadAttachment(filePath: string, filename: string, size: number): Promise<Asset>;
+    createIssue(title: string, body: string): Promise<any>;
+    getIssue(number: string): Promise<any>;
+    closeIssue(number: string): Promise<any>;
+    createComment(number: string, body: string): Promise<any>;
+    listComments(number: string): Promise<any[]>;
+}
+export declare function stageFile(sourceUrl: string, filename: string, destination: string, maxBytes: number, allowlist: ReadonlySet<string>): Promise<{
+    name: string;
+    size: number;
+    suffix: string;
+}>;

package/lib/client.js

@@ -0,0 +1,382 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CNBClient = exports.CNBNetworkError = exports.CNBAPIError = void 0;
+exports.stageFile = stageFile;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:dns/promises");
+const node_http_1 = require("node:http");
+const node_https_1 = require("node:https");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const promises_2 = require("node:stream/promises");
+const node_net_1 = require("node:net");
+const node_url_1 = require("node:url");
+class CNBAPIError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'CNBAPIError';
+    }
+}
+exports.CNBAPIError = CNBAPIError;
+class CNBNetworkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CNBNetworkError';
+    }
+}
+exports.CNBNetworkError = CNBNetworkError;
+class CNBClient {
+    token;
+    api;
+    web;
+    repository;
+    constructor(apiEndpoint, webEndpoint, repository, token) {
+        this.token = token;
+        this.api = endpoint(apiEndpoint, 'CNB API');
+        this.web = endpoint(webEndpoint, 'CNB 网页');
+        this.repository = repository.trim().replace(/^\/+|\/+$/g, '');
+        if (!this.repository || this.repository.split('/').some(part => !part || part === '.' || part === '..')) {
+            throw new TypeError('CNB 仓库路径格式无效。');
+        }
+        if (!token.trim())
+            throw new TypeError('请先在插件配置中填写 CNB 访问令牌。');
+        this.token = token.trim();
+    }
+    repoPath() {
+        return this.repository.split('/').map(encodeURIComponent).join('/');
+    }
+    async json(method, path, body, query) {
+        const url = new URL(`${this.api}/${path.replace(/^\//, '')}`);
+        if (query)
+            for (const [key, value] of Object.entries(query))
+                url.searchParams.set(key, String(value));
+        let response;
+        try {
+            response = await fetch(url, {
+                method,
+                headers: {
+                    Accept: 'application/json',
+                    Authorization: `Bearer ${this.token}`,
+                    ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+                    'User-Agent': 'Koishi-CNB-Report/0.1',
+                },
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: AbortSignal.timeout(30_000),
+            });
+        }
+        catch (error) {
+            throw new CNBNetworkError(`CNB API 网络请求结果不确定：${errorMessage(error)}`);
+        }
+        let raw = '';
+        if (response.body) {
+            const reader = response.body.getReader();
+            const chunks = [];
+            let total = 0;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    total += value.byteLength;
+                    if (total > 4 * 1024 * 1024) {
+                        await reader.cancel();
+                        throw new CNBAPIError('CNB API 响应超过 4 MiB 限制。', response.status);
+                    }
+                    chunks.push(value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            raw = Buffer.concat(chunks.map(chunk => Buffer.from(chunk))).toString('utf8');
+        }
+        let data = {};
+        if (raw) {
+            try {
+                data = JSON.parse(raw);
+            }
+            catch {
+                throw new CNBAPIError('CNB API 返回了无法解析的 JSON。', response.status);
+            }
+        }
+        if (!response.ok) {
+            const reason = data?.errmsg || data?.message || response.statusText;
+            throw new CNBAPIError(`CNB API 请求失败（HTTP ${response.status}）：${reason}`, response.status);
+        }
+        return data;
+    }
+    issueUrl(number) {
+        return `${this.web}/${this.repoPath()}/-/issues/${encodeURIComponent(number)}`;
+    }
+    async uploadAttachment(filePath, filename, size) {
+        const name = filename.split(/[\\/]/).pop() || 'log.zip';
+        const contentType = (0, node_path_1.extname)(name).toLowerCase() === '.log' ? 'text/plain' : 'application/zip';
+        const created = await this.json('POST', `/${this.repoPath()}/-/issues/asset-groups`, {
+            file_assets: [{ name, size, content_type: contentType }],
+        });
+        const asset = (created?.file_upload_urls || created?.assets || [])[0];
+        if (!asset?.upload_url || !asset?.asset_link) {
+            throw new CNBAPIError('CNB 创建附件组时没有返回文件上传地址。');
+        }
+        const uploadUrl = new URL(asset.upload_url);
+        if (uploadUrl.protocol !== 'https:' || uploadUrl.username || uploadUrl.password) {
+            throw new CNBAPIError('CNB 返回的附件上传 URL 不是有效 HTTPS 地址。');
+        }
+        let response;
+        try {
+            const stream = (0, node_fs_1.createReadStream)(filePath);
+            response = await fetch(uploadUrl, {
+                method: 'PUT',
+                headers: { 'Content-Type': contentType, 'Content-Length': String(size) },
+                body: stream,
+                duplex: 'half',
+                signal: AbortSignal.timeout(120_000),
+            });
+        }
+        catch {
+            throw new CNBNetworkError('CNB 附件上传结果不确定，请检查 CNB 外部状态。');
+        }
+        if (!response.ok)
+            throw new CNBAPIError(`CNB 附件上传失败（HTTP ${response.status}）。`, response.status);
+        return { asset_link: String(asset.asset_link), download_url: String(asset.download_url || ''), name };
+    }
+    async createIssue(title, body) {
+        const result = await this.json('POST', `/${this.repoPath()}/-/issues`, { title, body });
+        if (!result || !result.number)
+            throw new CNBAPIError('CNB 创建 Issue 响应缺少 Issue 编号。');
+        return { ...result, html_url: result.html_url || this.issueUrl(String(result.number)) };
+    }
+    getIssue(number) {
+        return this.json('GET', `/${this.repoPath()}/-/issues/${encodeURIComponent(number)}`);
+    }
+    closeIssue(number) {
+        return this.json('PATCH', `/${this.repoPath()}/-/issues/${encodeURIComponent(number)}`, {
+            state: 'closed', state_reason: 'completed',
+        });
+    }
+    createComment(number, body) {
+        return this.json('POST', `/${this.repoPath()}/-/issues/${encodeURIComponent(number)}/comments`, { body });
+    }
+    async listComments(number) {
+        const comments = [];
+        for (let page = 1; page <= 20; page++) {
+            const result = await this.json('GET', `/${this.repoPath()}/-/issues/${encodeURIComponent(number)}/comments`, undefined, {
+                page, page_size: 100,
+            });
+            const batch = Array.isArray(result) ? result : result?.data;
+            if (!Array.isArray(batch))
+                throw new CNBAPIError('CNB 评论列表响应格式异常。');
+            comments.push(...batch);
+            if (batch.length < 100)
+                break;
+        }
+        return comments;
+    }
+}
+exports.CNBClient = CNBClient;
+function endpoint(value, label) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new TypeError(`${label}地址无效，必须使用 HTTPS。`);
+    }
+    if (url.protocol !== 'https:' || !url.hostname || url.username || url.password || url.search || url.hash) {
+        throw new TypeError(`${label}地址无效，必须使用 HTTPS。`);
+    }
+    return url.href.replace(/\/$/, '');
+}
+async function stageFile(sourceUrl, filename, destination, maxBytes, allowlist) {
+    const name = filename.replace(/\\/g, '/').split('/').pop() || 'log.zip';
+    const suffix = (0, node_path_1.extname)(name).toLowerCase();
+    if (suffix !== '.zip' && suffix !== '.log')
+        throw new Error('只接受 .zip 或 .log 日志文件，请重新上传。');
+    const size = sourceUrl.startsWith('file:')
+        ? await stageLocalFile(sourceUrl, destination, maxBytes)
+        : await downloadSafe(sourceUrl, destination, maxBytes, allowlist);
+    if (!size) {
+        await node_fs_1.promises.rm(destination, { force: true }).catch(() => { });
+        throw new Error('上传的日志文件为空。');
+    }
+    return { name, size, suffix };
+}
+async function stageLocalFile(sourceUrl, destination, maxBytes) {
+    const url = new URL(sourceUrl);
+    if (url.host && url.host !== 'localhost')
+        throw new Error('附件本地路径无效。');
+    let path;
+    try {
+        path = (0, node_url_1.fileURLToPath)(url);
+    }
+    catch {
+        throw new Error('附件本地路径无效。');
+    }
+    const info = await node_fs_1.promises.lstat(path).catch(() => undefined);
+    if (!info?.isFile() || info.isSymbolicLink())
+        throw new Error('无法读取这个日志文件，请重新上传。');
+    if (info.size > maxBytes)
+        throw sizeError(maxBytes);
+    try {
+        const size = await copyLimited((0, node_fs_1.createReadStream)(path), destination, maxBytes);
+        return size;
+    }
+    catch {
+        await node_fs_1.promises.rm(destination, { force: true }).catch(() => { });
+        throw new Error('读取日志文件失败，请重新上传。');
+    }
+}
+async function downloadSafe(initialUrl, destination, maxBytes, allowlist) {
+    let current = initialUrl;
+    const endAt = Date.now() + 120_000;
+    for (let redirects = 0; redirects <= 5; redirects++) {
+        const url = new URL(current);
+        if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password) {
+            throw new Error('附件下载链接无效。');
+        }
+        const address = await validateHost(url.hostname, allowlist);
+        const remaining = endAt - Date.now();
+        if (remaining <= 0)
+            throw new Error('下载日志文件超时，请重新上传。');
+        const response = await requestPinned(url, address, remaining);
+        const status = response.statusCode || 0;
+        if (status >= 300 && status < 400) {
+            const rawLocation = response.headers.location;
+            const location = Array.isArray(rawLocation) ? rawLocation[0] : rawLocation;
+            response.destroy();
+            if (!location || redirects === 5)
+                throw new Error('附件下载重定向无效或次数过多。');
+            current = new URL(location, url).href;
+            continue;
+        }
+        if (status < 200 || status >= 300) {
+            response.destroy();
+            throw new Error('下载日志文件失败，文件链接可能已过期，请重新上传。');
+        }
+        const length = Number(response.headers['content-length'] || 0);
+        if (length > maxBytes) {
+            response.destroy();
+            throw sizeError(maxBytes);
+        }
+        try {
+            return await copyLimited(response, destination, maxBytes);
+        }
+        catch (error) {
+            await node_fs_1.promises.rm(destination, { force: true }).catch(() => { });
+            if (Date.now() >= endAt)
+                throw new Error('下载日志文件超时，请重新上传。');
+            if (error instanceof Error && error.message.includes('大小上限'))
+                throw error;
+            throw new Error('下载日志文件失败，文件链接可能已过期，请重新上传。');
+        }
+    }
+    throw new Error('附件下载重定向次数过多。');
+}
+async function copyLimited(source, destination, maxBytes) {
+    let total = 0;
+    const limiter = new node_stream_1.Transform({
+        transform(chunk, _encoding, callback) {
+            total += chunk.length;
+            if (total > maxBytes)
+                callback(sizeError(maxBytes));
+            else
+                callback(null, chunk);
+        },
+    });
+    await (0, promises_2.pipeline)(source, limiter, (0, node_fs_1.createWriteStream)(destination, { flags: 'wx', mode: 0o600 }));
+    return total;
+}
+async function validateHost(hostname, allowlist) {
+    const host = hostname.toLowerCase().replace(/^\[|\]$/g, '').replace(/\.$/, '');
+    if (host === 'localhost' || host.endsWith('.local'))
+        throw new Error('拒绝访问本机或本地域名附件地址。');
+    const entries = [...allowlist].map(item => item.trim().toLowerCase().replace(/^\.|\.$/g, '')).filter(Boolean);
+    if (entries.length && !entries.some(item => host === item || host.endsWith(`.${item}`))) {
+        throw new Error('附件下载域名不在配置的白名单中。');
+    }
+    let addresses;
+    try {
+        const family = (0, node_net_1.isIP)(host);
+        addresses = family ? [{ address: host, family }] : await (0, promises_1.lookup)(host, { all: true, verbatim: true });
+    }
+    catch {
+        throw new Error('无法解析附件下载域名。');
+    }
+    if (!addresses.length || addresses.some(({ address }) => !isPublicAddress(address))) {
+        throw new Error('拒绝访问内网或保留地址附件链接。');
+    }
+    return addresses[0];
+}
+function requestPinned(url, address, timeout) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            method: 'GET',
+            agent: false,
+            headers: { Host: url.host },
+            signal: AbortSignal.timeout(timeout),
+            // Pin the socket's DNS result to the public IP that was validated above.
+            // The URL hostname remains unchanged for Host and TLS certificate checks.
+            lookup: (_hostname, lookupOptions, callback) => {
+                if (lookupOptions?.all)
+                    callback(null, [address]);
+                else
+                    callback(null, address.address, address.family);
+            },
+        };
+        const tlsHost = url.hostname.replace(/^\[|\]$/g, '');
+        if (url.protocol === 'https:' && !(0, node_net_1.isIP)(tlsHost))
+            options.servername = tlsHost;
+        const onResponse = (response) => resolve(response);
+        const request = url.protocol === 'https:'
+            ? (0, node_https_1.request)(url, options, onResponse)
+            : (0, node_http_1.request)(url, options, onResponse);
+        request.once('error', reject);
+        request.end();
+    });
+}
+function isPublicAddress(address) {
+    const ip = address.toLowerCase().split('%')[0];
+    if (ip.includes(':')) {
+        if (ip === '::' || ip === '::1' || ip.startsWith('fc') || ip.startsWith('fd') || ip.startsWith('fe8') || ip.startsWith('fe9') || ip.startsWith('fea') || ip.startsWith('feb') || ip.startsWith('ff'))
+            return false;
+        if (ip.startsWith('::ffff:'))
+            return isPublicAddress(ip.slice(7));
+        if (ip.startsWith('2001:db8:'))
+            return false;
+        return /^[23]/.test(ip);
+    }
+    const n = ip.split('.').map(Number);
+    if (n.length !== 4 || n.some(x => !Number.isInteger(x) || x < 0 || x > 255))
+        return false;
+    const [a, b, c] = n;
+    if (a === 0 || a === 10 || a === 127 || a >= 224)
+        return false;
+    if (a === 100 && b >= 64 && b <= 127)
+        return false;
+    if (a === 169 && b === 254)
+        return false;
+    if (a === 172 && b >= 16 && b <= 31)
+        return false;
+    if (a === 192 && (b === 168 || (b === 0 && c === 0) || (b === 0 && c === 2)))
+        return false;
+    if (a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100)))
+        return false;
+    if (a === 203 && b === 0 && c === 113)
+        return false;
+    return true;
+}
+function sizeError(maxBytes) {
+    return new Error(`日志文件超过大小上限（${formatBytes(maxBytes)}），请压缩或只保留相关日志后重新上传。`);
+}
+function formatBytes(size) {
+    if (size >= 1024 * 1024)
+        return `${(size / 1024 / 1024).toFixed(1).replace(/\.0$/, '')} MiB`;
+    if (size >= 1024)
+        return `${(size / 1024).toFixed(1).replace(/\.0$/, '')} KiB`;
+    return `${size} B`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+import { Context, Schema } from 'koishi';
+import type { Config as PluginConfig } from './types';
+export declare const name = "cnb-bot";
+export declare const inject: string[];
+export type Config = PluginConfig;
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, input: PluginConfig): void;