@quecue/dev-notify 0.0.0-stage → 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dev-notify contributors
+
+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

@@ -1,3 +1,151 @@
-# Temporary Holding Version
+# dev-notify
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+跨平台开发任务通知工具，使用 **TypeScript / Node.js**，通过 npm 分发，无需 Python 或独立可执行文件。通用通知不依赖 Claude Code、Unity 或项目目录。
+
+**当前为未发布的 `0.1.0-alpha.1`，`private: true` 防止误发布。npm 包名尚未核定，请勿安装未经确认的同名公开包。**
+
+## 安装与使用
+
+要求 Node.js 22 或以上，首发目标 Windows、macOS。运行时依赖锁定版本的 `@napi-rs/keyring`，由 npm 安装对应系统的预编译原生组件，不需要 Python、Rust 或 C++ 编译器。不要省略 npm optional 依赖。
+
+在工程目录执行：
+
+```sh
+npm ci --ignore-scripts
+npm run build
+node dist/cli.js setup
+node dist/cli.js doctor
+```
+
+配置完成后发送：
+
+```sh
+node dist/cli.js send --title "构建完成" --content "安装包已生成"
+node dist/cli.js send --title "测试结果" --content-file result.txt
+node dist/cli.js send --title "任务输出" --stdin
+node dist/cli.js send --title "分段预览" --content-file result.txt --dry-run
+```
+
+若需要本地安装为 `dev-notify` 命令，在构建后运行 `npm install --global .`，之后可执行 `dev-notify setup`、`dev-notify send ...`。这是本地源码安装，不是从公开 registry 安装；本工程不会自动进行全局安装或发布。
+
+正式包的安装/升级/卸载由 npm 负责。**卸载程序不会自动清除用户凭据**；如需清理，请先交互执行 `dev-notify credentials clear`，再卸载。该命令只删除当前配置引用的 Node 凭据，不删除其他账号、其他配置或 Python 原型凭据。
+
+## 已提供的功能
+
+- Telegram、飞书双渠道通知，按渲染后的长度分段，不静默截断。
+- 文本、严格 UTF-8 文件或标准输入；支持渠道选择、通知级别、辅助信息。
+- 交互配置、隐藏输入、系统凭据存储、环境变量覆盖。
+- 配置更新冲突检测、失败恢复、凭据清理。
+- 可选测试通知：只有额外确认后才发送，默认不发送。
+- `paths`、`doctor`、`status`、`send --dry-run` 离线诊断。
+
+**交付范围是“安装 → 配置 → 存储凭据 → 发送 → 清理凭据”的通用通知链路。**当前不安装应用 hooks、不启动后台服务、不做远程控制。`integration list` 仅报告集成未启用；Claude Code 回复、自动配对、任务队列不属于本版已实现能力。
+
+## 配置向导
+
+```sh
+node dist/cli.js setup
+```
+
+1. 选择 Telegram、飞书或两者。
+2. 隐藏输入 Token、webhook 和可选签名密钥。无法安全隐藏输入时停止，不回退到明文回显。
+3. Telegram 手动填写数字 chat_id，多个用逗号分隔；用户需要先启动 Bot。不会自动启动 getUpdates 配对。
+4. 展示渠道和接收人数，最终确认后保存。输入错误可以重试，Ctrl+C 取消。
+5. 保存后单独询问是否发送固定内容的测试通知。测试失败不会撤销已成功保存的配置。
+
+编辑已有配置需要先确认；密钥留空保留已存值，可选签名输入 `-` 清除。未选渠道会禁用，新条目只保留所选渠道的凭据。环境变量仍然优先；向导会提示存在覆盖，测试使用最终生效值，而不是忽略环境的刚输入值。
+
+自动化使用无密钥模板和 CI secrets：
+
+```sh
+node dist/cli.js setup --template --yes
+```
+
+模板永不覆盖已有配置。`--yes` 只能配合 `--template`，不能跳过交互密钥保存确认。
+
+## 系统凭据与兼容性
+
+Node 版使用 **Windows Credential Manager / macOS Keychain**，通过原生 Node API 传递秘密，不调用 Python，不将秘密放进命令行参数，不写入明文 JSON。
+
+- 底层库：`@napi-rs/keyring`，固定版本记录于 lockfile。
+- service：`dev-notify.node.credentials.v1`；account：随机 32 位十六进制 ID。
+- 配置引用：`"credentials": {"backend":"keyring","id":"..."}`。
+- 为兼容 Windows 通用凭据 blob 大小，凭据包限制 2400 UTF-8 字节，超限报错，不截断。
+- 原生组件加载失败、存储锁定或拒绝访问时明确报错，不降级为明文文件。macOS 可能要求系统授权；离线不代表一定无系统提示。
+- 默认不枚举系统条目，只访问当前引用或本次新建的随机条目。
+
+保留的 Python 原型使用 `backend: "system"`，Windows 是 DPAPI 文件，与 Node Credential Manager 不是同一存储。Node 不会读取或删除它。遇到旧配置可运行 `setup` 重新输入生成 Node 引用；原 Python 凭据保持不变。不要用 Python 原型编辑 Node 的 `keyring` 配置。
+
+Python 源码及测试仍在 `src/dev_notify/`、`tests/`、`tools/`，本轮没有删除。历史文档位于 `docs/PYTHON_PROTOTYPE.md`、`docs/PYTHON_SECURITY.md`，不进入 npm 包。
+
+## 路径、模板和环境变量
+
+| 平台 | 配置 | 数据预留目录 |
+| --- | --- | --- |
+| Windows | `%APPDATA%\DevNotify\config.json` | `%LOCALAPPDATA%\DevNotify\data` |
+| macOS | `~/Library/Application Support/DevNotify/config/config.json` | `~/Library/Application Support/DevNotify/data` |
+
+`DEV_NOTIFY_HOME` 必须是绝对路径，配置位于其 `config/config.json` 下。也可用 `--config <路径>` 显式指定文件。显式文件缺失时报错；默认文件缺失时允许仅使用环境变量。
+
+```json
+{
+  "version": 1,
+  "telegram": {"enabled": true, "chat_ids": [], "token_env": "TELEGRAM_BOT_TOKEN"},
+  "feishu": {"enabled": true, "webhook_env": "FEISHU_WEBHOOK", "secret_env": "FEISHU_SECRET"}
+}
+```
+
+- `TELEGRAM_BOT_TOKEN`：Token。
+- `TELEGRAM_CHAT_ID`、`TELEGRAM_CHAT_IDS`：主接收人和逗号分隔接收人，任一显式存在即完全替换文件名单；显式空名单撤销接收人。大整数 chat_id 必须用字符串。
+- `FEISHU_WEBHOOK`：飞书中国站 HTTPS 自定义机器人地址。
+- `FEISHU_SECRET`：可选签名密钥。
+
+凭据环境变量显式存在时优先，包括空值；不存在才延迟读取系统引用，同次配置加载只读取一次。禁用渠道不会仅为读取系统秘密而打开后端。Token/webhook/secret 不能直接填写进 JSON。
+
+## 更新与清理安全
+
+保存流程：写入新随机系统条目 → 校验可读 → 原子替换 JSON → 删除旧 Node 条目。配置切换前失败保留旧配置，并尝试清理本次新凭据；清理失败只报告非敏感引用 ID。旧 Python 条目从不删除。
+
+配置写入使用排他 `.setup.lock`，写前及切换前核对原文件。不要在向导保存时用编辑器并发改配置；编辑器不遵守此锁。断电/强杀可能留下锁或孤立条目，存储和 JSON 不是跨系统原子事务。确认没有向导运行后才能处理残留锁；程序不会擅自扫描并删除不明条目。
+
+```sh
+node dist/cli.js credentials clear
+```
+
+清理必须交互确认，先去除当前 JSON 引用，再尝试删除其 Node 条目；环境变量保持不变。共享同一旧引用的配置副本也会受影响，操作前会告知。删除失败明确警告，不伪装成已清理。
+
+## 格式、发送与退出码
+
+支持标题、粗体、斜体、删除线、行内代码、代码块、引用、列表、任务列表、等宽表格。Telegram 按 UTF-16 长度，飞书按 UTF-8 请求预算分段，emoji 不从代理对中切开。跨段标签补齐，标题 `(1/N)`，每段保留辅助信息。链接显示为“文字 (URL)”，纯文本回退保留地址。不是完整 CommonMark 引擎，复杂转义或嵌套不保证完全原样排版。
+
+单接收人中途失败停止其后续分段，Telegram 继续其他接收人。HTML/卡片格式错误回退；Telegram 明确 `429` 按服务端要求有限重试。超时不盲目重发，不承诺恰好一次投递。
+
+- `send` 会把指定内容上传到第三方，请检查接收人与敏感信息。
+- `--dry-run` 不输出正文/凭据，不联网。
+- `doctor` / `status` 可能读取本地凭据，不验证网络和实际授权。
+- 文件缺失、损坏配置、UTF-8 错误立即报错，不退回发送标题。
+
+| 代码 | 含义 |
+| --- | --- |
+| 0 | 所选已配置渠道完整发送成功，或配置/只读操作成功 |
+| 1 | 部分/全部投递失败；或 doctor/status 没有可用渠道 |
+| 2 | 参数、配置、文件或凭据操作错误 |
+| 130 | 用户取消 |
+
+向导保存成功后测试通知失败，命令仍以保存成功结束，并明确显示测试失败，两者不混淆。
+
+## 开发与验证
+
+```sh
+npm ci --ignore-scripts
+npm test
+npm pack --dry-run
+```
+
+`node-src/` 是 TypeScript 源码，`dist/` 是编译输出，`test-js/` 是测试。默认测试只用假凭据和模拟后端/网络；本机原生假条目往返测试需显式设置 `DEV_NOTIFY_NATIVE_TEST=1`，且只在 Windows 启用，使用随机 ID，结束后清理。
+
+npm 发布白名单只有 `dist/*.js`、README、SECURITY、LICENSE 和必需的 package.json；不包含 Python、测试、配置或密文。无 postinstall、自动启动和自写下载脚本；预编译原生依赖由 npm 的平台 optional 包解析，**不应使用 `--omit=optional`**。macOS x64/arm64 和 Windows x64/arm64 预编译包由依赖提供，提供包不等于本项目已实机验收。
+
+本机验证环境为 Windows x64、Node 24。macOS 实机、Node 最低版本、版本管理器切换及公开发布审计仍未验证；不把路径模拟或依赖支持宣称为实机完成。
+
+采用 MIT，见 [LICENSE](LICENSE)。安全边界见 [SECURITY.md](SECURITY.md)。未创建远程仓库、未发布 npm 包。

package/SECURITY.md

@@ -0,0 +1,45 @@
+# 安全边界（Node/npm）
+
+当前为未发布 alpha，`private: true` 防止误发布；未宣称完成安全审计或双平台实机验收。Python 原型说明另见 `docs/PYTHON_SECURITY.md`。
+
+## 凭据与权限
+
+- Node 系统凭据使用固定版本 `@napi-rs/keyring`：Windows Credential Manager / macOS Keychain。秘密通过进程内原生接口传递，不使用 shell、Python、子进程参数或明文落盘。
+- Node service 为 `dev-notify.node.credentials.v1`，每份凭据使用随机 ID。JSON 只保存 `keyring` 引用，不枚举其他系统条目。
+- 环境变量优先且显式空值也覆盖。环境变量和系统凭据都不能防御已被控制的同用户进程；秘密会进入 Node 内存，不能保证所有副本被安全清零。
+- Keychain 可能请求系统授权；锁定、权限不足、原生库加载失败明确报错，不自动降级明文。提供预编译包不代表 macOS 权限流程已验收。
+- Python 的 `system` 引用与 Node 存储隔离，不读取、不删除旧 Python 凭据；重新输入后的 Node 引用不能交给旧 Python 原型编辑。
+- 交互秘密使用 raw mode 隐藏输入，异常/Ctrl+C/EOF 恢复终端状态；无法隐藏输入即拒绝，不回退回显。原生读取不保证无系统弹窗。
+
+## 配置事务与清理
+
+- 最终确认前不写配置和凭据。确认后先创建新随机条目并校验，再切换 JSON，成功后删除旧 Node 条目。
+- 配置切换失败保留原配置；只尝试清理本次创建的条目，清理失败只输出非敏感 ID。
+- 使用排他 `.setup.lock` 和内容快照防止多个向导互相覆盖；外部编辑器不遵守锁，保存期间不要手工编辑。
+- 存储和 JSON 不是跨系统原子事务。强制结束/断电可能留下锁、临时文件或孤立凭据，程序不扫描并删除未知数据。
+- `credentials clear` 需要交互确认，移除当前引用并删除其 Node 条目；共享引用的配置副本会受影响，操作前告知。环境变量不会清除，删除失败明确警告。
+- POSIX mode 不能代替 Windows ACL，非敏感配置仍可能暴露接收人和本机路径。
+
+## 网络与应用边界
+
+- 仅非 dry-run 的 `send`，以及向导保存后**另行同意**的固定测试消息会发送通知。
+- 向导测试使用环境覆盖后的最终配置；保存成功与测试失败分别报告，不伪装为全部成功。
+- HTTP 启用系统 TLS 验证、禁止重定向，超时 10 秒，响应大小最多 1 MiB；底层 URL、秘密、服务端原始正文不打印。
+- 网络超时可能发生服务端已接受但客户端未知，不承诺恰好一次，不能为避免失败而无限重发。
+- 接收人环境变量完整替换旧名单，不隐式残留旧授权。
+- 不自动读取应用会话、项目或版本控制信息，不安装 hooks、不开放监听、不注入终端、不执行远程命令。
+- `doctor`、`status`、`paths` 和 dry-run 不联网；本地凭据读取可能触发系统授权。
+
+## npm 与测试
+
+- 运行时有原生凭据依赖，版本和平台 optional 包锁定于 `package-lock.json`。不要省略 optional 依赖。项目无 postinstall、自写二进制下载、后台启动脚本。
+- npm 白名单仅包含编译 JS、README、SECURITY、LICENSE 和 package.json。测试、Python、配置、日志、密文不进入本包。
+- 第三方原生包带有其许可证与 Rust 依赖声明，公开前仍需审查依赖供应链和许可；不能把固定版本等同于完成审计。
+- 默认测试用假凭据/临时目录和模拟系统后端、网络。`DEV_NOTIFY_NATIVE_TEST=1` 显式开启 Windows 原生测试，仅创建本次随机 ID 的假条目，结束清理，不读取用户现有条目。
+- npm 卸载程序不自动删除用户配置/凭据。需要清理时先运行交互清理命令，不在卸载生命周期脚本偷偷操作系统存储。
+
+## 公开发布
+
+核对包名、源码权属、依赖许可；扫描完整目录、实际 npm 包和 Git 历史。密钥泄漏必须撤销轮换，删除文件不能撤销泄漏。正式公开前应设置私密漏洞报告渠道；当前没有公开安全联络地址。
+
+本机已验证 Windows x64；macOS 原生权限流程、其他架构及 Node 最低版本仍未实机验证，不宣称全面兼容。

package/dist/channels.js

@@ -0,0 +1,152 @@
+import { createHmac } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { escapeHtml, feishuParts, parseMarkdown, partTitle, telegramParts } from './formatting.js';
+export class TransportError extends Error {
+}
+const icons = { info: 'ℹ️', success: '✅', warn: '⚠️', error: '❌' };
+const colors = { info: 'blue', success: 'green', warn: 'yellow', error: 'red' };
+const bytes = (data) => Buffer.byteLength(JSON.stringify(data), 'utf8');
+export async function requestJson(url, payload, fetcher = fetch) {
+    try {
+        const response = await fetcher(url, { method: 'POST', body: JSON.stringify(payload),
+            headers: { 'Content-Type': 'application/json' }, redirect: 'error', signal: AbortSignal.timeout(10000) });
+        if (!response.body)
+            throw new TransportError('服务端响应为空');
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > 1024 * 1024) {
+                    await reader.cancel();
+                    throw new TransportError('服务端响应超过大小限制');
+                }
+                chunks.push(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const result = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
+        if (!result || typeof result !== 'object' || Array.isArray(result))
+            throw new TransportError('服务端未返回 JSON 对象');
+        return result;
+    }
+    catch (error) {
+        if (error instanceof TransportError)
+            throw error;
+        throw new TransportError('网络请求失败或响应无效；未自动重发，投递状态可能未知');
+    }
+}
+function text(title, content, footer, icon, html) {
+    const sections = [`${icon} ${html ? `<b>${escapeHtml(title)}</b>` : title}`];
+    if (content)
+        sections.push(content);
+    if (footer)
+        sections.push('────────\n' + (html ? `<i>${escapeHtml(footer)}</i>` : footer));
+    return sections.join('\n\n');
+}
+function card(message, title, content) {
+    const elements = [];
+    if (content)
+        elements.push({ tag: 'markdown', content });
+    if (message.footer)
+        elements.push({ tag: 'hr' }, { tag: 'note', elements: [{ tag: 'plain_text', content: message.footer }] });
+    return { msg_type: 'interactive', card: { config: { wide_screen_mode: true },
+            header: { template: colors[message.level], title: { tag: 'plain_text', content: title } }, elements } };
+}
+export function makePlan(channel, message, config) {
+    if (!message.title.trim())
+        throw new Error('通知标题不能为空');
+    const blocks = parseMarkdown(message.content);
+    if (channel === 'telegram') {
+        const icon = icons[message.level];
+        const reserve = String(Math.max(1, message.content.length)).length * 2 + 16;
+        const budget = 3900 - text(message.title, '', message.footer, icon, false).length - reserve;
+        const chunks = telegramParts(blocks, budget);
+        const items = [];
+        for (const chatId of config.telegram.chatIds)
+            chunks.forEach((chunk, index) => {
+                const title = partTitle(message.title, index, chunks.length);
+                const plain = text(title, chunk.plain, message.footer, icon, false);
+                if (plain.length > 4096)
+                    throw new Error('Telegram 分段超过消息限制');
+                items.push({ recipient: chatId, plain, payload: { chat_id: chatId,
+                        text: text(title, chunk.html, message.footer, icon, true), parse_mode: 'HTML', disable_web_page_preview: true } });
+            });
+        return { channel, items, recipients: config.telegram.chatIds.length };
+    }
+    const budget = Math.min(10000, Math.floor((28000 - bytes(card(message, message.title, '')) - 512) / 6));
+    const chunks = feishuParts(blocks, budget);
+    const items = chunks.map((chunk, index) => {
+        const payload = card(message, partTitle(message.title, index, chunks.length), chunk);
+        if (bytes(payload) + 128 > 28000)
+            throw new Error('飞书分段超过请求大小限制');
+        return { recipient: 'feishu', payload };
+    });
+    return { channel, items, recipients: 1 };
+}
+export async function deliver(plan, config, request = requestJson, sleep = delay) {
+    let sent = 0, error;
+    const failed = new Set();
+    const telegram = plan.channel === 'telegram';
+    const url = telegram ? `https://api.telegram.org/bot${config.telegram.token}/sendMessage` : config.feishu.webhook;
+    const post = async (payload) => {
+        if (!telegram && config.feishu.secret) {
+            const timestamp = String(Math.floor(Date.now() / 1000));
+            payload.timestamp = timestamp;
+            payload.sign = createHmac('sha256', `${timestamp}\n${config.feishu.secret}`).update('').digest('base64');
+        }
+        let response = await request(url, payload);
+        if (telegram && response.error_code === 429) {
+            const wait = response.parameters?.retry_after;
+            if (typeof wait === 'number' && Number.isFinite(wait) && wait > 0 && wait <= 60) {
+                await sleep(wait * 1000);
+                response = await request(url, payload);
+            }
+        }
+        return response;
+    };
+    for (let index = 0; index < plan.items.length; index++) {
+        const item = plan.items[index];
+        if (failed.has(item.recipient))
+            continue;
+        const payload = structuredClone(item.payload);
+        try {
+            let response = await post(payload);
+            if (telegram && response.ok !== true && /parse|entit/i.test(String(response.description ?? ''))) {
+                delete payload.parse_mode;
+                payload.text = item.plain;
+                response = await post(payload);
+            }
+            else if (!telegram && response.code !== 0) {
+                let changed = false;
+                payload.card.elements = payload.card.elements.map((element) => {
+                    if (element.tag !== 'markdown')
+                        return element;
+                    changed = true;
+                    return { tag: 'div', text: { tag: 'lark_md', content: element.content } };
+                });
+                if (changed)
+                    response = await post(payload);
+            }
+            if (telegram ? response.ok === true : response.code === 0)
+                sent++;
+            else {
+                failed.add(item.recipient);
+                error = '渠道拒绝发送，请检查凭据、接收人授权、签名或频率限制';
+            }
+        }
+        catch (cause) {
+            failed.add(item.recipient);
+            error = cause instanceof TransportError ? cause.message : '发送失败；投递状态可能未知';
+        }
+        if (!telegram && !failed.has(item.recipient) && index + 1 < plan.items.length)
+            await sleep(250);
+    }
+    return { channel: plan.channel, sent, planned: plan.items.length, ok: sent > 0 && sent === plan.items.length && !error, error };
+}

package/dist/cli.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { readFile } from 'node:fs/promises';
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { appPaths, ConfigError, createConfig, decodeUtf8, loadConfig, ready } from './config.js';
+import { deliver, makePlan } from './channels.js';
+import { wizard, clearCredentials } from './setup.js';
+import { terminalPrompts, readText, Cancelled } from './prompts.js';
+import { CredentialError } from './credentials.js';
+const HELP = `dev-notify 0.1.0-alpha.1 — 跨平台开发任务通知
+
+命令：
+  send --title 标题 [--content 正文 | --content-file 文件 | --stdin]
+       [--channel all|telegram|feishu] [--level info|success|warn|error]
+       [--footer 辅助信息] [--dry-run]
+  setup                     交互配置渠道并存入系统凭据，保存后可选测试
+  setup --template [--yes]   仅创建无密钥模板，不覆盖已有配置
+  credentials clear         确认后移除当前 Node 凭据引用和条目
+  paths                     显示配置路径，不写文件
+  doctor / status           离线检查，不发消息
+  integration list          显示集成迁移状态
+
+全局选项：--config 路径、--help、--version
+系统凭据使用 Windows Credential Manager / macOS Keychain；不调用 Python，不写入明文密钥。`;
+const defaults = {
+    env: process.env,
+    out: text => console.log(text),
+    err: text => console.error(text),
+    stdin: async () => { const chunks = []; for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk)); return Buffer.concat(chunks); },
+    confirm: async () => {
+        if (!process.stdin.isTTY)
+            throw new ConfigError('非交互环境请使用 setup --template --yes');
+        return /^(y|yes)$/i.test(await readText('确认创建模板？[y/N] '));
+    },
+    send: deliver,
+};
+export async function main(argv = process.argv.slice(2), overrides = {}) {
+    const context = { ...defaults, ...overrides };
+    try {
+        let parsed;
+        try {
+            parsed = parseArgs({ args: argv, allowPositionals: true, strict: true, options: {
+                    help: { type: 'boolean', short: 'h' }, version: { type: 'boolean' }, config: { type: 'string' },
+                    title: { type: 'string' }, content: { type: 'string' }, 'content-file': { type: 'string' }, stdin: { type: 'boolean' },
+                    channel: { type: 'string' }, level: { type: 'string' }, footer: { type: 'string' }, 'dry-run': { type: 'boolean' },
+                    template: { type: 'boolean' }, yes: { type: 'boolean' },
+                } });
+        }
+        catch {
+            throw new ConfigError('参数无效，请使用 --help；不回显可能含秘密的参数');
+        }
+        const { values, positionals } = parsed;
+        if (values.help) {
+            context.out(HELP);
+            return 0;
+        }
+        if (values.version) {
+            context.out('dev-notify 0.1.0-alpha.1');
+            return 0;
+        }
+        const [command, action] = positionals;
+        const allowed = {
+            send: ['title', 'content', 'content-file', 'stdin', 'channel', 'level', 'footer', 'dry-run'],
+            setup: ['template', 'yes'], paths: [], doctor: [], status: [], integration: [], credentials: [],
+        };
+        if (!command || !Object.hasOwn(allowed, command) || positionals.length > (['integration', 'credentials'].includes(command) ? 2 : 1)
+            || Object.keys(values).some(key => key !== 'config' && !allowed[command].includes(key)))
+            throw new ConfigError('命令或选项组合无效，请使用 --help');
+        const paths = appPaths(process.platform, context.env);
+        const file = values.config ? path.resolve(values.config) : paths.config;
+        if (command === 'paths') {
+            context.out(JSON.stringify({ config: file, data: paths.data }, null, 2));
+            return 0;
+        }
+        if (command === 'integration') {
+            if (action !== 'list')
+                throw new ConfigError('当前只支持 integration list');
+            context.out('claude-code: 尚未迁入 Node 版，未安装 hooks 或启用远程回复');
+            return 0;
+        }
+        if (command === 'credentials') {
+            if (action !== 'clear')
+                throw new ConfigError('当前只支持 credentials clear，且必须交互确认');
+            return await clearCredentials(file, context.prompts ?? terminalPrompts()) ? 0 : 130;
+        }
+        if (command === 'setup') {
+            if (!values.template) {
+                if (values.yes)
+                    throw new ConfigError('--yes 只允许与 --template 同时使用，不能跳过密钥保存确认');
+                return await wizard(file, {
+                    prompts: context.prompts, env: context.env,
+                    testSend: async (config) => {
+                        let count = 0, ok = true;
+                        for (const channel of ['telegram', 'feishu']) {
+                            if (!ready(config, channel))
+                                continue;
+                            count++;
+                            const plan = makePlan(channel, { title: 'dev-notify 配置测试', content: '这是一条由你确认发送的测试通知。', footer: '', level: 'info' }, config);
+                            const result = await context.send(plan, config);
+                            context.out(`${channel}: 测试已发送 ${result.sent}/${result.planned}`);
+                            ok = ok && result.ok;
+                        }
+                        return count > 0 && ok;
+                    },
+                }) ? 0 : 130;
+            }
+            context.out(`将创建无密钥模板: ${file}；不会联网或修改 hooks`);
+            if (!values.yes && !await context.confirm()) {
+                context.out('已取消，未写入');
+                return 130;
+            }
+            await createConfig(file);
+            context.out('已创建模板；请配置环境凭据和接收人');
+            return 0;
+        }
+        const config = await loadConfig(file, values.config !== undefined, context.env);
+        if (command === 'doctor' || command === 'status') {
+            context.out(`配置路径: ${file}`);
+            for (const channel of ['telegram', 'feishu'])
+                context.out(`${channel}: ${ready(config, channel) ? '配置齐全，网络未验证' : '未启用或配置不完整'}`);
+            context.out('凭据: 环境变量优先，其次 Windows Credential Manager / macOS Keychain；检查不联网，系统可能要求授权');
+            return ready(config, 'telegram') || ready(config, 'feishu') ? 0 : 1;
+        }
+        if (!values.title?.trim())
+            throw new ConfigError('send 必须指定非空 --title');
+        if ([values.content !== undefined, values['content-file'] !== undefined, !!values.stdin].filter(Boolean).length > 1)
+            throw new ConfigError('正文来源只能指定一个');
+        const level = values.level ?? 'info';
+        const channel = values.channel ?? 'all';
+        if (!['info', 'success', 'warn', 'error'].includes(level) || !['all', 'telegram', 'feishu'].includes(channel))
+            throw new ConfigError('渠道或通知级别无效');
+        let content = values.content ?? values.title;
+        if (values['content-file'] !== undefined)
+            content = decodeUtf8(await readFile(values['content-file']));
+        if (values.stdin)
+            content = decodeUtf8(await context.stdin());
+        const message = { title: values.title, content, footer: values.footer ?? '', level: level };
+        const selected = channel === 'all' ? ['telegram', 'feishu'] : [channel];
+        let failed = false, planned = 0;
+        for (const name of selected) {
+            if (!ready(config, name)) {
+                if (channel !== 'all')
+                    throw new ConfigError('指定渠道未启用或配置不完整');
+                continue;
+            }
+            planned++;
+            let plan;
+            try {
+                plan = makePlan(name, message, config);
+            }
+            catch {
+                context.err(`${name}: 无法生成安全分段，请缩短标题/辅助信息或检查正文格式`);
+                failed = true;
+                continue;
+            }
+            if (values['dry-run']) {
+                context.out(`${name}: 接收目标 ${plan.recipients}，预计请求 ${plan.items.length}；未发送`);
+                continue;
+            }
+            const result = await context.send(plan, config);
+            context.out(`${name}: 已发送 ${result.sent}/${result.planned}`);
+            if (!result.ok) {
+                failed = true;
+                context.err(result.error ?? '投递失败');
+            }
+        }
+        if (!planned)
+            throw new ConfigError('没有可发送的渠道，请配置环境凭据和接收人');
+        return failed ? 1 : 0;
+    }
+    catch (error) {
+        if (error instanceof Cancelled) {
+            context.out('已取消，未继续执行。');
+            return 130;
+        }
+        context.err(error instanceof ConfigError || error instanceof CredentialError ? error.message : '操作失败，请检查文件、权限或输入；不输出可能含秘密的底层异常');
+        return 2;
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+    process.exitCode = await main();
+}