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

package/dist/config.js

@@ -0,0 +1,141 @@
+import { readFile, mkdir, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { resolveReference } from './credentials.js';
+export class ConfigError extends Error {
+}
+export const example = {
+    version: 1,
+    telegram: { enabled: true, chat_ids: [], token_env: 'TELEGRAM_BOT_TOKEN' },
+    feishu: { enabled: true, webhook_env: 'FEISHU_WEBHOOK', secret_env: 'FEISHU_SECRET' },
+};
+export function appPaths(platform = process.platform, env = process.env, home) {
+    const join = platform === 'win32' ? path.win32 : path.posix;
+    if (env.DEV_NOTIFY_HOME) {
+        if (!join.isAbsolute(env.DEV_NOTIFY_HOME))
+            throw new ConfigError('DEV_NOTIFY_HOME 必须是绝对路径');
+        return { config: join.join(env.DEV_NOTIFY_HOME, 'config', 'config.json'), data: join.join(env.DEV_NOTIFY_HOME, 'data') };
+    }
+    home ??= homedir();
+    if (platform === 'win32')
+        return {
+            config: join.join(env.APPDATA || join.join(home, 'AppData', 'Roaming'), 'DevNotify', 'config.json'),
+            data: join.join(env.LOCALAPPDATA || join.join(home, 'AppData', 'Local'), 'DevNotify', 'data'),
+        };
+    if (platform === 'darwin') {
+        const root = join.join(home, 'Library', 'Application Support', 'DevNotify');
+        return { config: join.join(root, 'config', 'config.json'), data: join.join(root, 'data') };
+    }
+    return { config: join.join(env.XDG_CONFIG_HOME || join.join(home, '.config'), 'dev-notify', 'config.json'),
+        data: join.join(env.XDG_STATE_HOME || join.join(home, '.local', 'state'), 'dev-notify') };
+}
+export function object(value, allowed, name) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new ConfigError(`${name} 必须是 JSON 对象`);
+    const result = value;
+    if (Object.keys(result).some(key => !allowed.includes(key)))
+        throw new ConfigError(`${name} 包含不支持的字段；不能直接保存明文密钥`);
+    return result;
+}
+function enabled(section) {
+    if (section.enabled === undefined)
+        return true;
+    if (typeof section.enabled !== 'boolean')
+        throw new ConfigError('enabled 必须是布尔值');
+    return section.enabled;
+}
+function secret(section, field, fallback, env, stored) {
+    const name = section[field] ?? fallback;
+    if (typeof name !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+        throw new ConfigError('凭据引用必须是合法的环境变量名称');
+    if (Object.hasOwn(env, name))
+        return (env[name] ?? '').trim();
+    return enabled(section) ? stored().trim() : '';
+}
+export function parseConfig(input, env = process.env, resolver = resolveReference) {
+    const data = object(input, ['version', 'telegram', 'feishu', 'credentials'], '配置');
+    if ((data.version ?? 1) !== 1)
+        throw new ConfigError('不支持的配置版本');
+    let reference;
+    if (data.credentials !== undefined) {
+        const value = object(data.credentials, ['backend', 'id'], 'credentials');
+        if (!['system', 'keyring'].includes(String(value.backend)) || typeof value.id !== 'string' || !/^[a-f0-9]{32}$/.test(value.id))
+            throw new ConfigError('系统凭据引用无效');
+        reference = value;
+    }
+    let cached;
+    const stored = (field) => {
+        if (!reference)
+            return '';
+        cached ??= resolver(reference);
+        return cached[field] ?? '';
+    };
+    const tg = object(data.telegram ?? {}, ['enabled', 'chat_ids', 'token_env'], 'telegram');
+    const fs = object(data.feishu ?? {}, ['enabled', 'webhook_env', 'secret_env'], 'feishu');
+    const tgEnabled = enabled(tg), fsEnabled = enabled(fs);
+    let ids = tg.chat_ids ?? [];
+    if (Object.hasOwn(env, 'TELEGRAM_CHAT_ID') || Object.hasOwn(env, 'TELEGRAM_CHAT_IDS')) {
+        ids = `${env.TELEGRAM_CHAT_ID ?? ''},${env.TELEGRAM_CHAT_IDS ?? ''}`.split(',').map(v => v.trim()).filter(Boolean);
+    }
+    if (!Array.isArray(ids))
+        throw new ConfigError('telegram.chat_ids 必须是数组');
+    const chatIds = [...new Set(ids.map(value => {
+            if (typeof value !== 'string' && !(typeof value === 'number' && Number.isSafeInteger(value)))
+                throw new ConfigError('接收人必须是数字 chat_id；大整数请使用字符串');
+            const id = String(value).trim();
+            if (!/^-?[1-9][0-9]*$/.test(id))
+                throw new ConfigError('接收人必须是非零数字 chat_id');
+            return id;
+        }))];
+    const token = secret(tg, 'token_env', 'TELEGRAM_BOT_TOKEN', env, () => stored('telegram_token'));
+    if (token && !/^[0-9]+:[A-Za-z0-9_-]+$/.test(token))
+        throw new ConfigError('Telegram Token 格式无效');
+    const webhook = secret(fs, 'webhook_env', 'FEISHU_WEBHOOK', env, () => stored('feishu_webhook'));
+    if (webhook) {
+        let valid = false;
+        try {
+            const url = new URL(webhook);
+            valid = url.protocol === 'https:' && url.host === 'open.feishu.cn' && !url.username && !url.password && !url.search && !url.hash && /^\/open-apis\/bot\/v2\/hook\/[^/]+$/.test(url.pathname);
+        }
+        catch { /* 不输出含秘密的 URL 异常。 */ }
+        if (!valid)
+            throw new ConfigError('飞书 webhook 必须是 open.feishu.cn 的 HTTPS 自定义机器人地址');
+    }
+    return { telegram: { enabled: tgEnabled, token, chatIds }, feishu: { enabled: fsEnabled, webhook,
+            secret: secret(fs, 'secret_env', 'FEISHU_SECRET', env, () => stored('feishu_secret')) } };
+}
+export function ready(config, channel) {
+    return channel === 'telegram' ? config.telegram.enabled && !!config.telegram.token && !!config.telegram.chatIds.length
+        : config.feishu.enabled && !!config.feishu.webhook;
+}
+export function decodeUtf8(data) {
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(data);
+    }
+    catch {
+        throw new ConfigError('输入必须是有效的 UTF-8 文本');
+    }
+}
+export async function loadConfig(file, required = false, env = process.env) {
+    let input = {};
+    try {
+        input = JSON.parse(decodeUtf8(await readFile(file)));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT' && !required)
+            return parseConfig({}, env);
+        throw new ConfigError('配置文件缺失、不可读取或不是合法 UTF-8 JSON');
+    }
+    return parseConfig(input, env);
+}
+export async function createConfig(file) {
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    try {
+        await writeFile(file, JSON.stringify(example, null, 2) + '\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            throw new ConfigError('配置已存在，未覆盖；Node 版不会修改 Python 原型的配置');
+        throw new ConfigError('无法创建配置，请检查路径和权限');
+    }
+}

package/dist/credentials.js

@@ -0,0 +1,105 @@
+// 只访问本工具的随机引用条目，不枚举系统凭据，不通过子进程传递秘密。
+import { createRequire } from 'node:module';
+export const SERVICE = 'dev-notify.node.credentials.v1';
+export class CredentialError extends Error {
+}
+const fields = ['telegram_token', 'feishu_webhook', 'feishu_secret'];
+export function validateId(id) {
+    if (typeof id !== 'string' || !/^[0-9a-f]{32}$/.test(id))
+        throw new CredentialError('系统凭据引用无效');
+}
+export function decodeBundle(raw) {
+    try {
+        const result = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(raw));
+        if (!result || typeof result !== 'object' || Array.isArray(result)
+            || Object.keys(result).some(key => !fields.includes(key))
+            || Object.values(result).some(value => typeof value !== 'string'))
+            throw new Error();
+        return result;
+    }
+    catch {
+        throw new CredentialError('系统凭据数据无效，请重新运行 setup');
+    }
+}
+export function encodeBundle(values) {
+    const encoded = Buffer.from(JSON.stringify(values), 'utf8');
+    decodeBundle(encoded);
+    // Windows Credential Manager 通用凭据 blob 上限 2560 字节，跨平台采用保守值。
+    if (encoded.byteLength > 2400)
+        throw new CredentialError('凭据总长度超过 2400 字节，请检查输入；未保存');
+    return encoded;
+}
+export class KeyringStore {
+    Entry;
+    constructor(Entry) {
+        this.Entry = Entry;
+    }
+    entry(id) { validateId(id); return new this.Entry(SERVICE, id); }
+    read(id) {
+        validateId(id);
+        try {
+            const raw = this.entry(id).getSecret();
+            return raw === null ? null : decodeBundle(Uint8Array.from(raw));
+        }
+        catch {
+            throw new CredentialError('系统凭据无法读取或内容无效，请解锁系统存储并允许访问，或使用 setup 重配');
+        }
+    }
+    create(id, values) {
+        validateId(id);
+        const encoded = encodeBundle(values);
+        let entry;
+        try {
+            entry = this.entry(id);
+            if (entry.getSecret() !== null)
+                throw new CredentialError('随机凭据引用已存在，未覆盖，请重试');
+        }
+        catch (error) {
+            if (error instanceof CredentialError)
+                throw error;
+            throw new CredentialError('无法访问系统凭据存储，请检查系统权限');
+        }
+        try {
+            entry.setSecret(encoded);
+        }
+        catch {
+            // 后端可能已写入后才抛错，仅清理此前确认不存在的本次随机条目。
+            try {
+                entry.deleteCredential();
+            }
+            catch {
+                throw new CredentialError(`凭据写入状态未知且清理失败，需检查引用 ID：${id}`);
+            }
+            throw new CredentialError('系统凭据写入失败，未切换配置');
+        }
+    }
+    remove(id) {
+        validateId(id);
+        try {
+            this.entry(id).deleteCredential();
+        }
+        catch {
+            throw new CredentialError('系统凭据删除失败，请检查存储权限');
+        }
+    }
+}
+const require = createRequire(import.meta.url);
+export function nativeStore(platform = process.platform) {
+    if (platform !== 'win32' && platform !== 'darwin')
+        throw new CredentialError('系统凭据仅支持 Windows/macOS；其他平台请使用环境变量');
+    try {
+        const binding = require('@napi-rs/keyring');
+        return new KeyringStore(binding.Entry);
+    }
+    catch {
+        throw new CredentialError('原生凭据组件无法加载，请确认 npm 安装保留 optional 依赖且架构匹配；不会降级为明文');
+    }
+}
+export function resolveReference(reference) {
+    if (reference.backend === 'system')
+        throw new CredentialError('这是 Python 原型的凭据引用；请用 setup 重新输入并保存为 Node 凭据，或显式提供环境变量。不会自动读取或删除旧凭据');
+    const values = nativeStore().read(reference.id);
+    if (values === null)
+        throw new CredentialError('系统凭据条目缺失，请运行 setup 重新配置');
+    return values;
+}

package/dist/formatting.js

@@ -0,0 +1,210 @@
+export const escapeHtml = (text) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+export const partTitle = (title, index, total) => total > 1 ? `${title} (${index + 1}/${total})` : title;
+function inline(text, tags = [], depth = 0) {
+    if (depth > 8)
+        return [{ text, tags }];
+    // 不在生成的 HTML 上执行 Markdown 正则，避免修改链接属性。
+    const expression = /`([^`\n]+)`|\[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)|\*\*(\S(?:.*?\S)?)\*\*|__(\S(?:.*?\S)?)__|~~(\S(?:.*?\S)?)~~|(?<![\w*])\*([^*\n]+)\*(?![\w*])|(?<![\w_])_([^_\n]+)_(?![\w_])/g;
+    const spans = [];
+    let cursor = 0;
+    for (const match of text.matchAll(expression)) {
+        if (match.index > cursor)
+            spans.push({ text: text.slice(cursor, match.index), tags });
+        if (match[1] !== undefined)
+            spans.push({ text: match[1], tags: [...tags, 'code'] });
+        else if (match[2] !== undefined) {
+            // 链接地址同样保留在可见文本中；任何纯文本回退都不会丢失地址。
+            spans.push(...inline(match[2], tags, depth + 1), { text: ` (${match[3]})`, tags });
+        }
+        else {
+            const content = match[4] ?? match[5] ?? match[6] ?? match[7] ?? match[8];
+            const tag = match[4] !== undefined || match[5] !== undefined ? 'b' : match[6] !== undefined ? 's' : 'i';
+            spans.push(...inline(content, [...tags, tag], depth + 1));
+        }
+        cursor = match.index + match[0].length;
+    }
+    if (cursor < text.length)
+        spans.push({ text: text.slice(cursor), tags });
+    return spans.length ? spans : [{ text: '', tags }];
+}
+function cells(line) {
+    return line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map(cell => inline(cell.trim()).map(s => s.text).join(''));
+}
+function separator(line) {
+    return line.includes('|') && line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').every(cell => /^:?-{3,}:?$/.test(cell.trim()));
+}
+function width(text) {
+    let size = 0;
+    for (const ch of text) {
+        const code = ch.codePointAt(0);
+        size += code >= 0x1100 && (code <= 0x115f || code >= 0x2e80 && code <= 0xa4cf || code >= 0xac00 && code <= 0xd7af || code >= 0xff01 && code <= 0xff60 || code >= 0x1f300) ? 2 : 1;
+    }
+    return size;
+}
+function table(lines) {
+    const rows = lines.filter((_, index) => index !== 1).map(cells);
+    const count = Math.max(...rows.map(row => row.length));
+    const widths = Array.from({ length: count }, (_, col) => Math.max(3, ...rows.map(row => width(row[col] ?? ''))));
+    const output = [];
+    rows.forEach((row, index) => {
+        output.push(widths.map((size, col) => (row[col] ?? '') + ' '.repeat(size - width(row[col] ?? ''))).join(' | '));
+        if (!index)
+            output.push(widths.map(size => '-'.repeat(size)).join('-+-'));
+    });
+    return output.join('\n');
+}
+export function parseMarkdown(content) {
+    const lines = content.replace(/\r\n?/g, '\n').replace(/\0/g, '').split('\n');
+    const blocks = [];
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        const fence = /^\s*(`{3,}|~{3,})(.*)$/.exec(line);
+        if (fence) {
+            const marker = fence[1][0];
+            const closing = new RegExp(`^\\s*${marker === '`' ? '`' : '~'}{${fence[1].length},}\\s*$`);
+            const body = [];
+            index++;
+            while (index < lines.length && !closing.test(lines[index]))
+                body.push(lines[index++]);
+            if (index < lines.length)
+                index++;
+            blocks.push({ spans: [{ text: body.join('\n'), tags: [] }], code: true });
+            continue;
+        }
+        if (index + 1 < lines.length && line.includes('|') && separator(lines[index + 1])) {
+            const rows = [line, lines[index + 1]];
+            index += 2;
+            while (index < lines.length && lines[index].trim() && lines[index].includes('|'))
+                rows.push(lines[index++]);
+            blocks.push({ spans: [{ text: table(rows), tags: [] }], code: true });
+            continue;
+        }
+        const heading = /^\s{0,3}#{1,6}\s+(.*)$/.exec(line);
+        const quote = /^\s*>\s?(.*)$/.exec(line);
+        const list = /^(\s*)[-*+]\s+(.*)$/.exec(line);
+        let spans;
+        if (heading)
+            spans = inline(heading[1], ['b']);
+        else if (/^\s*([-*_])(?:\s*\1){2,}\s*$/.test(line))
+            spans = [{ text: '────────', tags: [] }];
+        else if (quote)
+            spans = inline(quote[1], ['blockquote']);
+        else if (list)
+            spans = inline(`${list[1]}• ${list[2].replace(/^\[ \] /, '☐ ').replace(/^\[x\] /i, '☑ ')}`);
+        else
+            spans = inline(line);
+        blocks.push({ spans, code: false });
+        index++;
+    }
+    return blocks;
+}
+export function visibleText(blocks) {
+    return blocks.map(block => block.spans.map(span => span.text).join('')).join('\n');
+}
+function cut(text, budget, measure) {
+    if (budget < 1)
+        throw new Error('分段空间不足');
+    let used = 0, end = 0;
+    for (const ch of text) {
+        const size = measure(ch);
+        if (used + size > budget)
+            break;
+        used += size;
+        end += ch.length;
+    }
+    if (!end && text)
+        throw new Error('分段空间不足以容纳一个字符');
+    if (end < text.length) {
+        for (const boundary of ['\n\n', '\n', ' ']) {
+            const offset = text.slice(0, end).lastIndexOf(boundary);
+            if (offset >= end / 2) {
+                end = offset + boundary.length;
+                break;
+            }
+        }
+    }
+    return [text.slice(0, end), text.slice(end)];
+}
+export function telegramParts(blocks, budget) {
+    if (budget < 2)
+        throw new Error('Telegram 标题或辅助信息过长');
+    const output = [];
+    let html = '', plain = '';
+    const flush = () => { if (plain)
+        output.push({ html, plain }); html = ''; plain = ''; };
+    blocks.forEach((block, index) => {
+        const spans = index ? [{ text: '\n', tags: [] }, ...block.spans] : block.spans;
+        for (const span of spans) {
+            let rest = span.text;
+            while (rest) {
+                if (budget - plain.length < [...rest][0].length)
+                    flush();
+                const [piece, remaining] = cut(rest, budget - plain.length, text => text.length);
+                // 块间换行不包裹为代码，其余内容每片均使用完整标签。
+                const actualTags = block.code && !(index && span === spans[0]) ? ['pre'] : span.tags;
+                html += actualTags.map(tag => `<${tag}>`).join('') + escapeHtml(piece) + [...actualTags].reverse().map(tag => `</${tag}>`).join('');
+                plain += piece;
+                rest = remaining;
+                if (rest)
+                    flush();
+            }
+        }
+    });
+    flush();
+    return output.length ? output : [{ html: '', plain: '' }];
+}
+export function feishuParts(blocks, budget) {
+    if (budget < 128)
+        throw new Error('飞书标题或辅助信息过长');
+    const output = [];
+    let current = '';
+    const size = (text) => Buffer.byteLength(text, 'utf8');
+    const flush = () => { if (current)
+        output.push(current); current = ''; };
+    blocks.forEach((block, index) => {
+        if (index) {
+            if (size(current) + 1 > budget)
+                flush();
+            current += '\n';
+        }
+        for (const span of block.spans) {
+            let rest = span.text;
+            let prefix = '', suffix = '';
+            if (block.code) {
+                const runs = rest.match(/`+/g) ?? [];
+                const marker = '`'.repeat(Math.max(3, ...runs.map(run => run.length + 1)));
+                prefix = marker + 'text\n';
+                suffix = '\n' + marker;
+                // 极端围栏长度下保留字面正文，不无限增大包装。
+                if (size(prefix + suffix) > budget / 2) {
+                    prefix = '';
+                    suffix = '';
+                }
+            }
+            else {
+                for (const tag of span.tags) {
+                    const wrapper = tag === 'b' ? '**' : tag === 'i' ? '*' : tag === 's' ? '~~' : tag === 'code' ? '`' : '';
+                    if (tag === 'blockquote')
+                        prefix += '▎ ';
+                    else {
+                        prefix += wrapper;
+                        suffix = wrapper + suffix;
+                    }
+                }
+            }
+            while (rest) {
+                const overhead = size(prefix + suffix);
+                if (size(current) + overhead + size([...rest][0]) > budget)
+                    flush();
+                const [piece, remaining] = cut(rest, budget - size(current) - overhead, size);
+                current += prefix + piece + suffix;
+                rest = remaining;
+                if (rest)
+                    flush();
+            }
+        }
+    });
+    flush();
+    return output.length ? output : [''];
+}

package/dist/prompts.js

@@ -0,0 +1,96 @@
+import { emitKeypressEvents } from 'node:readline';
+import { createInterface } from 'node:readline/promises';
+import { ConfigError } from './config.js';
+export class Cancelled extends Error {
+}
+export function terminalPrompts() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        throw new ConfigError('配置向导需要交互终端；自动化请使用 setup --template --yes 和环境变量');
+    return {
+        out: text => console.log(text),
+        text: label => readText(label),
+        secret: label => readHidden(label),
+    };
+}
+export async function readText(label, input = process.stdin, output = process.stdout) {
+    const terminal = createInterface({ input, output });
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    terminal.once('SIGINT', cancel);
+    terminal.once('close', cancel);
+    try {
+        return (await terminal.question(label, { signal: controller.signal })).trim();
+    }
+    catch {
+        throw new Cancelled('已取消');
+    }
+    finally {
+        terminal.off('SIGINT', cancel);
+        terminal.off('close', cancel);
+        terminal.close();
+    }
+}
+export async function readHidden(label, input = process.stdin, output = process.stdout) {
+    if (!input.isTTY || !output.isTTY || typeof input.setRawMode !== 'function')
+        throw new ConfigError('当前终端不支持隐藏输入，拒绝回显密钥');
+    const wasRaw = input.isRaw, wasPaused = input.isPaused();
+    return new Promise((resolve, reject) => {
+        let value = '';
+        let finished = false;
+        const cleanup = () => {
+            input.off('keypress', keypress);
+            input.off('error', failed);
+            input.off('end', cancelled);
+            try {
+                input.setRawMode(wasRaw);
+            }
+            catch { /* 终端已关闭时不泄漏输入。 */ }
+            if (wasPaused)
+                input.pause();
+        };
+        const finish = (error) => {
+            if (finished)
+                return;
+            finished = true;
+            cleanup();
+            output.write('\n');
+            const result = value.trim();
+            value = '';
+            error ? reject(error) : resolve(result);
+        };
+        const failed = () => finish(new ConfigError('隐藏输入失败，未保存凭据'));
+        const cancelled = () => finish(new Cancelled('已取消'));
+        const keypress = (text, key = {}) => {
+            if (key.ctrl && (key.name === 'c' || key.name === 'd'))
+                return cancelled();
+            if (key.name === 'return' || key.name === 'enter')
+                return finish();
+            if (key.name === 'backspace' || key.name === 'delete') {
+                value = Array.from(value).slice(0, -1).join('');
+                return;
+            }
+            if (key.ctrl && key.name === 'u') {
+                value = '';
+                return;
+            }
+            if (key.ctrl || key.meta || !text || /[\x00-\x1f\x7f]/.test(text))
+                return;
+            if (value.length + text.length > 8192)
+                return finish(new ConfigError('凭据输入过长，未保存'));
+            value += text;
+        };
+        try {
+            // 先进入 raw mode 再展示提示，任何失败都不退回明文输入。
+            input.setRawMode(true);
+            emitKeypressEvents(input);
+            input.on('keypress', keypress);
+            input.on('error', failed);
+            input.on('end', cancelled);
+            input.resume();
+            output.write(label);
+        }
+        catch {
+            failed();
+        }
+    });
+}