1086 lines
53 KiB
JavaScript
1086 lines
53 KiB
JavaScript
// 主进程 AI 代理
|
||
// ============================================================================
|
||
//
|
||
// 通过 Node 18+ 内置 fetch 调用 LLM API。两条协议分支：
|
||
// - aiProvider === 'openai'（默认）→ POST {baseURL}/chat/completions
|
||
// Authorization: Bearer ...
|
||
// - aiProvider === 'anthropic' → POST {baseURL}/v1/messages
|
||
// x-api-key: ... + anthropic-version
|
||
//
|
||
// 不使用 openai / @anthropic-ai SDK（避免引入依赖；统一在主进程发起，
|
||
// 隐藏 apiKey；统一错误结构供 renderer 弹 toast）。
|
||
//
|
||
// 设计要点：
|
||
// - 每个请求用一个 requestId 追踪；调用方通过 ai:cancel IPC 终止
|
||
// - 配置（provider / baseURL / apiKey / model / systemPrompt）从
|
||
// configStore.getConfig() 现读现用，用户改完设置不需要重启
|
||
// - 错误统一返回 { ok:false, error, message }，error 是稳定的错误码字符串，
|
||
// message 是用户能看的中文
|
||
// - API Key 不写日志；请求/响应调试时只用长度 + 状态码
|
||
//
|
||
// 协议差异（两个分支各自完整处理；共享的 cancel / 校验 / 响应后处理 抽到 helper）：
|
||
// 请求体:
|
||
// OpenAI : { model, temperature, max_tokens, max_completion_tokens,
|
||
// messages: [{role, content}], stream:false }
|
||
// Anthropic : { model, max_tokens, system, messages: [{role, content}], ... }
|
||
//
|
||
// 响应体:
|
||
// OpenAI : choices[0].message.content (string)
|
||
// choices[0].finish_reason === 'length' 截断
|
||
// Anthropic : content[].text (拼接所有 text 块)
|
||
// stop_reason === 'max_tokens' 截断
|
||
// ============================================================================
|
||
|
||
'use strict';
|
||
|
||
const CURRENT_FILE_EDIT_SYSTEM_PROMPT =
|
||
'你是 Markdown 文本助手。输入 JSON 格式含 filename、currentMarkdown、userPrompt。请按 userPrompt 修改 currentMarkdown，然后直接输出 JSON 格式：{"content":"完整 Markdown"}。如果 userPrompt 与文档修改无关，或者是 {"content":"完整 Markdown"} 内容和 currentMarkdown 完全一致，直接简单回复即可，不需要回复 {"content":"完整 Markdown"}。';
|
||
|
||
const DEFAULT_TIMEOUT_MS = 300_000;
|
||
// 内容长度硬上限：防止单次请求几 MB 把 LLM 计费用爆、把事件循环卡住。
|
||
// 1.5 MB ≈ 38 万字符 / 10 万行；超过的文档让用户拆分或手动改。
|
||
const MAX_CONTENT_BYTES = 1_500_000;
|
||
// 提示词硬上限：64 KB ≈ 1.6 万中文字。系统提示词另算（settings 上限 200 KB，
|
||
// 拼接后的总输入也由各 API 服务端二次校验）；这里只挡用户 prompt 单字段。
|
||
const MAX_PROMPT_BYTES = 64_000;
|
||
// 响应体大小上限：防止恶意 / 错误配置的服务器返回几百 MB body 把主进程 OOM。
|
||
// 5 MB 对正常 AI 回复（几十 KB 到 1 MB）足够宽松。
|
||
const MAX_RESP_BYTES = 5 * 1024 * 1024;
|
||
// tryParseJson 输入硬上限：getJsonCandidates 里的 fenced block 正则 +
|
||
// indexOf/lastIndexOf/slice 在 5 MB 字符串上仍有可观 CPU 占用，
|
||
// 且对对抗性输入（无闭合 ```）会让非贪婪量词扫到尾；提前砍掉尾巴，
|
||
// 让 JSON 解析失败直接走 extractRawReply 的回退路径。
|
||
const MAX_PARSE_INPUT_BYTES = 2_000_000;
|
||
|
||
// Anthropic API 当前稳定版本（2023-06-01 之后未再变）
|
||
const ANTHROPIC_API_VERSION = '2023-06-01';
|
||
|
||
// audit fix (CQ-MED-7)：错误码字面值与 renderer 端共享。preload 经 contextBridge
|
||
// 把同一份 AI_ERROR 暴露到 window.api.aiErrors，main / renderer 永远引用同一对象，
|
||
// 不再靠注释提醒同步。
|
||
const { AI_ERROR } = require('../shared/ai-errors.js');
|
||
const nodeCrypto = require('node:crypto');
|
||
// R3 P0-1：aiApiKey 走 safeStorage 加密后，磁盘上是 enc:v1: 包络；config
|
||
// 加载到 appConfig 时已经 decrypt 一次（见 main/config-store.js loadConfig），
|
||
// 但这里是直接接 getConfig() 的兜底路径，防御性再 decrypt 一次（passthrough
|
||
// 明文，包络也安全），避免未来调用方改动时漏掉解密。
|
||
const secretStore = require('./secret-store.js');
|
||
const { makeCleanupEpoch } = require('./cleanup-epoch.js');
|
||
const ERR_NOT_CONFIGURED = AI_ERROR.NOT_CONFIGURED;
|
||
const ERR_TIMEOUT = AI_ERROR.ERR_TIMEOUT;
|
||
const ERR_PROVIDER = AI_ERROR.ERR_PROVIDER;
|
||
const ERR_FORMAT = AI_ERROR.ERR_FORMAT;
|
||
const ERR_CANCELLED = AI_ERROR.ERR_CANCELLED;
|
||
|
||
const TRUNCATED_MESSAGE = 'AI 修改结果不完整，请缩小文档或简化要求后重试。';
|
||
|
||
/**
|
||
* 把超长输入砍到上限内（按 UTF-8 字节）。MAX_PARSE_INPUT_BYTES 之外的尾部
|
||
* 在多数 AI 模型回复里没有意义（远早于 JSON 边界）—— 直接截掉既防 ReDoS，
|
||
* 又让正则 / indexOf 不再 O(n²) 退化。
|
||
* @param {string} message
|
||
* @returns {string}
|
||
*/
|
||
function capForParse(message) {
|
||
const s = String(message || '');
|
||
if (Buffer.byteLength(s, 'utf8') <= MAX_PARSE_INPUT_BYTES) return s;
|
||
// 按字符截可能切到 UTF-8 序列中间；用 Buffer 切字节再转回字符串，
|
||
// 最后若尾部半个 multi-byte 用 toString('utf8') 会被替换成 U+FFFD，
|
||
// 但 JSON.parse 会立即抛 SyntaxError → 由 tryParseJson 的 catch 兜底。
|
||
return Buffer.from(s, 'utf8').subarray(0, MAX_PARSE_INPUT_BYTES).toString('utf8');
|
||
}
|
||
|
||
/**
|
||
* 提取 AI 消息中的 JSON 候选：trimmed 原文 / 三反引号代码块 / 第一个 { 到最后一个 }。
|
||
* @param {string} message
|
||
* @returns {string[]}
|
||
*/
|
||
function getJsonCandidates(message) {
|
||
const trimmed = capForParse(message).trim();
|
||
const candidates = [trimmed];
|
||
const fencedBlock = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
|
||
if (fencedBlock && fencedBlock[1]) {
|
||
candidates.push(fencedBlock[1].trim());
|
||
}
|
||
const jsonStart = trimmed.indexOf('{');
|
||
const jsonEnd = trimmed.lastIndexOf('}');
|
||
if (jsonStart !== -1 && jsonEnd > jsonStart) {
|
||
candidates.push(trimmed.slice(jsonStart, jsonEnd + 1));
|
||
}
|
||
return [...new Set(candidates)];
|
||
}
|
||
|
||
function tryParseJson(message) {
|
||
for (const candidate of getJsonCandidates(message)) {
|
||
try {
|
||
return JSON.parse(candidate);
|
||
} catch {
|
||
// continue
|
||
}
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
/**
|
||
* 在 message 中找第一个花括号配对的 JSON 对象，并把对象文本截出来。
|
||
* 简单字符串扫描 —— O(n) 处理嵌套 `{` `}` 和字符串字面量（避免 JSON 内容里的
|
||
* 引号 / 反斜杠把花括号配对误判）。找不到配对返回 null。
|
||
*
|
||
* 与 getJsonCandidates 的 brace-pair 切片不同：这里还要在体内识别字符串里的
|
||
* 转义序列（`\"` / `\\`），因此专写一个实现而非复用 indexOf/lastIndexOf。
|
||
*
|
||
* @param {string} s
|
||
* @returns {string|null}
|
||
*/
|
||
function extractFirstJsonObject(s) {
|
||
const str = String(s || '');
|
||
const len = str.length;
|
||
let start = -1;
|
||
let depth = 0;
|
||
let inStr = false;
|
||
let escape = false;
|
||
for (let i = 0; i < len; i++) {
|
||
const ch = str[i];
|
||
if (inStr) {
|
||
if (escape) { escape = false; continue; }
|
||
if (ch === '\\') { escape = true; continue; }
|
||
if (ch === '"') { inStr = false; }
|
||
continue;
|
||
}
|
||
if (ch === '"') { inStr = true; continue; }
|
||
if (ch === '{') {
|
||
if (start < 0) start = i;
|
||
depth++;
|
||
continue;
|
||
}
|
||
if (ch === '}') {
|
||
if (depth === 0) continue;
|
||
depth--;
|
||
if (depth === 0 && start >= 0) return str.slice(start, i + 1);
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function looksLikeEditJson(message) {
|
||
// audit fix：之前的 /"content"\s*:/ 太宽松 —— 用户提示词里只要含 `"content":`
|
||
// 子串就会被当作「AI 改稿的 JSON 截断」，误报 TRUNCATED_MESSAGE。
|
||
// 第二版 `/\{[^{}]*"content"\s*:[^{}]*\}/` 又过紧 —— 当 content 字段后跟随嵌套
|
||
// 对象（例：`{"content":"x","patches":[{"op":"replace"}]}`）时 `[^{}]*` 立刻失配，
|
||
// AI 返回"看似想输出 JSON 但 token 不够截断"的场景下，TRUNCATED 提示被静默吃掉。
|
||
//
|
||
// 现在走 extractFirstJsonObject 取出第一个配对的 JSON 对象文本，再在体内找
|
||
// `"content"` 键（允许值跨多行、允许嵌套、字符串里的 " 不会干扰）。
|
||
// —— 简单纯文本（"please edit {content} now"）也不会命中，因为：
|
||
// 1. 字符串里的花括号不算嵌套对象起点（inStr 分支已处理）；
|
||
// 2. 真正配对的对象才走 key 搜索。
|
||
//
|
||
// 截断的 JSON（花括号未闭合 / 数组未闭合）：extractFirstJsonObject 找不到配对对象，
|
||
// 这里直接返回 false —— normalizeAssistantText 会走 raw 回退把残文本返回给用户。
|
||
// 用户能看到 AI 输出了什么，比直接弹"不完整"更直观。截断信号应当由上游
|
||
// finish_reason=length / stop_reason=max_tokens 在更早的路径触发，不依赖正文配对。
|
||
const obj = extractFirstJsonObject(message);
|
||
if (!obj) return false;
|
||
// 体内 key 检测：用 `"content"` 加 `:` 兜住常见间距（`"content" :` / `"content":`）；
|
||
// 不复用 contains('"content"') 是为了避免匹配键名包含 content 子串的字段
|
||
// （如 `"mycontent":1` —— 但这种情况极少见，多一道正则更稳）。
|
||
return /"content"\s*:/.test(obj);
|
||
}
|
||
|
||
/**
|
||
* 从非 JSON 解析得到的对象里挑 reply/message/text/answer 字段当作纯文本。
|
||
* @param {unknown} parsed
|
||
* @returns {string | null}
|
||
*/
|
||
function extractRawReply(parsed) {
|
||
if (!parsed || typeof parsed !== 'object') return null;
|
||
for (const key of ['reply', 'message', 'text', 'answer']) {
|
||
const value = /** @type {Record<string, unknown>} */ (parsed)[key];
|
||
if (typeof value === 'string') return value;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 拼接 baseURL + path，自动处理末尾斜杠。
|
||
* @param {string} base
|
||
* @param {string} path
|
||
* @returns {string}
|
||
*/
|
||
// P2-6 (audit)：joinUrl / pickOpenAITokenConfig 每次 AI 请求都重复跑
|
||
// regex + new URL 解析；同 baseURL / 同 model 在一次会话里反复命中，
|
||
// LRU 缓存结果。maxSize 64 覆盖「用户试过的 URL + model」组合，无界增长免疫。
|
||
const { createLruCache } = require('./lru-cache.js');
|
||
const _joinUrlCache = createLruCache({ maxSize: 64 });
|
||
const _tokenConfigCache = createLruCache({ maxSize: 64 });
|
||
|
||
function joinUrl(base, path) {
|
||
const cacheKey = `${base}|${path}`;
|
||
const hit = _joinUrlCache.get(cacheKey);
|
||
if (hit !== undefined) return hit;
|
||
const joined = _joinUrlUncached(base, path);
|
||
_joinUrlCache.set(cacheKey, joined);
|
||
return joined;
|
||
}
|
||
|
||
function _joinUrlUncached(base, path) {
|
||
// P3-3 fix (audit)：拆分 query / fragment 后再拼。
|
||
// 否则 `https://gw.com?token=abc` 会被拼成 `https://gw.com?token=abc/v1/messages`
|
||
// （query 后被拼了 path，URL 非法）。query / fragment 也可能在错误回显时
|
||
// 包含 api_key 之类敏感 token，所以一并禁止放在 baseURL 里。
|
||
// M2 fix (audit)：剥掉 baseURL 里可能存在的 userinfo（`https://user:pass@host`）。
|
||
// fetch 会把 userinfo 当 Basic Auth 自动发送，把 API Key 当用户名/密码发给中转服务，
|
||
// 敏感凭据直接泄露到第三方；错误回显里也会暴露凭据。
|
||
//
|
||
// M2 follow-up：旧 regex `^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@` 只识别字面 `@`，
|
||
// 对 percent-encoded `user%40evil.com:pass@host` 会放过（`%40` 走 URL 解析后
|
||
// 才被还原成 `@`，fetch 仍按 Basic Auth 发送）。统一走 new URL 解析：URL parser
|
||
// 主动还原 percent-encoding 并暴露 username / password，靠这两个字段判定 /
|
||
// 剥除更稳。query / fragment 仍由外层 split 拿回。
|
||
const s = String(base || '');
|
||
const m = s.match(/^([^?#]*)(\?[^#]*)?(#.*)?$/);
|
||
if (!m) return s;
|
||
let originAndPath = m[1].replace(/\/+$/, '');
|
||
try {
|
||
const parsed = new URL(originAndPath);
|
||
// 任何形式的 userinfo（字面 / percent-encoded / IDN punycode 包装）都会
|
||
// 被 URL parser 还原到 username / password 字段。剥干净再拼回。
|
||
// 注意：直接把 username/password 置空 + toString() 仍会保留空 userinfo 的
|
||
// `https://@host` 形式，所以这里走 host + pathname 重组最稳。
|
||
if (parsed.username || parsed.password) {
|
||
const port = parsed.port ? `:${parsed.port}` : '';
|
||
originAndPath = `${parsed.protocol}//${parsed.hostname}${port}${parsed.pathname}`.replace(/\/+$/, '');
|
||
}
|
||
} catch {
|
||
// URL 解析失败：保留原字符串的 regex 兜底（防御旧路径畸形输入）
|
||
originAndPath = originAndPath.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/, '$1');
|
||
}
|
||
const p = String(path || '').replace(/^\/+/, '');
|
||
return `${originAndPath}/${p}${m[2] || ''}${m[3] || ''}`;
|
||
}
|
||
|
||
/**
|
||
* 过滤错误回显里的敏感 token（OpenAI/Anthropic/proxy 可能在错误信息里
|
||
* echo URL 或 header）。API Key 不该出现在用户能看到的 toast 里。
|
||
* P2-2 fix (audit)；Q3 fix (audit)：补 Google API key / JWT / proxy-authorization。
|
||
* @param {string} detail
|
||
* @returns {string}
|
||
*/
|
||
function sanitizeDetail(detail) {
|
||
return String(detail || '')
|
||
// OpenAI / 通用 OpenAI 风格 key：sk-xxx / sk-proj-xxx / sk-ant-xxx
|
||
// M3 fix (audit)：阈值 8 → 5，捕获被截断的 key（错误回显常见前缀模式 sk-12ab...）。
|
||
// 5 是保守下限：正常文本里 5 位随机 base64url 不常见
|
||
.replace(/sk-[A-Za-z0-9_-]{5,}/g, '[API_KEY]')
|
||
// Google API key：AIzaSy 开头 + 33 字符。33 是 Google 当前规范
|
||
.replace(/AIzaSy[A-Za-z0-9_-]{20,}/g, '[API_KEY]')
|
||
// JWT：header.payload.signature 三段 base64url；至少各 8 字符避免误伤短词
|
||
.replace(/eyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, '[JWT]')
|
||
// M3 fix (audit)：先单独处理 JSON 风格 `"authorization": "Bearer sk-xxx"`——
|
||
// 旧正则 `[^\s,;&}"']+` 遇到 `"` 就停，只盖到 `"Bearer`，剩余 ` sk-xxx"`
|
||
// 直接漏到下一步被文本截断逻辑保留。现在用单独 pattern 一次性吃掉整段带引号的值。
|
||
// audit fix (Phase O-L19)：扩到 `authentication` / `www-authenticate` / `cookie` /
|
||
// `set-cookie` —— 自部署中转 / Azure gateway 偶尔回 `Authentication: Bearer sk-xxx`，
|
||
// LLM 自定义代理常通过 cookie 传 key。原始 key 不会泄露（line 229 的 sk-/AIzaSy
|
||
// 兜底会替成 [API_KEY]），但 header 名这一行会在 detail 文本里残留。
|
||
.replace(/("(?:proxy-authorization|x-api-key|authorization|authentication|www-authenticate|cookie|set-cookie)"\s*:\s*)"[^"]*"/gi, '$1"[REDACTED]"')
|
||
// 任意 header 里出现敏感 token —— 含 proxy-authorization（Q3 audit 新增）
|
||
// 不再排除 `"` 和 `'`：让正则跨过引号吃掉值（与 JSON pattern 互补，命中 form-style）
|
||
.replace(/(proxy-authorization|x-api-key|authorization|authentication|www-authenticate|cookie|set-cookie)\s*[:=]\s*[^\s,;&}]+/gi, '$1=[REDACTED]')
|
||
// URL query 或 form body 里的 key/token
|
||
.replace(/(api[_-]?key|token)\s*=\s*[^\s,;&}]+/gi, '$1=[REDACTED]');
|
||
}
|
||
|
||
/**
|
||
* 把 URL 中可能携带 secret 的部分脱敏再写到日志。
|
||
* 1. 去掉 query 和 fragment（用户 baseURL 不该带 ?api_key=xxx / #fragment，但有人会带）
|
||
* 2. path 段里嵌入的 secret token（OpenAI sk-xxx / Google AIzaSy）也遮罩
|
||
* 保留 scheme + host + path，便于调试"请求打到哪个域名"，但不带任何 secret。
|
||
* Q6 fix (audit)。
|
||
* @param {string} raw
|
||
* @returns {string}
|
||
*/
|
||
function sanitizeUrl(raw) {
|
||
let s = String(raw || '');
|
||
// M2 follow-up：与 joinUrl 同款 percent-encoded userinfo 防御。
|
||
// 先用 new URL 解析（字面 / 编码 / punycode 都被还原到 username/password），
|
||
// 命中则走 host + pathname 重组。否则 fallback 旧 regex 兜底畸形输入。
|
||
try {
|
||
const parsed = new URL(s);
|
||
if (parsed.username || parsed.password) {
|
||
const port = parsed.port ? `:${parsed.port}` : '';
|
||
s = `${parsed.protocol}//${parsed.hostname}${port}${parsed.pathname}`;
|
||
}
|
||
} catch {
|
||
s = s.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/, '$1');
|
||
}
|
||
return s
|
||
.replace(/[?#].*$/, '') // 去 query / fragment
|
||
.replace(/\/(sk-[A-Za-z0-9_-]{8,})/g, '/[REDACTED]') // path 段里的 OpenAI key
|
||
.replace(/\/(AIzaSy[A-Za-z0-9_-]{20,})/g, '/[REDACTED]'); // path 段里的 Google key
|
||
}
|
||
|
||
/**
|
||
* 读 response body 到字符串，超过 MAX_RESP_BYTES 立刻中断。
|
||
* P2-3 fix (audit)。
|
||
* @param {Response} res
|
||
* @returns {Promise<{ ok:true, text:string } | { ok:false, message:string }>}
|
||
*/
|
||
async function readBodyWithLimit(res) {
|
||
if (!res.body || typeof res.body.getReader !== 'function') {
|
||
// 旧版 fetch / mock：fallback 到 .text()，上限由 .text() 自带的内存限制兜底
|
||
try {
|
||
const text = await res.text();
|
||
if (Buffer.byteLength(text, 'utf8') > MAX_RESP_BYTES) {
|
||
return { ok: false, message: 'AI 响应体过大' };
|
||
}
|
||
return { ok: true, text };
|
||
} catch {
|
||
return { ok: false, message: '读取 AI 响应失败' };
|
||
}
|
||
}
|
||
const reader = res.body.getReader();
|
||
/** @type {Buffer[]} */
|
||
const chunks = [];
|
||
let total = 0;
|
||
let readErr = null;
|
||
while (true) {
|
||
let value;
|
||
let done;
|
||
try {
|
||
({ value, done } = await reader.read());
|
||
} catch (e) {
|
||
readErr = e;
|
||
break;
|
||
}
|
||
if (done) break;
|
||
total += value.byteLength;
|
||
if (total > MAX_RESP_BYTES) {
|
||
try { reader.cancel(); } catch { /* ignore */ }
|
||
return { ok: false, message: 'AI 响应体过大（超过 5 MB）' };
|
||
}
|
||
chunks.push(Buffer.from(value));
|
||
}
|
||
if (readErr) {
|
||
// Round 13 fix (M9)：reader.read() 抛错时不 cancel — 流连接资源会被 GC
|
||
// 最终释放，但 fetch 在 abort 时仍可能持有未读数据；显式 cancel 让对端
|
||
// 立即知道我们不再消费，提早关连接。
|
||
try { reader.cancel(); } catch { /* ignore */ }
|
||
return { ok: false, message: '读取 AI 响应失败' };
|
||
}
|
||
return { ok: true, text: Buffer.concat(chunks).toString('utf8') };
|
||
}
|
||
|
||
/**
|
||
* 创建主进程 AI 代理。
|
||
* @param {object} deps
|
||
* @param {() => object} deps.getConfig - 取最新设置（configStore.getConfig）；每次 runEdit 都会调用
|
||
* @param {typeof fetch} [deps.fetchImpl] - 注入 fetch（测试用）
|
||
* @param {(key: string, payload: object) => void} [deps.log] - 日志钩子（不记录 apiKey）
|
||
*/
|
||
function createAiProxy({ getConfig, fetchImpl, log } = {}) {
|
||
if (typeof getConfig !== 'function') {
|
||
throw new Error('[ai] getConfig 必须是函数');
|
||
}
|
||
const fetchFn = fetchImpl || ((...args) => fetch(...args));
|
||
const logFn = typeof log === 'function' ? log : () => {};
|
||
|
||
/** @type {Map<string, AbortController>} */
|
||
const pending = new Map();
|
||
/** requestId → 它的超时定时器。cancel 时一起清，避免 setTimeout 回调空转。 */
|
||
const timers = new Map();
|
||
// audit fix (P1-5)：cancelAll 顺序竞争 epoch 闸。cancelAll 三步非原子
|
||
// （abort → clear → clear），与新 runEdit 同步阶段加 entry 存在竞态窗口。
|
||
// cleanupEpoch.invalidate() 让所有「更早 snapshot」的 in-flight runEdit
|
||
// 自行 bail（isCurrent → false），避免「同 requestId 重试找不到 controller」。
|
||
const cleanupEpoch = makeCleanupEpoch();
|
||
/** audit fix (C4)：请求生命周期登记集合（runEdit 入口 → finally），用于
|
||
* 真正拦截同 requestId 的重复进入 —— 之前的 pending 集合是 postJson 内部填的，
|
||
* runEdit 同步阶段检查永远是空，已被注释自承为 dead code。 */
|
||
const inFlightRequestIds = new Set();
|
||
|
||
function cancel(requestId) {
|
||
const controller = pending.get(requestId);
|
||
const timer = timers.get(requestId);
|
||
if (controller) {
|
||
controller.abort();
|
||
pending.delete(requestId);
|
||
}
|
||
if (timer) {
|
||
clearTimeout(timer);
|
||
timers.delete(requestId);
|
||
}
|
||
}
|
||
|
||
function cancelAll() {
|
||
// audit fix (P1-5)：入口先 invalidate，挡掉「cancelAll 期间新 runEdit
|
||
// 同步阶段已加入 entry」竞态。新 runEdit 入口会 snapshot 当前 epoch，
|
||
// await 后 isCurrent → false 时 bail，不污染主流程返回。
|
||
cleanupEpoch.invalidate();
|
||
for (const controller of pending.values()) controller.abort();
|
||
pending.clear();
|
||
// C1 (audit)：与 cancel() 一样同步清理 timeout，避免 setTimeout 回调空转
|
||
for (const timer of timers.values()) clearTimeout(timer);
|
||
timers.clear();
|
||
// 第二阶段代码审查 (Phase 2 review #3)：同步清理 inFlightRequestIds。
|
||
// 之前只清 pending / timers —— runEdit 的 finally 也会 clear 自己加进 Set
|
||
// 的 requestId，所以正常路径下 Set 会自然排空。但 cancelAll 在
|
||
// app.on('will-quit') 调用（main.js:889），与 runEdit finally 之间存在
|
||
// 竞态窗口：requestId 仍残留在 Set 里时若有新 AI 请求复用同一 requestId
|
||
// （test harness / HMR / 未来 re-init），cancel(requestId) 会取消错对象。
|
||
// 显式 clear 让 cancelAll 真正幂等且不留残根。
|
||
inFlightRequestIds.clear();
|
||
}
|
||
|
||
/**
|
||
* 校验 baseURL 是否为合法 http(s) URL。
|
||
* 防止 javascript: / file: / data: 等伪协议触发 fetch TypeError 后报成"网络错误"误导用户。
|
||
* M1 (audit)：旧版只走 fetch 抛错，错误信息不友好。
|
||
* @param {string} base
|
||
* @returns {{ok:true, value:string} | {ok:false, reason:string}}
|
||
*/
|
||
function validateBaseUrl(base) {
|
||
const s = String(base || '').trim();
|
||
if (!s) return { ok: false, reason: 'Base URL 不能为空' };
|
||
if (!/^https?:\/\//i.test(s)) {
|
||
return { ok: false, reason: 'Base URL 必须以 http:// 或 https:// 开头' };
|
||
}
|
||
// P2 fix：hostname 校验 —— 之前只校验前缀，`https:///etc/passwd`（缺少 host）
|
||
// / `https:// host`（带空格）会被放行，然后 fetch 抛「ENOTFOUND / Invalid URL」
|
||
// 但错误信息毫无线索。new URL 直接拒绝这些畸形输入，给出可执行反馈。
|
||
try {
|
||
const parsed = new URL(s);
|
||
if (!parsed.hostname) {
|
||
return { ok: false, reason: 'Base URL 缺少主机名' };
|
||
}
|
||
// 主机名不能包含空白字符或 ASCII 控制字符（防御一些浏览器容忍的奇怪输入）
|
||
// eslint-disable-next-line no-control-regex -- 控制字符范围是刻意检查的非法字符
|
||
if (/[\s\x00-\x1f]/.test(parsed.hostname)) {
|
||
return { ok: false, reason: 'Base URL 主机名包含非法字符' };
|
||
}
|
||
} catch (e) {
|
||
return { ok: false, reason: 'Base URL 不是合法 URL：' + (e && e.message || '') };
|
||
}
|
||
return { ok: true, value: s };
|
||
}
|
||
|
||
/**
|
||
* Round 13 fix (M6)：抽「明文 HTTP + 非 loopback + 已配 Key → 拒绝」共用检查。
|
||
* OpenAI / Anthropic 两条分支各复制 30 行同款防御，现在统一走这里。
|
||
* 本地代理（Ollama / LM Studio / vllm）走 http://localhost / 127.0.0.1 / ::1
|
||
* 不需要 Key（apiKey 留空即放过），配置 Key 时必须 HTTPS。
|
||
* @param {string} baseUrl - 已经 validateBaseUrl 通过的 URL
|
||
* @param {string} apiKey - 当前配置的 API Key（空串 = 未配）
|
||
* @returns {null | {ok:false, error:string, message:string}} 通过时返回 null
|
||
*/
|
||
function rejectInsecureKeyTransport(baseUrl, apiKey) {
|
||
if (!/^http:\/\//i.test(baseUrl) || !apiKey) return null;
|
||
try {
|
||
const parsed = new URL(baseUrl);
|
||
const host = (parsed.hostname || '').toLowerCase();
|
||
const isLoopback = host === 'localhost' || host === '127.0.0.1' || host === '::1';
|
||
if (isLoopback) return null;
|
||
console.warn('[ai] 明文 HTTP + 非loopback + 已配 Key，拒绝请求以防泄露:', sanitizeUrl(baseUrl));
|
||
return {
|
||
ok: false,
|
||
error: ERR_NOT_CONFIGURED,
|
||
message: '检测到 Base URL 使用明文 HTTP 且已配置 API Key；请改用 https:// 以避免 Key 在网络传输中被窃取。本地代理（localhost / 127.0.0.1）允许明文。',
|
||
};
|
||
} catch { /* validateBaseUrl 已校验过 URL，这里兜底 */ }
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 按模型名路由 token 上限 + token 字段。
|
||
* H1 (audit)：65536 远超多数模型上限（gpt-3.5=4096, gpt-4=8192, gpt-4o=16384），
|
||
* 服务端可能直接 400 拒绝或抛 invalid_request_error。
|
||
* H2 (audit)：gpt-5 / o-series 只接受 max_completion_tokens，旧字段会触发
|
||
* "Unsupported parameter" 错误；老模型反过来——只接受 max_tokens。
|
||
* H5 (audit)：gpt-5 / o-series 不接受自定义 temperature（o1 固定为 1），
|
||
* 发 0.2 会 400 invalid_request_error。
|
||
* @param {string} model
|
||
* @returns {{ capTokens: number, tokenField: 'max_tokens' | 'max_completion_tokens', includeTemperature: boolean }}
|
||
*/
|
||
function pickOpenAITokenConfig(model) {
|
||
const key = String(model || '');
|
||
const hit = _tokenConfigCache.get(key);
|
||
if (hit !== undefined) return hit;
|
||
const cfg = _pickOpenAITokenConfigUncached(key);
|
||
_tokenConfigCache.set(key, cfg);
|
||
return cfg;
|
||
}
|
||
|
||
function _pickOpenAITokenConfigUncached(model) {
|
||
const m = String(model || '').toLowerCase();
|
||
// gpt-5 / o-series → 必须用 max_completion_tokens；上限通常 ≥ 128k；不传 temperature
|
||
if (/^(gpt-5|o1|o3|o4)/.test(m)) {
|
||
return { capTokens: 32_000, tokenField: 'max_completion_tokens', includeTemperature: false };
|
||
}
|
||
// gpt-4o / 4-turbo → max_tokens，上限 16k
|
||
if (/^gpt-4o/.test(m) || /^gpt-4-turbo/.test(m)) {
|
||
return { capTokens: 16_384, tokenField: 'max_tokens', includeTemperature: true };
|
||
}
|
||
// 普通 gpt-4 → 8k
|
||
if (/^gpt-4/.test(m)) {
|
||
return { capTokens: 8_192, tokenField: 'max_tokens', includeTemperature: true };
|
||
}
|
||
// gpt-3.5 → 4k
|
||
if (/^gpt-3\.5/.test(m)) {
|
||
return { capTokens: 4_096, tokenField: 'max_tokens', includeTemperature: true };
|
||
}
|
||
// 未知模型（包括国产中转、自部署）：保守值 + 老字段，最大限度兼容
|
||
return { capTokens: 4_096, tokenField: 'max_tokens', includeTemperature: true };
|
||
}
|
||
|
||
/**
|
||
* Anthropic 模型 max_tokens 上限路由。
|
||
* H1 (audit)：Anthropic 不同模型上限差异很大（旧 haiku 4096 / sonnet-3-5 8192），
|
||
* 65536 会被这些老模型 400 拒绝。
|
||
*
|
||
* audit fix (round-13)：补齐「5 系」与 4.6+ 命名。
|
||
* 之前的正则 `claude-(3-5|3\.5|3-7|sonnet-4|opus-4|4)` 要求 `claude-` 后面
|
||
* 紧跟这些片段，于是 claude-opus-5 / claude-sonnet-5 / claude-fable-5 /
|
||
* claude-haiku-4-5 全部不命中 → 回退 8192，反而比 claude-opus-4-8（16384）
|
||
* 更低。结果是「越新、输出上限越高的模型，拿到的 max_tokens 越小」：
|
||
* 长笔记改写会在 8k 处被截断 → stop_reason: max_tokens → runEdit 走
|
||
* TRUNCATED_MESSAGE 分支报「AI 修改结果不完整」。这正是 Phase O-L17
|
||
* 想修掉的那类 bug，只是模型命名又演进了一代。
|
||
*
|
||
* 现行分档（保守取值，远低于官方上限，避免中转/自部署网关拒绝）：
|
||
* - 5 系 + 4.6/4.7/4.8（官方 max output 128k）→ 32k
|
||
* - 其余 4 系（含 haiku-4-5）+ 3-5/3-7 → 16k
|
||
* - claude-3 老家族 → 8k
|
||
* - 未知模型（国产中转 / 自部署）→ 8k，最大限度兼容
|
||
* @param {string} model
|
||
* @returns {number}
|
||
*/
|
||
function pickAnthropicTokenConfig(model) {
|
||
const m = String(model || '').toLowerCase();
|
||
// 5 系（opus-5 / sonnet-5 / fable-5 / mythos-5 / haiku-5）+ 4.6+ → 官方 128k 上限
|
||
// Round 13 fix：旧正则漏了 `claude-haiku-5-*`，会落到下一档的 16k；
|
||
// 同样保留 haiku-5 与其他 5 系在同一档。
|
||
if (/claude-(opus|sonnet|fable|mythos|haiku)-5/.test(m)) return 32_000;
|
||
if (/claude-(opus|sonnet)-4-(6|7|8)/.test(m)) return 32_000;
|
||
// 其余 4 系（sonnet-4-5 / opus-4-5 / haiku-4-5 / claude-4-*）+ 3-5 / 3-7
|
||
if (/claude-(3-5|3\.5|3-7|sonnet-4|opus-4|haiku-4|4)/.test(m)) return 16_384;
|
||
// Round 13 fix (H2)：claude-3 老家族官方 max output = 4096。
|
||
// 旧值 8192 在 opus-3 / sonnet-3 / haiku-3 上会被服务端 400 拒绝，
|
||
// runEdit 走 TRUNCATED_MESSAGE 分支报「AI 修改结果不完整」（实际是
|
||
// 请求参数越界，不是输出被截断）。claude-3-5 / claude-3-7 由上一档命中。
|
||
if (/claude-3/.test(m)) return 4_096;
|
||
return 8_192; // 未知模型回退到 8k —— 之前 4096 经常截断长 diff
|
||
}
|
||
|
||
/**
|
||
* 抽象的 HTTP 调用 + 超时 + 取消 + 状态码错误处理。
|
||
* 不解析业务响应（OpenAI / Anthropic 各自的 JSON 结构在调用方处理）。
|
||
*
|
||
* @param {{
|
||
* requestId: string,
|
||
* url: string,
|
||
* headers: Record<string, string>,
|
||
* body: object,
|
||
* timeoutMs: number,
|
||
* }} args
|
||
* @returns {Promise<{ ok: true, json: any } | { ok: false, error: string, message: string }>}
|
||
*/
|
||
async function postJson({ requestId, url, headers, body, timeoutMs }) {
|
||
const controller = new AbortController();
|
||
pending.set(requestId, controller);
|
||
|
||
let timedOut = false;
|
||
const timer = setTimeout(() => {
|
||
timedOut = true;
|
||
controller.abort();
|
||
}, timeoutMs);
|
||
timers.set(requestId, timer);
|
||
|
||
// audit fix：所有 exit 路径必须清理两个 Map，否则长时间使用会泄漏
|
||
// 内存（之前修复 cancelAll 只清理了 Map 没在 postJson 内清理 entry，
|
||
// 现在统一走 helper 确保不遗漏）。
|
||
//
|
||
// 关键：cleanup 只清理「自己的」controller / timer，不能按 requestId 无脑
|
||
// delete。如果 renderer 在我们 await fetchFn 的间隙用同一个 requestId 发起
|
||
// 了新请求（pending.has → cancel → 新 postJson），新请求会重新
|
||
// pending.set(requestId, newController)。随后旧 cleanup 在 microtask 阶段
|
||
// 触发 pending.delete(requestId)，会把新请求的 controller 从 Map 里抹掉，
|
||
// 导致新请求无法单独 cancel。比对 identity 再 delete 即可解决。
|
||
function cleanup() {
|
||
clearTimeout(timer);
|
||
if (pending.get(requestId) === controller) pending.delete(requestId);
|
||
if (timers.get(requestId) === timer) timers.delete(requestId);
|
||
}
|
||
|
||
let res;
|
||
try {
|
||
// audit fix (Round 13 / Sec-H3)：redirect: 'manual' 阻止 undici 跟随 3xx
|
||
// 重定向到不同 origin 时复传自定义头。fetch 规范只会在 CORS 非通配头
|
||
// 集合里自动剥 `Authorization`，但 Anthropic 用的是 `x-api-key`（自定义头），
|
||
// 不在脱敏名单里 —— 用户配置的中转 / 第三方网关一旦答 302 到攻击者域，
|
||
// `x-api-key: sk-ant-...` 和当前笔记全文都会被转发出去。
|
||
//
|
||
// 用 manual 后拿到的是 opaqueredirect 类型的 Response，status 0、body 不可读；
|
||
// 我们在下文按 status === 0 / type === 'opaqueredirect' 显式报错给用户。
|
||
// 不支持 redirect 的真 endpoint 不会触发这条分支（2xx/4xx/5xx 都不是 3xx）。
|
||
res = await fetchFn(url, {
|
||
method: 'POST',
|
||
headers,
|
||
body: JSON.stringify(body),
|
||
signal: controller.signal,
|
||
redirect: 'manual',
|
||
});
|
||
} catch (e) {
|
||
cleanup();
|
||
if (controller.signal.aborted) {
|
||
if (timedOut) {
|
||
return { ok: false, error: ERR_TIMEOUT, message: 'AI 请求超时，请缩小文档、简化要求或重试' };
|
||
}
|
||
return { ok: false, error: ERR_CANCELLED, message: '已取消 AI 请求' };
|
||
}
|
||
const msg = e instanceof Error ? e.message : String(e);
|
||
if (/abort/i.test(msg)) {
|
||
return { ok: false, error: timedOut ? ERR_TIMEOUT : ERR_CANCELLED, message: timedOut ? 'AI 请求超时，请缩小文档、简化要求或重试' : '已取消 AI 请求' };
|
||
}
|
||
// M1 fix (audit)：网络错误信息里也可能携带 api key（fetch 库 / DNS 错误里偶尔
|
||
// 会回显 URL 或 header），统一走 sanitizeDetail 防止泄露到 toast / 日志
|
||
return { ok: false, error: ERR_PROVIDER, message: `网络错误：${sanitizeDetail(msg)}` };
|
||
}
|
||
// 不再此处 cleanup：fetch 已 resolve 但 body 仍在流式读取，取消窗口内
|
||
// （响应头到达 → body 读完前）cancel 需要 pending 中的 controller 才能 abort。
|
||
// 清理统一收口到下方 try/finally（覆盖所有 early-return / 错误路径）。
|
||
try {
|
||
// audit fix (Round 13 / Sec-H3)：3xx 重定向在 manual 模式下表现为 status=0
|
||
// 且 type='opaqueredirect'。明示用户配置错了 Base URL，不要走"读 body 取错误信息"
|
||
// 分支（那里会卡死读 body 或者报错信息误导成"格式错误"）。
|
||
if (res.status === 0 || res.type === 'opaqueredirect') {
|
||
return {
|
||
ok: false,
|
||
error: ERR_PROVIDER,
|
||
message: 'Base URL 发生了重定向，请直接填写最终地址（出于 API Key 安全考虑，Notes 不会自动跟随重定向）',
|
||
};
|
||
}
|
||
|
||
if (!res.ok) {
|
||
const status = res.status;
|
||
let detail = '';
|
||
let errBody = null;
|
||
// P2-3 fix (audit)：用 readBodyWithLimit 限制响应体大小，防止 OOM
|
||
// 审计修复 (Round 11 deep-fix P1-2)：在 readBodyWithLimit 抛 AbortError 时
|
||
// （用户取消）不要静默走到下面 → bodyRead.ok === false 时仍正常报错 OK；
|
||
// 但 reader 自身抛错会冒到 catch。检查 controller.signal.aborted 走「已取消」。
|
||
let bodyRead;
|
||
try {
|
||
bodyRead = await readBodyWithLimit(res);
|
||
} catch (e) {
|
||
if (controller && controller.signal && controller.signal.aborted) {
|
||
return { ok: false, error: ERR_CANCELLED, message: '已取消 AI 请求' };
|
||
}
|
||
throw e;
|
||
}
|
||
if (!bodyRead.ok) {
|
||
// Q6 fix (audit)：url 写入日志前 sanitizeUrl，去掉 query / fragment / path secret
|
||
logFn('ai:http_error', { url: sanitizeUrl(url), status, detail: bodyRead.message });
|
||
return { ok: false, error: ERR_FORMAT, message: bodyRead.message };
|
||
}
|
||
const text = bodyRead.text;
|
||
if (text) {
|
||
// 尝试解析为 JSON 取 error.message；不成功则把原文截断用作 detail
|
||
try {
|
||
const parsed = JSON.parse(text);
|
||
errBody = parsed;
|
||
if (parsed && parsed.error && typeof parsed.error.message === 'string') {
|
||
detail = parsed.error.message;
|
||
}
|
||
} catch {
|
||
// ignore
|
||
}
|
||
if (!detail) detail = text.length > 200 ? `${text.slice(0, 200)}…` : text;
|
||
}
|
||
// P2-2 fix (audit)：过滤 detail 里的 api key / 敏感 token 后再 log + 回显
|
||
detail = sanitizeDetail(detail);
|
||
// Q6 fix (audit)：url 写入日志前 sanitizeUrl，去掉 query / fragment / path secret
|
||
logFn('ai:http_error', { url: sanitizeUrl(url), status, detail });
|
||
if (status === 401 || status === 403) {
|
||
return { ok: false, error: ERR_PROVIDER, message: 'API Key 无效或没有权限' };
|
||
}
|
||
if (status === 404) {
|
||
return { ok: false, error: ERR_PROVIDER, message: 'Base URL 或模型不存在' };
|
||
}
|
||
if (status === 408 || status === 504) {
|
||
return { ok: false, error: ERR_TIMEOUT, message: 'AI 请求超时，请缩小文档、简化要求或重试' };
|
||
}
|
||
if (status === 429) {
|
||
return { ok: false, error: ERR_PROVIDER, message: '请求过于频繁，请稍后重试' };
|
||
}
|
||
if (status === 400 && errBody && errBody.error && errBody.error.type === 'invalid_request_error') {
|
||
// audit fix (Round 8 A-1)：这里过去用的是 `errBody.error.message` 原文，
|
||
// 绕过了上面 line 525 的 sanitizeDetail —— 而 detail 正是同一个字符串
|
||
// 脱敏后的版本。自部署网关（Azure / LiteLLM / 各类中转）在
|
||
// invalid_request_error.message 里 echo 请求头或请求体的情况很常见，
|
||
// 一旦回吐 `Bearer sk-...` 就会原样进 toast。改用已脱敏的 detail。
|
||
return { ok: false, error: ERR_PROVIDER, message: `请求参数错误：${detail || '服务端未提供详情'}` };
|
||
}
|
||
if (status >= 500) {
|
||
// audit fix (M3 regression)：500 也带 sanitized detail，
|
||
// 让上游服务器把真实错误（"invalid token: sk-xxx"）回吐时，
|
||
// 用户能从 toast 看到「凭据有问题」而不是一句空泛的"服务不可用"。
|
||
// detail 已经走过 sanitizeDetail，key 类 token 已经被 [API_KEY] 替换。
|
||
return {
|
||
ok: false,
|
||
error: ERR_PROVIDER,
|
||
message: `AI 服务暂时不可用（HTTP ${status}）${detail ? '：' + detail : ''}`,
|
||
};
|
||
}
|
||
return { ok: false, error: ERR_PROVIDER, message: `AI 请求失败（HTTP ${status}）${detail ? '：' + detail : ''}` };
|
||
}
|
||
|
||
/** @type {any} */
|
||
let json;
|
||
try {
|
||
// P2-3 fix (audit)：成功路径也走大小限制（恶意 / 错误配置的服务端可能
|
||
// 对 200 也返回大 body）。用 text + JSON.parse 替代 res.json()。
|
||
const bodyRead = await readBodyWithLimit(res);
|
||
if (!bodyRead.ok) return { ok: false, error: ERR_FORMAT, message: bodyRead.message };
|
||
json = JSON.parse(bodyRead.text);
|
||
} catch (e) {
|
||
// 审计修复 (Round 11 deep-fix P1-2)：用户取消时 readBodyWithLimit 内部
|
||
// reader.cancel() 抛 AbortError，外层 catch 之前把它误判成 "不是合法 JSON"
|
||
// → UI 看到误导的格式错误。先检查 controller.signal.aborted 走「已取消」分支。
|
||
if (controller && controller.signal && controller.signal.aborted) {
|
||
return { ok: false, error: ERR_CANCELLED, message: '已取消 AI 请求' };
|
||
}
|
||
const msg = e instanceof Error ? e.message : String(e);
|
||
if (/abort/i.test(msg)) {
|
||
return { ok: false, error: ERR_CANCELLED, message: '已取消 AI 请求' };
|
||
}
|
||
return { ok: false, error: ERR_FORMAT, message: 'AI 返回的不是合法 JSON' };
|
||
}
|
||
return { ok: true, json };
|
||
} finally {
|
||
cleanup();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 把模型原始文本回复归一化成 { content, responseFormat }：
|
||
* - 解析成 { content: string } → responseFormat = 'json'（用于文档修改 diff）
|
||
* - 其它情况 → responseFormat = 'raw'（普通对话回复）
|
||
*/
|
||
function normalizeAssistantText(message, originalContent) {
|
||
const parsed = tryParseJson(message);
|
||
if (parsed && typeof parsed === 'object' && typeof parsed.content === 'string') {
|
||
const next = parsed.content;
|
||
if (next === originalContent) {
|
||
return { content: '当前文档无需修改。', responseFormat: 'raw' };
|
||
}
|
||
return { content: next, responseFormat: 'json' };
|
||
}
|
||
// audit fix (shared-M13)：如果 JSON 解析成功但 content 不是字符串（典型
|
||
// 是 [] 数组 / 对象 / null / 数字），不要按「截断」处理 —— 模型是按规矩
|
||
// 返回 JSON 对象的，只是 content 的形状不是我们约定的字符串。把 message
|
||
// 整体当 raw 回退返回给用户，至少他们能看到模型实际输出了什么，而不是
|
||
// 看到一个误导的「输出不完整，请重试」提示。
|
||
if (parsed && typeof parsed === 'object' && 'content' in parsed) {
|
||
return { content: message, responseFormat: 'raw' };
|
||
}
|
||
const rawReply = extractRawReply(parsed);
|
||
if (rawReply) return { content: rawReply, responseFormat: 'raw' };
|
||
if (looksLikeEditJson(message)) {
|
||
return null; // JSON 看起来想返回 {content:...} 但解析失败 —— 截断
|
||
}
|
||
return { content: message, responseFormat: 'raw' };
|
||
}
|
||
|
||
/**
|
||
* OpenAI 兼容分支：POST {baseURL}/chat/completions。
|
||
*/
|
||
async function runOpenAIEdit({ prompt, content, filename, requestId, timeoutMs }) {
|
||
const config = (typeof getConfig === 'function' ? getConfig() : {}) || {};
|
||
const baseURL = String(config.aiBaseUrl || '').trim();
|
||
// R3 P0-1：解密 aiApiKey 包络。secretStore.decrypt 对明文 / 空 / 损坏都有兜底。
|
||
const apiKey = secretStore.decrypt(config.aiApiKey).trim();
|
||
const model = String(config.aiModel || '').trim();
|
||
const systemPrompt = String(config.aiSystemPrompt || '').trim() || CURRENT_FILE_EDIT_SYSTEM_PROMPT;
|
||
|
||
if (!baseURL || !apiKey || !model) {
|
||
return { ok: false, error: ERR_NOT_CONFIGURED, message: '请先在设置中填写 AI 的 Base URL、API Key 和模型名' };
|
||
}
|
||
// M1 (audit)：拒绝 javascript: / data: / file: 等伪协议，避免 fetch TypeError 报成"网络错误"
|
||
const urlCheck = validateBaseUrl(baseURL);
|
||
if (!urlCheck.ok) {
|
||
return { ok: false, error: ERR_NOT_CONFIGURED, message: urlCheck.reason };
|
||
}
|
||
// audit fix (Round 8 A-2) + Round 13 抽 helper：明文 HTTP + 非loopback + 已配置 API Key → 拒绝。
|
||
// 本地代理（Ollama / LM Studio / vllm）走 http://localhost / 127.0.0.1 / ::1
|
||
// 且不需要 Key —— apiKey 留空就过；这里有 apiKey 意味着第三方 API，必须 HTTPS。
|
||
// 静默放行会让 Key 在网线上裸奔到攻击者嗅探点，错误必须显式。
|
||
// localhost/127.0.0.1/::1 仍然放过：本地抓包门槛远高于公网，本地代理是合法场景。
|
||
const insecureReject = rejectInsecureKeyTransport(urlCheck.value, apiKey);
|
||
if (insecureReject) return insecureReject;
|
||
|
||
const url = joinUrl(baseURL, 'chat/completions');
|
||
// H1+H2+H5 (audit)：按模型名路由 token 上限，避免 65536 超过多数模型上限被拒；
|
||
// 同时按模型名决定发 max_tokens 还是 max_completion_tokens（gpt-5 / o-series 只接受后者）。
|
||
// o-series / gpt-5 也不接受自定义 temperature（o1 强制为 1，发 0.2 会 400）。
|
||
const { capTokens, tokenField, includeTemperature } = pickOpenAITokenConfig(model);
|
||
/** @type {Record<string, any>} */
|
||
const body = {
|
||
model,
|
||
[tokenField]: capTokens,
|
||
messages: [
|
||
{ role: 'system', content: systemPrompt },
|
||
{
|
||
role: 'user',
|
||
content: JSON.stringify({ filename, currentMarkdown: content, userPrompt: prompt }),
|
||
},
|
||
],
|
||
stream: false,
|
||
};
|
||
if (includeTemperature) body.temperature = 0.2;
|
||
|
||
logFn('ai:request', { provider: 'openai', url: sanitizeUrl(url), model, filename, promptLen: prompt.length, contentLen: content.length });
|
||
|
||
const result = await postJson({ requestId, url, headers: {
|
||
'Content-Type': 'application/json',
|
||
Authorization: `Bearer ${apiKey}`,
|
||
}, body, timeoutMs });
|
||
if (!result.ok) return result;
|
||
|
||
const json = result.json;
|
||
const choice = json && Array.isArray(json.choices) ? json.choices[0] : null;
|
||
if (!choice) {
|
||
return { ok: false, error: ERR_FORMAT, message: 'AI 返回了空结果' };
|
||
}
|
||
if (choice.finish_reason === 'length') {
|
||
return { ok: false, error: ERR_FORMAT, message: TRUNCATED_MESSAGE };
|
||
}
|
||
if (choice.finish_reason === 'content_filter') {
|
||
return { ok: false, error: ERR_FORMAT, message: 'AI 返回被服务方过滤，请调整要求后重试' };
|
||
}
|
||
const message = choice.message && typeof choice.message.content === 'string' ? choice.message.content : '';
|
||
if (!message) {
|
||
return { ok: false, error: ERR_FORMAT, message: 'AI 返回了空内容' };
|
||
}
|
||
|
||
const normalized = normalizeAssistantText(message, content);
|
||
if (normalized === null) {
|
||
return { ok: false, error: ERR_FORMAT, message: TRUNCATED_MESSAGE };
|
||
}
|
||
return { ok: true, id: requestId, content: normalized.content, responseFormat: normalized.responseFormat };
|
||
}
|
||
|
||
/**
|
||
* Anthropic 分支：POST {baseURL}/v1/messages。
|
||
* system 单独字段（不在 messages 里）；messages 只有 user/assistant 两轮对话。
|
||
*/
|
||
async function runAnthropicEdit({ prompt, content, filename, requestId, timeoutMs }) {
|
||
const config = (typeof getConfig === 'function' ? getConfig() : {}) || {};
|
||
const baseURL = String(config.aiBaseUrl || '').trim();
|
||
// R3 P0-1：解密 aiApiKey 包络。secretStore.decrypt 对明文 / 空 / 损坏都有兜底。
|
||
const apiKey = secretStore.decrypt(config.aiApiKey).trim();
|
||
const model = String(config.aiModel || '').trim();
|
||
const systemPrompt = String(config.aiSystemPrompt || '').trim() || CURRENT_FILE_EDIT_SYSTEM_PROMPT;
|
||
|
||
if (!baseURL || !apiKey || !model) {
|
||
return { ok: false, error: ERR_NOT_CONFIGURED, message: '请先在设置中填写 AI 的 Base URL、API Key 和模型名' };
|
||
}
|
||
// M1 (audit)：同样校验协议前缀，与 OpenAI 分支一致
|
||
const urlCheck = validateBaseUrl(baseURL);
|
||
if (!urlCheck.ok) {
|
||
return { ok: false, error: ERR_NOT_CONFIGURED, message: urlCheck.reason };
|
||
}
|
||
// audit fix (Round 8 A-2) + Round 13 抽 helper：与 OpenAI 分支共用同样防御，
|
||
// 本地代理不需要 Key，留空即可。
|
||
const insecureReject = rejectInsecureKeyTransport(urlCheck.value, apiKey);
|
||
if (insecureReject) return insecureReject;
|
||
|
||
const url = joinUrl(baseURL, 'v1/messages');
|
||
// H1 (audit)：Anthropic 各模型 max_tokens 上限不同，超额会 400
|
||
const capTokens = pickAnthropicTokenConfig(model);
|
||
const body = {
|
||
model,
|
||
max_tokens: capTokens,
|
||
system: systemPrompt,
|
||
messages: [
|
||
{
|
||
role: 'user',
|
||
content: JSON.stringify({ filename, currentMarkdown: content, userPrompt: prompt }),
|
||
},
|
||
],
|
||
};
|
||
|
||
logFn('ai:request', { provider: 'anthropic', url: sanitizeUrl(url), model, filename, promptLen: prompt.length, contentLen: content.length });
|
||
|
||
const result = await postJson({ requestId, url, headers: {
|
||
'Content-Type': 'application/json',
|
||
'x-api-key': apiKey,
|
||
'anthropic-version': ANTHROPIC_API_VERSION,
|
||
}, body, timeoutMs });
|
||
if (!result.ok) return result;
|
||
|
||
const json = result.json;
|
||
// 拼接所有 type==='text' 的 content 块；忽略 tool_use / tool_result 等。
|
||
if (!json || !Array.isArray(json.content)) {
|
||
return { ok: false, error: ERR_FORMAT, message: 'AI 返回了空结果' };
|
||
}
|
||
if (json.stop_reason === 'max_tokens') {
|
||
return { ok: false, error: ERR_FORMAT, message: TRUNCATED_MESSAGE };
|
||
}
|
||
/** @type {string} */
|
||
let message = '';
|
||
let hasNonTextBlock = false;
|
||
for (const block of json.content) {
|
||
if (block && block.type === 'text' && typeof block.text === 'string') {
|
||
// Round 13 fix (H7)：Anthropic 不保证 text 块之间有分隔符。
|
||
// [{text:'A.'}, {text:'B begin.'}] 直接拼接得 'A.B begin.'，
|
||
// Markdown 渲染会把 `A.B` 误识为 list / 句点边界。块与块之间补
|
||
// 双换行（Markdown 段落分隔），让多块拼接后渲染保持原意。
|
||
if (message && !message.endsWith('\n')) message += '\n\n';
|
||
message += block.text;
|
||
} else if (block && block.type !== 'text') {
|
||
// audit fix (shared-M11)：tool_use / tool_result / image 等非文本块
|
||
// 当前版本不消费，但若整条 response 只有这些块就给一个明确的中文
|
||
// 提示，而不是误导用户「AI 返回了空内容」（实际是格式我们暂时不支持）。
|
||
hasNonTextBlock = true;
|
||
}
|
||
}
|
||
if (!message) {
|
||
// audit fix (shared-M11)：把「模型只回了 tool_use / image 但没有正文」
|
||
// 与「模型真的没回东西」区分开 —— 后者才报「空内容」。
|
||
if (hasNonTextBlock) {
|
||
return {
|
||
ok: false,
|
||
error: ERR_FORMAT,
|
||
message: 'AI 返回了无法识别的内容（仅含 tool_use / 图像块，无文本回复）',
|
||
};
|
||
}
|
||
return { ok: false, error: ERR_FORMAT, message: 'AI 返回了空内容' };
|
||
}
|
||
|
||
const normalized = normalizeAssistantText(message, content);
|
||
if (normalized === null) {
|
||
return { ok: false, error: ERR_FORMAT, message: TRUNCATED_MESSAGE };
|
||
}
|
||
return { ok: true, id: requestId, content: normalized.content, responseFormat: normalized.responseFormat };
|
||
}
|
||
|
||
// Round 13 fix (H3)：从共享 AI_ERROR 引用错误码字面值。原先 4 处裸字面量
|
||
// ('INVALID_PROMPT' / 'INVALID_CONTENT' / 'CONTENT_TOO_LARGE' / 'PROMPT_TOO_LARGE')
|
||
// 绕开 AI_ERROR，renderer 端 ai-controller 走通用 toast 而不是本地化提示。
|
||
const ERR_INVALID_PROMPT = AI_ERROR.INVALID_PROMPT;
|
||
const ERR_INVALID_CONTENT = AI_ERROR.INVALID_CONTENT;
|
||
const ERR_CONTENT_TOO_LARGE = AI_ERROR.CONTENT_TOO_LARGE;
|
||
const ERR_PROMPT_TOO_LARGE = AI_ERROR.PROMPT_TOO_LARGE;
|
||
|
||
/**
|
||
* 执行一次 AI 修改请求。
|
||
* @param {{ prompt:string, content:string, filename:string, requestId:string }} input
|
||
* @returns {Promise<{ ok:true, id:string, content:string, responseFormat:'json'|'raw' } | { ok:false, error:string, message:string }>}
|
||
*/
|
||
async function runEdit({ prompt, content, filename, requestId }) {
|
||
if (typeof prompt !== 'string' || !prompt.trim()) {
|
||
return { ok: false, error: ERR_INVALID_PROMPT, message: '修改要求不能为空' };
|
||
}
|
||
if (typeof content !== 'string') {
|
||
return { ok: false, error: ERR_INVALID_CONTENT, message: '当前文件内容无效' };
|
||
}
|
||
// 字节上限用 UTF-8 编码长度近似（中文/emoji 一个字符多字节，会略高估）
|
||
if (Buffer.byteLength(content, 'utf8') > MAX_CONTENT_BYTES) {
|
||
return {
|
||
ok: false,
|
||
error: ERR_CONTENT_TOO_LARGE,
|
||
message: `文档过大（超过 ${(MAX_CONTENT_BYTES / 1024 / 1024).toFixed(1)} MB），请拆分后再让 AI 修改`,
|
||
};
|
||
}
|
||
if (Buffer.byteLength(prompt, 'utf8') > MAX_PROMPT_BYTES) {
|
||
return {
|
||
ok: false,
|
||
error: ERR_PROMPT_TOO_LARGE,
|
||
message: `提示词过长（超过 ${MAX_PROMPT_BYTES / 1024} KB），请简化要求`,
|
||
};
|
||
}
|
||
if (typeof filename !== 'string') {
|
||
filename = '';
|
||
}
|
||
if (typeof requestId !== 'string' || !requestId) {
|
||
// Round 13 fix (M8)：用 crypto.randomUUID 代替 Math.random；后者在
|
||
// 高并发（用户连点）下理论碰撞，会让 cancel 误杀新请求。
|
||
requestId = `ai-${Date.now()}-${nodeCrypto.randomUUID()}`;
|
||
}
|
||
|
||
const config = (typeof getConfig === 'function' ? getConfig() : {}) || {};
|
||
const provider = String(config.aiProvider || 'openai').trim().toLowerCase();
|
||
const timeoutMs = DEFAULT_TIMEOUT_MS;
|
||
|
||
// audit fix (C4)：原 `if (pending.has(requestId)) cancel(requestId)` 是死代码 —
|
||
// pending 是 postJson 内部填的，postJson 在 runEdit 异步返回之后才执行，
|
||
// runEdit 入口检查 pending 时它一定是空的，双击防护其实由 renderer 端
|
||
// ai-chat-panel 的 _submitting 守门。这里改成真正的 inFlightRequestIds：
|
||
// 进入 runEdit 即登记（早于 postJson），finally 清理，覆盖整个请求生命周期。
|
||
if (inFlightRequestIds.has(requestId)) {
|
||
cancel(requestId);
|
||
}
|
||
inFlightRequestIds.add(requestId);
|
||
// audit fix (P1-5)：拍下 cancelAll epoch 快照。本 runEdit 期间若发生
|
||
// cancelAll（用户点取消、will-quit 触发），await 之后 isCurrent → false
|
||
// → 返 ERR_CANCELLED 不应用任何副作用。snapshot 必须在 inFlightRequestIds
|
||
// 之后但 await 之前 —— 在 inFlightRequestIds.add 之后确保「新请求已
|
||
// 登记」语义在 cancelAll 之前；invalidate 会同时清 Set 的 entry，但本请求
|
||
// 已登记的「我自己负责清除」语义不变（finally 仍会 delete，但 Set 已空，
|
||
// delete 一次 noop）。
|
||
const myEpoch = cleanupEpoch.snapshot();
|
||
|
||
// 注：token 上限不再用入参 maxTokens（已被 pick*TokenConfig 按模型路由取代）
|
||
const baseArgs = { prompt, content, filename, requestId, timeoutMs };
|
||
try {
|
||
let result;
|
||
if (provider === 'anthropic') {
|
||
result = await runAnthropicEdit(baseArgs);
|
||
} else if (provider === 'openai') {
|
||
result = await runOpenAIEdit(baseArgs);
|
||
} else {
|
||
// audit fix (2.5)：未知 provider 不再静默按 OpenAI 走 —— 配置错了会让用户困惑。
|
||
// schema enum 已防，但 IPC 直调 / 老 settings 文件可能漏过来，这里明确报错。
|
||
return {
|
||
ok: false,
|
||
error: ERR_NOT_CONFIGURED,
|
||
message: `未知 AI 服务提供方：${provider}（请在设置里选 OpenAI 兼容或 Anthropic 兼容）`,
|
||
};
|
||
}
|
||
// audit fix (P1-5)：await 之后，cancelAll 已 invalidate epoch → 本次
|
||
// 任务期间发生过 cancel，请求结果不再应用（即使 provider 返了 200，
|
||
// 也可能是 cancelAll 触发 abort 之前最后一段响应；语义上「用户已取消」
|
||
// 优先于「网络层成功」）。同时这一步拦截「cancelAll 三步非原子期间
|
||
// 新请求被误 abort 之后」场景 —— 新 runEdit 拿不到 response，但 abort
|
||
// 信号让它提前抛 AbortError；这里统一以 ERR_CANCELLED 兜底。
|
||
if (!cleanupEpoch.isCurrent(myEpoch)) {
|
||
return {
|
||
ok: false,
|
||
error: ERR_CANCELLED,
|
||
message: '请求已被取消',
|
||
};
|
||
}
|
||
return result;
|
||
} finally {
|
||
// audit fix (C4)：无论成功 / 失败 / 抛错都清登记，下次同 requestId
|
||
// 再来能正常进入；防 Set 缓慢增长。
|
||
inFlightRequestIds.delete(requestId);
|
||
}
|
||
}
|
||
|
||
return {
|
||
runEdit,
|
||
cancel,
|
||
cancelAll,
|
||
};
|
||
}
|
||
|
||
module.exports = {
|
||
createAiProxy,
|
||
// 共享错误码表 —— preload 经 contextBridge 把同一份 AI_ERROR 暴露到
|
||
// window.api.aiErrors，renderer 直接 window.api?.aiErrors?.AI_ERROR。
|
||
// main/ai.js 内部仍用 ERR_* 命名别名（line 59-63），纯粹是阅读性，无外部
|
||
// 调用方 —— 别名不出 module.exports，避免「两个相同字面值漂移」风险。
|
||
AI_ERROR,
|
||
};
|