pi-information-protecter 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog / 更新日志
 
+## 0.6.0 — Shape-preserving replacements and single-language messages / 同形替换与单语言消息
+
+### Changed / 变更
+
+- **Breaking:** replace matches with random values of the same shape instead of `__PIP_<hex>__` tokens, preserving length, case pattern, digits and punctuation positions so tool schemas, URLs, emails and embedded JSON stay valid.
+  **破坏性变更：**命中内容改为同形随机值而非占位符，保留长度、大小写形态、数字和标点位置，使工具结构、URL、邮箱和内嵌 JSON 仍然有效。
+- Keep numeric JSON values as numbers with the same digit count and safe-integer range, fixing provider errors such as `'9007199254740991' is not of type 'number'`.
+  数值型 JSON 字段保持数字类型、位数和安全整数范围，修复类似 `'9007199254740991' is not of type 'number'` 的提供商错误。
+- Replace characters within their own writing system, covering Latin with diacritics, Vietnamese, Greek, Cyrillic, Hebrew, Arabic, Thai, Hiragana, Katakana, Hangul and CJK; punctuation, whitespace, emoji and unknown code points stay unchanged.
+  在各自文字体系内替换字符，覆盖带重音拉丁字母、越南语、希腊语、西里尔语、希伯来语、阿拉伯语、泰语、平假名、片假名、谚文及汉字；标点、空白、表情和未知码位保持不变。
+- **Breaking:** render every notification, prompt and diagnostic in one language selected from `PI_PROTECTER_LANG`, `LC_ALL`, `LC_MESSAGES`, `LANG`, `LANGUAGE` or the runtime locale, instead of pairing English and Chinese in the same string; codes, stages and numeric details stay language-neutral.
+  **破坏性变更：**通知、提示和诊断改为单一语言，按上述环境变量或运行时区域选择，不再在同一字符串中并列中英文；错误码、阶段和数值细节保持语言无关。
+- Format counts with `Intl.PluralRules` and `Intl.NumberFormat` so quantities read naturally in each language.
+  使用 `Intl.PluralRules` 和 `Intl.NumberFormat` 格式化数量，使各语言表达自然。
+
+### Added / 新增
+
+- Add `SCAN_NUMBER_UNSAFE` and `SCAN_UNIQUE_FAILED` diagnostics so numbers that cannot round-trip and matches with no unique replacement fail closed instead of corrupting a request.
+  新增两个诊断码，使无法精确往返的数值和无唯一替换值的匹配拒绝放行，而不破坏请求。
+- Add `RESTORE_COMPLEXITY` and `RESTORE_KEY_COLLISION` diagnostics for oversized or ambiguous restoration input.
+  为过深或歧义的还原输入新增两个诊断码。
+- Add regressions for numeric type preservation, per-script shapes, punctuation and emoji layout, collision avoidance, fail-closed paths and locale selection.
+  新增回归，覆盖数值类型保持、各文字体系同形、标点与表情布局、冲突避免、失败拒绝路径及语言选择。
+
+### Security / 安全
+
+- Document that shape-preserving values leak length, character class and punctuation structure, look like plausible data, and may be restored when a model independently emits the same short string; prefer long, distinctive targets.
+  文档说明同形值会泄露长度、字符类别和标点结构，看似真实数据，且模型自行输出相同短字符串时可能被还原，应优先使用较长且有辨识度的目标。
+
 ## 0.5.0 — Actionable block diagnostics / 可定位的拦截诊断
 
 - Replace the single generic block message with a stable code, failing stage, reason and suggested action across initialization, configuration, migration, request, scan, worker and audit paths.

package/README.md

@@ -82,6 +82,31 @@ Targets are literal text, not replacement templates: `$1` and `$&` are not expan
 
 For reversible protection, duplicate targets across different rules, substring-overlapping targets, targets containing configured sensitive values, reserved `__PIP_` names and conflicting definitions are rejected. A fixed regex can represent only one distinct matched original per instance; a second distinct original rejects the request. Partially overlapping matches involving fixed rules also reject rather than silently choose a rule or expose a suffix. Pure random-rule overlaps still merge. Migration preserves targets and refuses conflicting merges without deleting originals. Reload after editing; older plugin versions do not support this field.
 
+### Shape-preserving replacements
+
+Since 0.6.0 a matched value is replaced by a random value of the **same shape** instead of an opaque token, so requests stay schema-valid:
+
+| Original | Replacement | Preserved |
+| --- | --- | --- |
+| `9007199254740991` (number) | `2844008842109708` (number) | JSON type, digit count, safe-integer range |
+| `13800138000` | `06864831332` | length, digits only |
+| `Alex.Morgan@Example.COM` | `Ufqz.Vwtudb@Rjdnpxe.HGZ` | length, case pattern, punctuation positions |
+| `张三` | `丅欕` | CJK script, character count |
+| `Nguyễn Văn Tèo` | `Ufefṉg Zżt Sàb` | Latin with diacritics, word boundaries |
+| `ひらがな` | `ゅせはっ` | Hiragana |
+
+This fixes provider errors such as `'9007199254740991' is not of type 'number'`, which happened when a numeric field was replaced by a token string. Numeric JSON values stay numbers, keep their digit count and remain safe integers. If a partial match cannot round-trip as a number, the request is blocked with `SCAN_NUMBER_UNSAFE` instead of sending an invalid type.
+
+Letters and digits are replaced inside their own writing system: ASCII, Latin-1, Latin Extended-A, Latin Extended Additional (including Vietnamese), Greek, Cyrillic, Hebrew, Arabic, Thai, Hiragana, Katakana, Hangul and CJK. Punctuation, whitespace, emoji, symbols and code points outside these ranges are kept unchanged, which is what keeps URLs, emails and embedded JSON parseable.
+
+**This is a deliberate trade-off.** An opaque token revealed only that a redaction happened; a shape-preserving value also reveals length, character classes and punctuation structure, and it looks like plausible real data to the model. Text in unsupported scripts is preserved as-is, so a rule matching such text may leave part of it visible.
+
+Replacements are checked so restoration stays exact: a candidate is rejected if it equals the original, is already mapped, or already appears anywhere in the same request. When no unique candidate can be produced, typically for very short matches, the request is blocked with `SCAN_UNIQUE_FAILED`. Because a shaped value is indistinguishable from ordinary content, a model that independently emits the same short string will have it restored to the original, so prefer rules that match longer, distinctive values.
+
+### Message language
+
+All notifications, prompts and diagnostics render in a single language, chosen from the environment: `PI_PROTECTER_LANG`, then `LC_ALL`, `LC_MESSAGES`, `LANG`, `LANGUAGE`, then the runtime locale. `zh*` selects Simplified Chinese; anything else falls back to English. Set `PI_PROTECTER_LANG=en` or `PI_PROTECTER_LANG=zh` to override. Error codes, stages and numeric details stay language-neutral so they can be searched and reported.
+
 ### Multi-turn consistency and prompt caching
 
 Random placeholders are generated once per exact original and reused within the same extension instance, including after local response restoration. Starting another scan worker does not reset the mapping. This supports stable prompt prefixes but does not guarantee provider KV-cache hits; model, tools, message ordering, cache lifetime and routing also matter. `/reload`, process restart and session-instance replacement clear mappings. Different processes do not share mappings, and audit timestamps/request IDs are never included in the model payload.
@@ -103,16 +128,16 @@ Use `/protecter logs clear` to empty only the current machine's audit log. Local
 When a request is blocked, the notification names the failing stage, a stable code and a suggested action instead of one generic message:
 
 ```text
-SPI Protecter blocked this request / 已阻止该请求
+SPI Protecter blocked this request
 code=CONFIG_EMPTY_MATCH stage=configuration rule=1
-Reason / 原因: Regex matches an empty string / 正则匹配空字符串
-Action / 处理: Require a non-empty match in the numbered rule / 修改指定规则，要求非空匹配
-Details / 详情: /protecter status
+Reason: Regex matches an empty string
+Action: Require a non-empty match in the numbered rule
+Details: /protecter status
 ```
 
 Stages are `initialization`, `configuration`, `migration`, `request`, `scan`, `worker`, `audit` and `internal`. Coordinates appear only when known: `rule` and `otherRule` are 1-based indexes into `sensitiveWords`, `node` counts scanned payload nodes, `bytes`/`limit`/`timeoutMs` report the exceeded limit, and `errno` is the OS error code.
 
-Common codes include `CONFIG_JSON`, `CONFIG_SCHEMA`, `CONFIG_REGEX`, `CONFIG_TARGET`, `CONFIG_CONFLICT`, `CONFIG_EMPTY_MATCH`, `CONFIG_SENSITIVE_TARGET`, `CONFIG_ALIAS_CONFLICT`, `CONFIG_UNSAFE`, `MIGRATION_LOCKED`, `MIGRATION_CHANGED`, `PAYLOAD_JSON`, `PAYLOAD_SIZE`, `SCAN_TIMEOUT`, `SCAN_MATCH_LIMIT`, `SCAN_COMPLEXITY`, `SCAN_ATTACHMENT`, `SCAN_JSON_REWRITE`, `FIXED_OVERLAP`, `FIXED_ALIAS_REUSED`, `AUDIT_FULL`, `AUDIT_PARTIAL`, `AUDIT_LOCKED`, `AUDIT_UNSAFE` and `WORKER_FAILED`.
+Common codes include `CONFIG_JSON`, `CONFIG_SCHEMA`, `CONFIG_REGEX`, `CONFIG_TARGET`, `CONFIG_CONFLICT`, `CONFIG_EMPTY_MATCH`, `CONFIG_SENSITIVE_TARGET`, `CONFIG_ALIAS_CONFLICT`, `CONFIG_UNSAFE`, `MIGRATION_LOCKED`, `MIGRATION_CHANGED`, `PAYLOAD_JSON`, `PAYLOAD_SIZE`, `SCAN_TIMEOUT`, `SCAN_MATCH_LIMIT`, `SCAN_COMPLEXITY`, `SCAN_ATTACHMENT`, `SCAN_JSON_REWRITE`, `SCAN_NUMBER_UNSAFE`, `SCAN_UNIQUE_FAILED`, `FIXED_OVERLAP`, `FIXED_ALIAS_REUSED`, `AUDIT_FULL`, `AUDIT_PARTIAL`, `AUDIT_LOCKED`, `AUDIT_UNSAFE` and `WORKER_FAILED`.
 
 Notifications can scroll away, so `/protecter status` repeats the last recorded block for the session, and a tool blocked while protection is unavailable reports the same cause. Requests still fail closed: the outgoing payload is replaced with `{}`.
 
@@ -125,13 +150,13 @@ Input / history / tools / system prompt / tool definitions
                          ↓
 before_provider_request: final JSON text scan
                          ↓
-__PIP_<192-bit random hex>__ → LLM gateway
+shape-preserving random value → LLM gateway
                          ↓
 Local response and tool-argument restoration
 ```
 
 1. Scan JSON strings, keys and numbers, including decoded JSON-string tool arguments. Local user input and original history are unchanged.
-2. Generate tokens with `crypto.randomBytes(24)`. Runtime mappings stay in memory and are not restored across restarts. **Since 0.3.0, successful original/token pairs are also persisted in the private audit log.** They are never injected into configuration, session custom entries or model prompts.
+2. Generate a shape-preserving replacement with `crypto.randomBytes`. Runtime mappings stay in memory and are not restored across restarts. **Since 0.3.0, successful original/replacement pairs are also persisted in the private audit log.** They are never injected into configuration, session custom entries or model prompts.
 3. Restore finalized assistant text, thinking and tool arguments. The TUI Markdown transformer restores complete streamed tokens; partial tokens may briefly appear. RPC/JSON deltas remain masked until final `message_end`. Altered or truncated tokens cannot be restored.
 4. Restore tool arguments before execution so legitimate local operations use original values; redact them again on subsequent requests. **Restoring credentials is not tool authorization or exfiltration prevention.**
 5. Execute regex scans in a terminable worker. On failure, return `{}` and request cancellation rather than relying on hook exceptions swallowed by Pi. An empty request or provider validation error may still occur, but the handler does not return the original payload.
@@ -253,6 +278,31 @@ pi -e ./src/index.ts
 
 为保持可逆保护，不同规则复用相同目标、目标互为子串、目标包含配置敏感值、使用保留 `__PIP_` 名称或定义冲突时拒绝加载。固定正则在同一实例中只能表示一种不同的匹配原文，第二种原文会导致请求被拒绝。涉及固定规则的部分重叠匹配也拒绝，不静默选择规则或泄漏后缀；纯随机规则重叠仍合并。迁移保留固定目标，遇到冲突停止且不删除原文件。修改后请重载；旧插件版本不支持此字段。
 
+### 同形替换
+
+从 0.6.0 起，命中内容不再替换为不透明占位符，而是替换为**同形**随机值，使请求保持结构有效：
+
+| 原文 | 替换值 | 保留特征 |
+| --- | --- | --- |
+| `9007199254740991`（数字） | `2844008842109708`（数字） | JSON 类型、位数、安全整数范围 |
+| `13800138000` | `06864831332` | 长度、纯数字 |
+| `Alex.Morgan@Example.COM` | `Ufqz.Vwtudb@Rjdnpxe.HGZ` | 长度、大小写形态、标点位置 |
+| `张三` | `丅欕` | 汉字体系、字数 |
+| `Nguyễn Văn Tèo` | `Ufefṉg Zżt Sàb` | 带重音拉丁字母、词边界 |
+| `ひらがな` | `ゅせはっ` | 平假名 |
+
+这修复了类似 `'9007199254740991' is not of type 'number'` 的提供商错误：过去数值字段会被替换成字符串占位符。现在数值仍为数字，位数不变并保持安全整数；若部分匹配无法作为数字精确往返，则以 `SCAN_NUMBER_UNSAFE` 拦截，而不发送错误类型。
+
+字母和数字在各自文字体系内替换：ASCII、Latin-1、Latin Extended-A、Latin Extended Additional（含越南语）、希腊语、西里尔语、希伯来语、阿拉伯语、泰语、平假名、片假名、谚文及汉字。标点、空白、表情、符号以及上述范围之外的码位保持不变，这正是 URL、邮箱和内嵌 JSON 仍可解析的原因。
+
+**这是有意为之的权衡。** 不透明占位符仅暴露“发生了脱敏”；同形值还会暴露长度、字符类别和标点结构，并且在模型看来像真实数据。不支持的文字体系会原样保留，因此匹配这类文本的规则可能残留部分可见内容。
+
+为保证还原精确，候选值会被校验：与原文相同、已被占用、或已出现在同一请求中的候选值会被拒绝。无法生成唯一值时（通常是极短匹配），以 `SCAN_UNIQUE_FAILED` 拦截请求。由于同形值与普通内容难以区分，若模型自行输出了相同的短字符串，它会被还原为原文，因此应优先匹配更长、更有辨识度的值。
+
+### 消息语言
+
+所有通知、提示和诊断仅以**单一语言**呈现，语言按环境变量依次选取：`PI_PROTECTER_LANG`、`LC_ALL`、`LC_MESSAGES`、`LANG`、`LANGUAGE`，最后是运行时区域。`zh*` 选择简体中文，其余回退英文。可设置 `PI_PROTECTER_LANG=en` 或 `PI_PROTECTER_LANG=zh` 覆盖。错误码、阶段和数值细节保持语言无关，便于搜索和反馈。
+
 ### 多轮一致性与提示词缓存
 
 随机占位符按精确原文首次生成，在同一扩展实例内持续复用，包括本地回复还原后的再次脱敏；新建扫描 worker 不会重置映射。这有助于前缀稳定，但不保证提供商 KV Cache 命中，模型、工具、消息顺序、缓存有效期和路由也有影响。重载、进程重启和会话实例替换会清除映射；不同进程不共享映射，审计时间和请求 ID 不进入模型请求体。
@@ -274,16 +324,16 @@ pi -e ./src/index.ts
 请求被拦截时，提示不再是单一笼统信息，而是给出失败阶段、稳定错误码和处理建议：
 
 ```text
-SPI Protecter blocked this request / 已阻止该请求
+SPI Protecter 已阻止该请求
 code=CONFIG_EMPTY_MATCH stage=configuration rule=1
-Reason / 原因: Regex matches an empty string / 正则匹配空字符串
-Action / 处理: Require a non-empty match in the numbered rule / 修改指定规则，要求非空匹配
-Details / 详情: /protecter status
+原因：正则匹配空字符串
+处理：修改指定规则，要求非空匹配
+详情：/protecter status
 ```
 
 阶段包括初始化、配置、迁移、请求、扇描、worker、审计和内部错误。定位信息仅在已知时输出：`rule` 和 `otherRule` 是敏感词数组中从 1 开始的序号，`node` 为已扫描节点数，`bytes`、`limit`、`timeoutMs` 说明超限情况，`errno` 为系统错误码。
 
-常见错误码包括 `CONFIG_JSON`、`CONFIG_SCHEMA`、`CONFIG_REGEX`、`CONFIG_TARGET`、`CONFIG_CONFLICT`、`CONFIG_EMPTY_MATCH`、`CONFIG_SENSITIVE_TARGET`、`CONFIG_ALIAS_CONFLICT`、`CONFIG_UNSAFE`、`MIGRATION_LOCKED`、`MIGRATION_CHANGED`、`PAYLOAD_JSON`、`PAYLOAD_SIZE`、`SCAN_TIMEOUT`、`SCAN_MATCH_LIMIT`、`SCAN_COMPLEXITY`、`SCAN_ATTACHMENT`、`SCAN_JSON_REWRITE`、`FIXED_OVERLAP`、`FIXED_ALIAS_REUSED`、`AUDIT_FULL`、`AUDIT_PARTIAL`、`AUDIT_LOCKED`、`AUDIT_UNSAFE` 和 `WORKER_FAILED`。
+常见错误码包括 `CONFIG_JSON`、`CONFIG_SCHEMA`、`CONFIG_REGEX`、`CONFIG_TARGET`、`CONFIG_CONFLICT`、`CONFIG_EMPTY_MATCH`、`CONFIG_SENSITIVE_TARGET`、`CONFIG_ALIAS_CONFLICT`、`CONFIG_UNSAFE`、`MIGRATION_LOCKED`、`MIGRATION_CHANGED`、`PAYLOAD_JSON`、`PAYLOAD_SIZE`、`SCAN_TIMEOUT`、`SCAN_MATCH_LIMIT`、`SCAN_COMPLEXITY`、`SCAN_ATTACHMENT`、`SCAN_JSON_REWRITE`、`SCAN_NUMBER_UNSAFE`、`SCAN_UNIQUE_FAILED`、`FIXED_OVERLAP`、`FIXED_ALIAS_REUSED`、`AUDIT_FULL`、`AUDIT_PARTIAL`、`AUDIT_LOCKED`、`AUDIT_UNSAFE` 和 `WORKER_FAILED`。
 
 通知可能消失，因此 `/protecter status` 会重新展示本会话最近一次拦截；防护不可用时被拦截的工具也会报告同一原因。请求仍然失败不放行：出站请求体会被替换为 `{}`。
 
@@ -296,13 +346,13 @@ Details / 详情: /protecter status
                          ↓
 before_provider_request：最终 JSON 文本扫描
                          ↓
-__PIP_<192-bit 随机十六进制>__ → LLM 网关
+同形随机值 → LLM 网关
                          ↓
 本地回复和工具参数还原
 ```
 
 1. 扫描 JSON 字符串、键和数字，包括解码后的 JSON 字符串工具参数；不修改本地用户输入和历史原文。
-2. 使用 `crypto.randomBytes(24)` 生成占位符。运行时映射保存在内存，不跨重启恢复。**从 0.3.0 起，成功替换的原文和占位符也会持久化到私有审计日志。** 不注入配置、会话自定义条目或模型提示。
+2. 使用 `crypto.randomBytes` 生成同形替换值。运行时映射保存在内存，不跨重启恢复。**从 0.3.0 起，成功替换的原文和占位符也会持久化到私有审计日志。** 不注入配置、会话自定义条目或模型提示。
 3. 还原最终 assistant 文本、思考内容和工具参数。TUI 在完整占位符到达后还原，片段可能短暂显示；RPC/JSON 增量仍脱敏，直到最终消息还原。被改写或截断的占位符无法还原。
 4. 工具执行前还原参数，让合法本地操作使用原值；后续请求再次脱敏。**凭证还原不等于工具授权或防外传。**
 5. 正则扫描运行于可终止 worker。失败时返回 `{}` 并请求取消，不依赖被 Pi 吞掉的钩子异常；仍可能产生空请求或提供商校验错误，但处理器不返回原始请求体。

package/SECURITY.md

@@ -19,8 +19,10 @@ Prevent configured personal information from accidentally entering Pi LLM reques
 
 ## Implementation / 实现策略
 
-- Scan outgoing payload text with random 192-bit placeholders. Runtime mappings stay in memory, but version 0.3.0 adds plaintext original/token audit pairs in private JSONL. Audit files are sensitive credential stores, not encrypted archives; never upload them. Logs persist after exit and are not loaded to restore tokens.
-  出站文本使用随机占位符，运行映射保存在内存，但 0.3.0 新增私有 JSONL 原文与占位符审计。日志属于敏感凭证存储，不是加密归档，禁止上传；退出后仍保留，不用于恢复占位符。
+- Scan outgoing payload text and replace matches with random shape-preserving values. Runtime mappings stay in memory, but version 0.3.0 adds plaintext original/replacement audit pairs in private JSONL. Audit files are sensitive credential stores, not encrypted archives; never upload them. Logs persist after exit and are not loaded to restore mappings.
+  出站文本使用随机同形值替换，运行映射保存在内存，但 0.3.0 新增私有 JSONL 原文与替换值审计。日志属于敏感凭证存储，不是加密归档，禁止上传；退出后仍保留，不用于恢复映射。
+- Shape-preserving replacements (0.6.0) keep JSON types, length, character class and punctuation structure, so they leak more metadata than opaque tokens and look like plausible real data. Unsupported scripts and symbols are preserved unchanged, so part of a matched value may stay visible. Short matches may be restored when a model independently emits the same string; prefer long, distinctive targets. Numeric values that cannot round-trip and matches with no unique replacement fail closed.
+  同形替换（0.6.0）保留 JSON 类型、长度、字符类别和标点结构，因此比不透明占位符泄露更多元信息，且看似真实数据。不支持的文字体系和符号原样保留，命中值可能部分可见。模型自行输出相同短字符串时可能被还原，应优先使用较长且有辨识度的目标；无法精确往返的数值以及无唯一替换值的匹配均拒绝放行。
 - Audit writes use 0600 files, safe-open checks, a cooperative lock and fsync before returning a redacted payload. Logging errors fail closed. Success means local replacement, not provider delivery. File size and preview limits bound resource usage; users manage retention locally. Hard crashes may leave stale locks or partial records. Same-UID writers and terminal capture remain outside the threat model.
   日志使用 0600、安全打开检查、协作锁，并在返回脱敏请求前同步落盘；日志失败则拒绝请求。成功表示本地替换而非网关已接收。文件及预览大小受限，用户本地管理保留策略；硬崩溃可能残留锁或不完整记录，同用户权限攻击和终端录屏仍不在防护范围。
 - `/protecter` previews are TUI-only and require confirmation before showing original values; nothing is injected into model context or session entries. Trusted extensions may still observe UI hooks. Configuration caching remains memory-only during requests, but matched requests now perform audit-file writes.

package/dist/index.mjs

@@ -1,13 +1,13 @@
 /*! SPI Protecter | MIT | see LICENSE / SPI 隐私保护插件 | MIT 许可 */
-import{getAgentDir as Ue,VERSION as le}from"@earendil-works/pi-coding-agent";import{Worker as ke}from"node:worker_threads";import{fileURLToPath as be}from"node:url";import*as g from"node:fs";import{join as _,resolve as Oe}from"node:path";import{createHash as we,randomUUID as Ne}from"node:crypto";import{Worker as Ee}from"node:worker_threads";import{fileURLToPath as Se}from"node:url";var W={INTERNAL:["internal","Unexpected local failure / 未预期的本地错误","Reload; check the installed package integrity / 重载并检查安装包完整性"],NOT_READY:["initialization","Protection is not initialized / 防护尚未初始化","Run /protecter status for the initialization error, fix it, then /reload / 查看初始化错误，修复后重载"],UNSUPPORTED_PI:["initialization","Unsupported Pi version / Pi 版本不受支持","Use Pi 0.85.1-0.85.x / 请使用受支持的 Pi 版本"],MACHINE_ID:["initialization","Machine identifier unavailable / 无法获取机器标识","Check local OS machine-ID access; no random fallback is used / 检查系统机器标识访问权限，不使用随机回退"],CONFIG_JSON:["configuration","Invalid configuration JSON / 配置 JSON 无效","Fix JSON syntax locally, then /reload / 本地修复 JSON 语法后重载"],CONFIG_SCHEMA:["configuration","Invalid configuration structure or rule / 配置结构或规则无效","Use version 1, a sensitiveWords array and documented fields; rule shows the 1-based index / 使用版本1、敏感词数组及文档字段，rule 为规则序号"],CONFIG_REGEX:["configuration","Invalid regex or flags / 正则或标志无效","Fix the numbered rule; flags support gimsu only / 修复指定规则，标志仅支持 gimsu"],CONFIG_TARGET:["configuration","Invalid fixed replacement target / 固定替换目标无效","Use a non-blank string under 8192 characters without reserved __PIP_ names / 使用非空且少于8192字符的目标，不含保留名称"],CONFIG_CONFLICT:["configuration","Conflicting rule definitions / 规则定义冲突","Give the same matcher one replacement policy across all configs / 为同一匹配器设置一致的替换策略"],CONFIG_SIZE:["configuration","Configuration exceeds size or rule limit / 配置超过体积或规则数上限","Reduce configuration size or rule count; rules are never truncated / 减少配置体积或规则数，规则不会被截断"],CONFIG_IO:["configuration","Cannot access configuration / 无法访问配置","Check local permissions, ownership and free space / 检查本地权限、所有者和磁盘空间"],CONFIG_UNSAFE:["configuration","Unsafe configuration file / 配置文件不安全","Use an owned regular file without symbolic or hard links / 使用本人所有的普通文件，不含符号或硬链接"],CONFIG_EMPTY_MATCH:["configuration","Regex matches an empty string / 正则匹配空字符串","Require a non-empty match in the numbered rule / 修改指定规则，要求非空匹配"],CONFIG_SENSITIVE_TARGET:["configuration","Fixed target overlaps a sensitive rule / 固定目标与敏感规则重叠","Choose a target unrelated to every sensitive matcher / 选择与所有敏感匹配器无关的目标"],CONFIG_ALIAS_CONFLICT:["configuration","Fixed aliases overlap each other / 固定别名相互重叠","Use distinct aliases that are not substrings of one another / 使用互不包含的不同别名"],CONFIG_TIMEOUT:["configuration","Rule validation timed out / 规则验证超时","Simplify regex rules, then /reload / 简化正则规则后重载"],MIGRATION_LOCKED:["migration","Configuration migration lock is busy / 配置迁移锁被占用","Wait for other Pi processes; inspect a stale lock only after stopping them / 等待其他进程，全部停止后再检查残留锁"],MIGRATION_CHANGED:["migration","Configuration changed during migration / 迁移期间配置发生变化","Stop concurrent edits and /reload; source files are preserved / 停止并发编辑后重载，源文件会保留"],MIGRATION_LIMIT:["migration","Too many configuration candidates / 候选配置过多","Consolidate old configuration files locally / 在本地整理旧配置文件"],MIGRATION_IO:["migration","Migration file operation failed / 迁移文件操作失败","Check permissions, free space and leftover files before retrying / 检查权限、空间和残留文件后重试"],PAYLOAD_JSON:["request","Request is not serializable JSON / 请求无法序列化为 JSON","Inspect the provider or another payload-modifying extension; no payload is logged / 检查提供商或其他请求改写扩展，不记录请求内容"],PAYLOAD_SIZE:["request","Request exceeds the size limit / 请求超过体积上限","Reduce history or tool output size, or start a new session / 减少历史或工具输出，或新建会话"],SCAN_TIMEOUT:["scan","Redaction worker timed out / 脱敏 worker 超时","Simplify regex rules or reduce input size / 简化正则规则或缩小输入"],WORKER_FAILED:["worker","Worker failed to start or exited early / worker 启动失败或提前退出","Verify all dist files and the Node version; reinstall if needed / 检查 dist 文件完整性和 Node 版本，必要时重装"],SCAN_INTERNAL:["scan","Unexpected scan failure / 未预期的扫描错误","Review recent rule changes and retry with smaller input / 检查最近的规则改动并缩小输入"],SCAN_ZERO_WIDTH:["scan","Regex produced a zero-width match / 正则产生零宽匹配","Require a non-empty match in the numbered rule / 修改指定规则，要求非空匹配"],SCAN_MATCH_LIMIT:["scan","Too many matches in one request / 单次请求匹配次数过多","Narrow overly broad rules or reduce input / 缩小过宽规则或减少输入"],SCAN_MAPPING_LIMIT:["scan","Mapping limit reached / 映射数量达到上限","Start a new session or /reload; in-memory mappings reset / 新建会话或重载，内存映射将重置"],FIXED_MAPPING_CONFLICT:["scan","One original has conflicting replacements / 同一原文存在冲突替换","Use one replacement for overlapping matchers, then /reload / 为重叠匹配器使用同一目标后重载"],FIXED_ALIAS_REUSED:["scan","Fixed alias already maps to another original / 固定别名已映射其他原文","A fixed regex represents one original per instance; use random replacement or split literal rules / 固定正则在同一实例仅代表一种原文，改用随机替换或拆分字面规则"],FIXED_SENSITIVE_TARGET:["scan","Replacement contains the matched original / 替换目标包含命中原文","Choose a target without sensitive content / 选择不含敏感内容的目标"],FIXED_OVERLAP:["scan","Fixed replacement partially overlaps another match / 固定替换与其他匹配部分重叠","Remove the partial overlap or use random rules; rule and otherRule show both rules / 消除部分重叠或改用随机规则，rule 与 otherRule 指出两条规则"],FIXED_ALIAS_CROSSING:["scan","Regex crosses a learned fixed alias / 正则跨越已学习的固定别名","Narrow the regex or choose a different alias / 缩小正则范围或更换别名"],SCAN_COMPLEXITY:["scan","Request exceeds depth or node limits / 请求超过层级或节点上限","Reduce nested data and tool schema size / 减少嵌套数据和工具结构体积"],SCAN_JSON_REWRITE:["scan","Replacement breaks embedded JSON syntax / 替换破坏内嵌 JSON 语法","Avoid rules spanning JSON syntax; match field values instead / 避免跨 JSON 语法的规则，改为匹配字段值"],SCAN_ATTACHMENT:["scan","Unsupported image, audio, video or file content / 不支持图片、音频、视频或文件内容","Remove attachments or send reviewed text only / 移除附件或仅发送已审查的文本"],SCAN_KEY_COLLISION:["scan","Replacement creates duplicate object keys / 替换后对象键重复","Use distinct targets or avoid matching schema keys / 使用不同目标或避免匹配结构键"],AUDIT_BATCH_LIMIT:["audit","Audit batch exceeds the size limit / 审计批次超过上限","Reduce matched content per request / 减少单个请求的命中内容"],AUDIT_FULL:["audit","Audit log would exceed the size limit / 审计日志将超过上限","Review records, then run /protecter logs clear or archive locally / 检查记录后清空日志或本地归档"],AUDIT_PARTIAL:["audit","Audit log has an incomplete last line / 审计日志末行不完整","Inspect locally or run /protecter logs clear; never upload the log / 本地检查或清空日志，不要上传日志"],AUDIT_LOCKED:["audit","Audit lock stayed busy / 审计锁持续被占用","Wait for writers; stop all Pi processes before inspecting a stale lock / 等待写入完成，全部停止后再检查残留锁"],AUDIT_UNSAFE:["audit","Unsafe audit file / 审计文件不安全","Use an owned regular file without links; checks are not bypassed / 使用本人普通文件且不含链接，不会绕过检查"],AUDIT_IO:["audit","Audit file operation failed / 审计文件操作失败","Check errno, permissions and free space; no path or content is exposed / 检查错误码、权限和磁盘空间，不暴露路径或内容"]},H=["rule","otherRule","node","bytes","limit","timeoutMs"],ue=/^(EACCES|EPERM|ENOENT|ENOSPC|EDQUOT|EROFS|ELOOP|EISDIR|ENOTDIR|EMFILE|ENFILE|EIO|EEXIST|EBADF|EBUSY|ENOTEMPTY)$/;function de(n,e={}){let[t,r,i]=W[n],o={};for(let f of H){let s=e[f];typeof s=="number"&&Number.isSafeInteger(s)&&s>=0&&(o[f]=s)}return typeof e.errno=="string"&&ue.test(e.errno)&&(o.errno=e.errno),{code:n,stage:t,reason:r,action:i,...o}}function S(n){let e=[...H,"errno"].filter(t=>n[t]!==void 0).map(t=>`${t}=${n[t]}`).join(" ");return["SPI Protecter blocked this request / 已阻止该请求",`code=${n.code} stage=${n.stage}${e?` ${e}`:""}`,`Reason / 原因: ${n.reason}`,`Action / 处理: ${n.action}`,"Details / 详情: /protecter status"].join(`
-`)}var N=class extends Error{diagnostic;constructor(e,t={}){let r=de(e,t);super(S(r)),this.name="ProtectionError",this.diagnostic=r}};function c(n,e={}){return new N(n,e)}function y(n,e,t={}){if(n instanceof N)return c(n.diagnostic.code,{...n.diagnostic,...t});let r=n&&typeof n=="object"&&"code"in n?n.code:void 0;return c(e,{...t,errno:typeof r=="string"?r:void 0})}function D(n,e){if(!n||typeof n!="object")return c(e);let t=n,r=typeof t.code=="string"&&Object.hasOwn(W,t.code)?t.code:e;return c(r,t)}import{constants as A,closeSync as j,fchmodSync as ge,fstatSync as me,mkdirSync as he,openSync as Y,readFileSync as pe,writeFileSync as ye}from"node:fs";import{dirname as Ie}from"node:path";var F={version:1,sensitiveWords:[]};function L(n){let e;try{e=JSON.parse(n)}catch{throw c("CONFIG_JSON")}let t=0;try{if(!e||e.version!==1||!Array.isArray(e.sensitiveWords)||Object.keys(e).some(i=>!["version","sensitiveWords"].includes(i)))throw c("CONFIG_SCHEMA");if(e.sensitiveWords.length>1e3)throw c("CONFIG_SIZE",{limit:1e3});let r=new Map;for(let i of e.sensitiveWords){if(t++,typeof i=="string"){if(!i||i.length>8192)throw c("CONFIG_SCHEMA",{rule:t,limit:8192});let f=JSON.stringify(["literal",i]);if(r.has(f)&&r.get(f)!==void 0)throw c("CONFIG_CONFLICT",{rule:t});r.set(f,void 0);continue}if(!i||typeof i!="object")throw c("CONFIG_SCHEMA",{rule:t});if(Object.hasOwn(i,"replacement")&&(typeof i.replacement!="string"||!i.replacement.trim()||i.replacement.length>8192||i.replacement.includes("__PIP_")))throw c("CONFIG_TARGET",{rule:t,limit:8192});if(i.type==="literal"){if(Object.keys(i).some(f=>!["type","value","replacement"].includes(f))||typeof i.value!="string"||!i.value||i.value.length>8192)throw c("CONFIG_SCHEMA",{rule:t,limit:8192})}else if(i.type==="regex"){if(Object.keys(i).some(f=>!["type","pattern","flags","replacement"].includes(f))||typeof i.pattern!="string"||!i.pattern||i.pattern.length>8192||i.flags!==void 0&&(typeof i.flags!="string"||!/^[gimsu]*$/.test(i.flags)))throw c("CONFIG_REGEX",{rule:t,limit:8192});try{new RegExp(i.pattern,i.flags??"")}catch{throw c("CONFIG_REGEX",{rule:t})}}else throw c("CONFIG_SCHEMA",{rule:t});let o=i.type==="literal"?JSON.stringify(["literal",i.value]):JSON.stringify(["regex",i.pattern,[...new Set((i.flags??"")+"g")].sort().join("")]);if(r.has(o)&&r.get(o)!==i.replacement)throw c("CONFIG_CONFLICT",{rule:t});r.set(o,i.replacement)}return e}catch(r){throw r instanceof N?r:c("CONFIG_SCHEMA",{rule:t})}}function B(n,e=!1){let t;try{if(e){he(Ie(n),{recursive:!0,mode:448});try{let o=Y(n,A.O_WRONLY|A.O_CREAT|A.O_EXCL,384);try{ye(o,JSON.stringify(F,null,2)+`
-`)}finally{j(o)}}catch(o){if(o.code!=="EEXIST")throw y(o,"CONFIG_IO")}}t=Y(n,A.O_RDONLY|A.O_NOFOLLOW|A.O_NONBLOCK);let r=me(t);if(r.size>1024*1024)throw c("CONFIG_SIZE",{bytes:r.size,limit:1024*1024});if(!r.isFile()||r.nlink!==1||process.getuid&&r.uid!==process.getuid())throw c("CONFIG_UNSAFE");process.platform!=="win32"&&ge(t,384);let i=pe(t,"utf8");if(Buffer.byteLength(i)>1024*1024)throw c("CONFIG_SIZE",{bytes:Buffer.byteLength(i),limit:1024*1024});return{config:L(i),raw:i}}catch(r){let i=r&&typeof r=="object"&&"code"in r?r.code:void 0;throw y(r,i==="ELOOP"||i==="EISDIR"||i==="ENOTDIR"?"CONFIG_UNSAFE":"CONFIG_IO")}finally{t!==void 0&&j(t)}}var G=/^protecter(?:\.[a-f0-9]{32})?\.json$/;function Ae(n){return new Promise((e,t)=>{let r=new Ee(Se(new URL("./validate-worker.mjs",import.meta.url)),{workerData:n,execArgv:[],resourceLimits:{maxOldGenerationSizeMb:64}}),i=!1,o=(s,a=c("WORKER_FAILED"))=>{i||(i=!0,clearTimeout(f),r.terminate(),s?e():t(a))},f=setTimeout(()=>o(!1,c("CONFIG_TIMEOUT",{timeoutMs:2e3})),2e3);r.once("message",s=>s===!0?o(!0):o(!1,D(s,"CONFIG_SCHEMA"))),r.once("error",()=>o(!1)),r.once("exit",()=>o(!1))})}function _e(n){let e=new Set,t=[];for(let i of n)for(let o of i.sensitiveWords){let f=typeof o=="string"?JSON.stringify(["literal",o,null]):o.type==="literal"?JSON.stringify(["literal",o.value,o.replacement??null]):JSON.stringify(["regex",o.pattern,[...new Set((o.flags??"")+"g")].sort().join(""),o.replacement??null]);e.has(f)||(e.add(f),t.push(o))}let r=JSON.stringify({version:1,sensitiveWords:t});if(Buffer.byteLength(r)>1024*1024)throw c("CONFIG_SIZE",{bytes:Buffer.byteLength(r),limit:1024*1024});return L(r)}function q(n){let e;try{e=g.lstatSync(n,{bigint:!0})}catch(t){throw y(t,"CONFIG_IO")}if(!e.isFile()||e.nlink!==1n||process.getuid&&e.uid!==BigInt(process.getuid()))throw c("CONFIG_UNSAFE");return`${e.dev}:${e.ino}:${e.size}:${e.mtimeNs}`}function M(n,e){let t=_(n,e),r=q(t),i=B(t);if(q(t)!==r)throw c("MIGRATION_CHANGED");return{name:e,...i,identity:r,digest:we("sha256").update(i.raw).digest("hex")}}function C(n,e){let t=M(n,e.name);if(t.identity!==e.identity||t.digest!==e.digest)throw c("MIGRATION_CHANGED")}function k(n){return g.readdirSync(n).filter(e=>G.test(e)).sort()}function X(n){if(process.platform==="win32")return;let e=g.openSync(n,g.constants.O_RDONLY);try{g.fsyncSync(e)}finally{g.closeSync(e)}}async function K(n,e,t={}){if(!/^[a-f0-9]{32}$/.test(e))throw c("MACHINE_ID");let r=Oe(n),i=`protecter.${e}.json`,o=_(r,i);g.mkdirSync(r,{recursive:!0,mode:448});let f=_(r,".protecter-migration.lock"),s=Date.now()+(t.lockTimeoutMs??5e3);for(;;)try{g.mkdirSync(f,{mode:448});break}catch(l){if(l.code!=="EEXIST")throw y(l,"MIGRATION_IO");if(Date.now()>=s)throw c("MIGRATION_LOCKED",{timeoutMs:t.lockTimeoutMs??5e3});await new Promise(O=>setTimeout(O,50))}let a;try{let l=k(r);if(l.length>64)throw c("MIGRATION_LIMIT",{limit:64});let u=[...l].sort((h,E)=>h===i?-1:E===i?1:h.localeCompare(E)).map(h=>M(r,h)),p=_e(u.length?u.map(h=>h.config):[F]);if(await Ae([p]),u.length===1&&u[0].name===i){if(C(r,u[0]),JSON.stringify(k(r))!==JSON.stringify(l))throw c("MIGRATION_CHANGED");return{path:o,config:u[0].config,raw:u[0].raw,sourceRaws:[u[0].raw],migrated:0}}let m=JSON.stringify(p,null,2)+`
-`;if(Buffer.byteLength(m)>1024*1024)throw c("CONFIG_SIZE",{bytes:Buffer.byteLength(m),limit:1024*1024});a=_(r,`.protecter-migration.${Ne()}.tmp`);let I=g.openSync(a,g.constants.O_WRONLY|g.constants.O_CREAT|g.constants.O_EXCL,384);try{g.writeFileSync(I,m),g.fsyncSync(I)}finally{g.closeSync(I)}if(t.checkpoint?.("beforeCommit",o),JSON.stringify(k(r))!==JSON.stringify(l))throw c("MIGRATION_CHANGED");for(let h of u)C(r,h);g.renameSync(a,o),a=void 0,X(r);let w=M(r,i);if(w.raw!==m)throw c("MIGRATION_CHANGED");t.checkpoint?.("afterCommit",o);for(let h of u)h.name!==i&&(t.checkpoint?.("beforeDelete",_(r,h.name)),C(r,w),C(r,h),g.unlinkSync(_(r,h.name)));X(r);let R=[i];if(JSON.stringify(k(r))!==JSON.stringify(R))throw c("MIGRATION_CHANGED");return C(r,w),{path:o,config:p,raw:m,sourceRaws:[...new Set([...u.map(h=>h.raw),m])],migrated:u.filter(h=>h.name!==i).length}}catch(l){throw l instanceof N?l:y(l,"MIGRATION_IO")}finally{if(a)try{g.unlinkSync(a)}catch{}g.rmdirSync(f)}}import{createHash as Ce}from"node:crypto";import{readFileSync as Te}from"node:fs";import{execFileSync as Z}from"node:child_process";var V="SPI Protecter: machine ID unavailable / 无法获取机器标识。";function U(n){let e=n.trim().toLowerCase().replace(/-/g,"");if(!/^[a-f0-9]{32}$/.test(e)||/^0+$/.test(e))throw new Error(V);return Ce("sha256").update(`pi-information-protecter:v1:${e}`).digest("hex").slice(0,32)}function Q(){try{if(process.platform==="linux")return U(Te("/etc/machine-id","utf8"));if(process.platform==="darwin"){let n=Z("/usr/sbin/ioreg",["-rd1","-c","IOPlatformExpertDevice"],{encoding:"utf8",timeout:5e3,maxBuffer:1048576,stdio:["ignore","pipe","pipe"]});return U(n.match(/"IOPlatformUUID"\s*=\s*"([a-fA-F0-9-]+)"/)?.[1]??"")}if(process.platform==="win32"){let n=Z("reg.exe",["query","HKLM\\SOFTWARE\\Microsoft\\Cryptography","/v","MachineGuid","/reg:64"],{encoding:"utf8",timeout:5e3,maxBuffer:65536,stdio:["ignore","pipe","pipe"]});return U(n.match(/MachineGuid\s+REG_SZ\s+([a-fA-F0-9-]+)/i)?.[1]??"")}}catch{}throw new Error(V)}import*as d from"node:fs";import{randomUUID as Re}from"node:crypto";var ee=32*1024*1024,te=8*1024*1024;function De(n){let e=t=>String(t).padStart(2,"0");return`${n.getFullYear()}-${e(n.getMonth()+1)}-${e(n.getDate())} ${e(n.getHours())}:${e(n.getMinutes())}:${e(n.getSeconds())}`}function $(n,e,t=e){let r=d.openSync(n,(e?d.constants.O_RDWR|(t?d.constants.O_CREAT:0):d.constants.O_RDONLY)|d.constants.O_NOFOLLOW|d.constants.O_NONBLOCK,384);try{let i=d.fstatSync(r);if(!i.isFile()||i.nlink!==1||process.getuid&&i.uid!==process.getuid())throw c("AUDIT_UNSAFE");return process.platform!=="win32"&&d.fchmodSync(r,384),r}catch(i){throw d.closeSync(r),y(i,"AUDIT_UNSAFE")}}function b(n){let e=n&&typeof n=="object"&&"code"in n?n.code:void 0;return y(n,e==="ELOOP"||e==="EISDIR"||e==="ENOTDIR"?"AUDIT_UNSAFE":"AUDIT_IO")}async function re(n){let e=`${n}.lock`,t=Date.now()+2e3;for(;;)try{return d.mkdirSync(e,{mode:448}),e}catch(r){if(r.code!=="EEXIST")throw y(r,"AUDIT_IO");if(Date.now()>=t)throw c("AUDIT_LOCKED",{timeoutMs:2e3});await new Promise(i=>setTimeout(i,25))}}async function ne(n){let e=await re(n),t;try{try{t=$(n,!0,!1)}catch(i){if(i.code==="ENOENT")return 0;throw i}let r=d.fstatSync(t).size;return d.ftruncateSync(t,0),d.fsyncSync(t),r}catch(r){throw b(r)}finally{try{t!==void 0&&d.closeSync(t)}finally{d.rmdirSync(e)}}}async function ie(n,e,t){if(!t.length)return;let r=new Date,i=Re(),o=Buffer.from(t.map(([a,l])=>JSON.stringify({version:1,time:De(r),timezoneOffset:-r.getTimezoneOffset(),requestId:i,provider:e||"unknown",original:l,replacement:a})).join(`
+import{getAgentDir as et,VERSION as Ee}from"@earendil-works/pi-coding-agent";import{Worker as Ye}from"node:worker_threads";import{fileURLToPath as We}from"node:url";import*as d from"node:fs";import{join as C,resolve as Ge}from"node:path";import{createHash as Me,randomUUID as ke}from"node:crypto";import{Worker as ve}from"node:worker_threads";import{fileURLToPath as Ue}from"node:url";var z={INTERNAL:["Unexpected local failure","Reload; check the installed package integrity"],NOT_READY:["Protection is not initialized","Run /protecter status for the initialization error, fix it, then /reload"],UNSUPPORTED_PI:["Unsupported Pi version","Use Pi 0.85.1-0.85.x"],MACHINE_ID:["Machine identifier unavailable","Check local OS machine-ID access; no random fallback is used"],CONFIG_JSON:["Invalid configuration JSON","Fix JSON syntax locally, then /reload"],CONFIG_SCHEMA:["Invalid configuration structure or rule","Use version 1, a sensitiveWords array and documented fields; rule shows the 1-based index"],CONFIG_REGEX:["Invalid regex or flags","Fix the numbered rule; flags support gimsu only"],CONFIG_TARGET:["Invalid fixed replacement target","Use a non-blank string under 8192 characters without reserved __PIP_ names"],CONFIG_CONFLICT:["Conflicting rule definitions","Give the same matcher one replacement policy across all configs"],CONFIG_SIZE:["Configuration exceeds size or rule limit","Reduce configuration size or rule count; rules are never truncated"],CONFIG_IO:["Cannot access configuration","Check local permissions, ownership and free space"],CONFIG_UNSAFE:["Unsafe configuration file","Use an owned regular file without symbolic or hard links"],CONFIG_EMPTY_MATCH:["Regex matches an empty string","Require a non-empty match in the numbered rule"],CONFIG_SENSITIVE_TARGET:["Fixed target overlaps a sensitive rule","Choose a target unrelated to every sensitive matcher"],CONFIG_ALIAS_CONFLICT:["Fixed aliases overlap each other","Use distinct aliases that are not substrings of one another"],CONFIG_TIMEOUT:["Rule validation timed out","Simplify regex rules, then /reload"],MIGRATION_LOCKED:["Configuration migration lock is busy","Wait for other Pi processes; inspect a stale lock only after stopping them"],MIGRATION_CHANGED:["Configuration changed during migration","Stop concurrent edits and /reload; source files are preserved"],MIGRATION_LIMIT:["Too many configuration candidates","Consolidate old configuration files locally"],MIGRATION_IO:["Migration file operation failed","Check permissions, free space and leftover files before retrying"],PAYLOAD_JSON:["Request is not serializable JSON","Inspect the provider or another payload-modifying extension; no payload is logged"],PAYLOAD_SIZE:["Request exceeds the size limit","Reduce history or tool output size, or start a new session"],SCAN_TIMEOUT:["Redaction worker timed out","Simplify regex rules or reduce input size"],WORKER_FAILED:["Worker failed to start or exited early","Verify all dist files and the Node version; reinstall if needed"],SCAN_INTERNAL:["Unexpected scan failure","Review recent rule changes and retry with smaller input"],SCAN_NUMBER_UNSAFE:["Replacement would turn a numeric JSON value into an invalid number","Narrow the rule so it does not match inside numeric fields such as timestamps or schema limits"],SCAN_UNIQUE_FAILED:["Could not generate a unique shape-preserving replacement","The matched value is too short; match a longer value or set an explicit replacement"],SCAN_ZERO_WIDTH:["Regex produced a zero-width match","Require a non-empty match in the numbered rule"],SCAN_MATCH_LIMIT:["Too many matches in one request","Narrow overly broad rules or reduce input"],SCAN_MAPPING_LIMIT:["Mapping limit reached","Start a new session or /reload; in-memory mappings reset"],FIXED_MAPPING_CONFLICT:["One original has conflicting replacements","Use one replacement for overlapping matchers, then /reload"],FIXED_ALIAS_REUSED:["Fixed alias already maps to another original","A fixed regex represents one original per instance; use random replacement or split literal rules"],FIXED_SENSITIVE_TARGET:["Replacement contains the matched original","Choose a target without sensitive content"],FIXED_OVERLAP:["Fixed replacement partially overlaps another match","Remove the partial overlap or use random rules; rule and otherRule show both rules"],FIXED_ALIAS_CROSSING:["Regex crosses a learned fixed alias","Narrow the regex or choose a different alias"],SCAN_COMPLEXITY:["Request exceeds depth or node limits","Reduce nested data and tool schema size"],SCAN_JSON_REWRITE:["Replacement breaks embedded JSON syntax","Avoid rules spanning JSON syntax; match field values instead"],SCAN_ATTACHMENT:["Unsupported image, audio, video or file content","Remove attachments or send reviewed text only"],SCAN_KEY_COLLISION:["Replacement creates duplicate object keys","Use distinct targets or avoid matching schema keys"],RESTORE_COMPLEXITY:["Response nesting is too deep to restore","Reduce nested structures or start a new session with /new"],RESTORE_KEY_COLLISION:["Restoring produced duplicate object keys","Use more specific rules or fixed targets that cannot collide with schema keys"],AUDIT_BATCH_LIMIT:["Audit batch exceeds the size limit","Reduce matched content per request"],AUDIT_FULL:["Audit log would exceed the size limit","Review records, then run /protecter logs clear or archive locally"],AUDIT_PARTIAL:["Audit log has an incomplete last line","Inspect locally or run /protecter logs clear; never upload the log"],AUDIT_LOCKED:["Audit lock stayed busy","Wait for writers; stop all Pi processes before inspecting a stale lock"],AUDIT_UNSAFE:["Unsafe audit file","Use an owned regular file without links; checks are not bypassed"],AUDIT_IO:["Audit file operation failed","Check errno, permissions and free space; no path or content is exposed"]},_e={INTERNAL:["未预期的本地错误","重载并检查安装包完整性"],NOT_READY:["防护尚未初始化","查看初始化错误，修复后重载"],UNSUPPORTED_PI:["Pi 版本不受支持","请使用受支持的 Pi 版本"],MACHINE_ID:["无法获取机器标识","检查系统机器标识访问权限，不使用随机回退"],CONFIG_JSON:["配置 JSON 无效","本地修复 JSON 语法后重载"],CONFIG_SCHEMA:["配置结构或规则无效","使用版本1、敏感词数组及文档字段，rule 为规则序号"],CONFIG_REGEX:["正则或标志无效","修复指定规则，标志仅支持 gimsu"],CONFIG_TARGET:["固定替换目标无效","使用非空且少于8192字符的目标，不含保留名称"],CONFIG_CONFLICT:["规则定义冲突","为同一匹配器设置一致的替换策略"],CONFIG_SIZE:["配置超过体积或规则数上限","减少配置体积或规则数，规则不会被截断"],CONFIG_IO:["无法访问配置","检查本地权限、所有者和磁盘空间"],CONFIG_UNSAFE:["配置文件不安全","使用本人所有的普通文件，不含符号或硬链接"],CONFIG_EMPTY_MATCH:["正则匹配空字符串","修改指定规则，要求非空匹配"],CONFIG_SENSITIVE_TARGET:["固定目标与敏感规则重叠","选择与所有敏感匹配器无关的目标"],CONFIG_ALIAS_CONFLICT:["固定别名相互重叠","使用互不包含的不同别名"],CONFIG_TIMEOUT:["规则验证超时","简化正则规则后重载"],MIGRATION_LOCKED:["配置迁移锁被占用","等待其他进程，全部停止后再检查残留锁"],MIGRATION_CHANGED:["迁移期间配置发生变化","停止并发编辑后重载，源文件会保留"],MIGRATION_LIMIT:["候选配置过多","在本地整理旧配置文件"],MIGRATION_IO:["迁移文件操作失败","检查权限、空间和残留文件后重试"],PAYLOAD_JSON:["请求无法序列化为 JSON","检查提供商或其他请求改写扩展，不记录请求内容"],PAYLOAD_SIZE:["请求超过体积上限","减少历史或工具输出，或新建会话"],SCAN_TIMEOUT:["脱敏 worker 超时","简化正则规则或缩小输入"],WORKER_FAILED:["worker 启动失败或提前退出","检查 dist 文件完整性和 Node 版本，必要时重装"],SCAN_INTERNAL:["未预期的扫描错误","检查最近的规则改动并缩小输入"],SCAN_NUMBER_UNSAFE:["替换会把 JSON 数值变成无效数字","缩小规则范围，避免匹配时间戳或结构上限等数值字段"],SCAN_UNIQUE_FAILED:["无法生成唯一的同形替换值","命中内容过短或可选空间过小，请匹配更长内容或设置固定 replacement"],SCAN_ZERO_WIDTH:["正则产生零宽匹配","修改指定规则，要求非空匹配"],SCAN_MATCH_LIMIT:["单次请求匹配次数过多","缩小过宽规则或减少输入"],SCAN_MAPPING_LIMIT:["映射数量达到上限","新建会话或重载，内存映射将重置"],FIXED_MAPPING_CONFLICT:["同一原文存在冲突替换","为重叠匹配器使用同一目标后重载"],FIXED_ALIAS_REUSED:["固定别名已映射其他原文","固定正则在同一实例仅代表一种原文，改用随机替换或拆分字面规则"],FIXED_SENSITIVE_TARGET:["替换目标包含命中原文","选择不含敏感内容的目标"],FIXED_OVERLAP:["固定替换与其他匹配部分重叠","消除部分重叠或改用随机规则，rule 与 otherRule 指出两条规则"],FIXED_ALIAS_CROSSING:["正则跨越已学习的固定别名","缩小正则范围或更换别名"],SCAN_COMPLEXITY:["请求超过层级或节点上限","减少嵌套数据和工具结构体积"],SCAN_JSON_REWRITE:["替换破坏内嵌 JSON 语法","避免跨 JSON 语法的规则，改为匹配字段值"],SCAN_ATTACHMENT:["不支持图片、音频、视频或文件内容","移除附件或仅发送已审查的文本"],SCAN_KEY_COLLISION:["替换后对象键重复","使用不同目标或避免匹配结构键"],RESTORE_COMPLEXITY:["还原响应时层级过深","减少嵌套结构，或使用 /new 开始新会话"],RESTORE_KEY_COLLISION:["还原后对象键重复","使用更具体的规则或固定替换目标，避免与结构键冲突"],AUDIT_BATCH_LIMIT:["审计批次超过上限","减少单个请求的命中内容"],AUDIT_FULL:["审计日志将超过上限","检查记录后清空日志或本地归档"],AUDIT_PARTIAL:["审计日志末行不完整","本地检查或清空日志，不要上传日志"],AUDIT_LOCKED:["审计锁持续被占用","等待写入完成，全部停止后再检查残留锁"],AUDIT_UNSAFE:["审计文件不安全","使用本人普通文件且不含链接，不会绕过检查"],AUDIT_IO:["审计文件操作失败","检查错误码、权限和磁盘空间，不暴露路径或内容"]},q={blockedHeader:"SPI Protecter blocked this request",reasonLabel:"Reason",actionLabel:"Action",detailsLabel:"Details",statusReady:"ready",statusNotReady:"not ready",statusLine:"SPI Protecter: {state}; {rules}; {mappings}. Memory snapshot; /reload to refresh.",statusLastBlock:"Last block @ {at}:",statusNoBlock:"No recorded block in this session.",statusBarRules:"SPI Protecter · {rules}",statusBarNotReady:"SPI Protecter · not ready",emptyRules:"SPI Protecter: no rules configured; edit the local machine config, then /reload.",commandDescription:"View local SPI protection records",usage:"Usage: /protecter [logs [1-100|clear]|status|reload]. Never type secrets as arguments.",logsTuiOnly:"Open the local TUI to view protection records.",logsNone:"No readable records.",logsSelectTitle:"Protection records",logsTruncated:" (limited tail)",logsRevealTitle:"Sensitive plaintext",logsRevealBody:"Reveal locally? Never share this view.",logsPreviewTitle:"Local preview; edits are discarded",logsPreviewTruncated:"[Preview truncated]",clearTitle:"Clear the current audit log?",clearBody:"Irreversible. Only this machine's log is cleared; configuration and in-memory mappings stay. Later requests may add new records.",cleared:"Audit log cleared: {bytes}.",toolBlocked:"SPI Protecter blocked tool access to the protected configuration or audit log; edit it locally.",compactUnsupported:"SPI Protecter does not support remote context compaction yet; use /new to start a new session."},Ae={blockedHeader:"SPI Protecter 已阻止该请求",reasonLabel:"原因",actionLabel:"处理",detailsLabel:"详情",statusReady:"就绪",statusNotReady:"未就绪",statusLine:"SPI Protecter：{state}；{rules}；{mappings}。内存快照，重载后更新。",statusLastBlock:"最近一次拦截 @ {at}：",statusNoBlock:"本会话暂无拦截记录。",statusBarRules:"SPI Protecter · {rules}",statusBarNotReady:"SPI Protecter · 未就绪",emptyRules:"SPI Protecter：尚未配置规则，请编辑本地机器配置后重载。",commandDescription:"查看本地保护记录",usage:"用法：/protecter [logs [1-100|clear]|status|reload]。不要在参数中输入敏感内容。",logsTuiOnly:"请在本地 TUI 查看保护记录。",logsNone:"暂无可读记录。",logsSelectTitle:"保护记录",logsTruncated:"（仅显示有限尾部）",logsRevealTitle:"敏感明文",logsRevealBody:"确认在本地显示？请勿分享此界面。",logsPreviewTitle:"本地预览，编辑不会保存",logsPreviewTruncated:"[预览已截断]",clearTitle:"确认清空当前审计日志？",clearBody:"不可撤销。仅清空本机日志，配置和内存映射保留；后续请求可能写入新记录。",cleared:"已清空审计日志：{bytes}。",toolBlocked:"SPI Protecter 已阻止工具访问受保护的配置或审计日志，请在本地编辑。",compactUnsupported:"SPI Protecter 暂不支持远程上下文压缩，请使用 /new 开始新会话。"};function H(n=process.env){let e=n.PI_PROTECTER_LANG||n.LC_ALL||n.LC_MESSAGES||n.LANG||n.LANGUAGE||Se();return/^zh\b|^zh[-_]/i.test(e.trim())?"zh":"en"}function Se(){try{return new Intl.DateTimeFormat().resolvedOptions().locale}catch{return""}}var _=H();function V(){return _}function Q(n){_=n}function m(n,e={}){return((_==="zh"?Ae:q)[n]??q[n]).replace(/\{(\w+)\}/g,(t,o)=>Object.hasOwn(e,o)?String(e[o]):t)}var Te={en:{rules:{one:"{n} rule",other:"{n} rules"},mappings:{one:"{n} mapping",other:"{n} mappings"},bytes:{one:"{n} byte",other:"{n} bytes"}},zh:{rules:{other:"规则 {n} 条"},mappings:{other:"映射 {n} 个"},bytes:{other:"{n} 字节"}}},Z=new Map;function R(n,e){let r=_==="zh"?"zh-CN":"en",t=Z.get(_);if(!t){try{t=new Intl.PluralRules(r)}catch{t=void 0}t&&Z.set(_,t)}let o=t?.select(e)??"other",s=Te[_][n],l=s[o]??s.other,i=new Intl.NumberFormat(r).format(e);return l.replace("{n}",i)}function ee(n){let r=(_==="zh"?_e[n]:z[n])??z[n]??z.INTERNAL;return{reason:r[0],action:r[1]}}var te={INTERNAL:"internal",NOT_READY:"initialization",UNSUPPORTED_PI:"initialization",MACHINE_ID:"initialization",CONFIG_JSON:"configuration",CONFIG_SCHEMA:"configuration",CONFIG_REGEX:"configuration",CONFIG_TARGET:"configuration",CONFIG_CONFLICT:"configuration",CONFIG_SIZE:"configuration",CONFIG_IO:"configuration",CONFIG_UNSAFE:"configuration",CONFIG_EMPTY_MATCH:"configuration",CONFIG_SENSITIVE_TARGET:"configuration",CONFIG_ALIAS_CONFLICT:"configuration",CONFIG_TIMEOUT:"configuration",MIGRATION_LOCKED:"migration",MIGRATION_CHANGED:"migration",MIGRATION_LIMIT:"migration",MIGRATION_IO:"migration",PAYLOAD_JSON:"request",PAYLOAD_SIZE:"request",SCAN_TIMEOUT:"scan",WORKER_FAILED:"worker",SCAN_INTERNAL:"scan",SCAN_NUMBER_UNSAFE:"scan",SCAN_UNIQUE_FAILED:"scan",SCAN_ZERO_WIDTH:"scan",SCAN_MATCH_LIMIT:"scan",SCAN_MAPPING_LIMIT:"scan",FIXED_MAPPING_CONFLICT:"scan",FIXED_ALIAS_REUSED:"scan",FIXED_SENSITIVE_TARGET:"scan",FIXED_OVERLAP:"scan",FIXED_ALIAS_CROSSING:"scan",SCAN_COMPLEXITY:"scan",SCAN_JSON_REWRITE:"scan",SCAN_ATTACHMENT:"scan",SCAN_KEY_COLLISION:"scan",RESTORE_COMPLEXITY:"restore",RESTORE_KEY_COLLISION:"restore",AUDIT_BATCH_LIMIT:"audit",AUDIT_FULL:"audit",AUDIT_PARTIAL:"audit",AUDIT_LOCKED:"audit",AUDIT_UNSAFE:"audit",AUDIT_IO:"audit"},re=["rule","otherRule","node","bytes","limit","timeoutMs"],Ce=/^(EACCES|EPERM|ENOENT|ENOSPC|EDQUOT|EROFS|ELOOP|EISDIR|ENOTDIR|EMFILE|ENFILE|EIO|EEXIST|EBADF|EBUSY|ENOTEMPTY)$/;function we(n,e={}){let{reason:r,action:t}=ee(n),o={};for(let s of re){let l=e[s];typeof l=="number"&&Number.isSafeInteger(l)&&l>=0&&(o[s]=l)}return typeof e.errno=="string"&&Ce.test(e.errno)&&(o.errno=e.errno),{code:n,stage:te[n],reason:r,action:t,...o}}function S(n){let e=V()==="zh"?"：":": ",r=[...re,"errno"].filter(t=>n[t]!==void 0).map(t=>`${t}=${n[t]}`).join(" ");return[m("blockedHeader"),`code=${n.code} stage=${n.stage}${r?` ${r}`:""}`,`${m("reasonLabel")}${e}${n.reason}`,`${m("actionLabel")}${e}${n.action}`,`${m("detailsLabel")}${e}/protecter status`].join(`
+`)}var A=class extends Error{diagnostic;constructor(e,r={}){let t=we(e,r);super(S(t)),this.name="ProtectionError",this.diagnostic=t}};function a(n,e={}){return new A(n,e)}function y(n,e,r={}){if(n instanceof A)return a(n.diagnostic.code,{...n.diagnostic,...r});let t=n&&typeof n=="object"&&"code"in n?n.code:void 0;return a(e,{...r,errno:typeof t=="string"?t:void 0})}function b(n,e){if(!n||typeof n!="object")return a(e);let r=n,t=typeof r.code=="string"&&Object.hasOwn(te,r.code)?r.code:e;return a(t,r)}import{constants as T,closeSync as ne,fchmodSync as Re,fstatSync as De,mkdirSync as Le,openSync as oe,readFileSync as Fe,writeFileSync as Pe}from"node:fs";import{dirname as be}from"node:path";var J={version:1,sensitiveWords:[]};function B(n){let e;try{e=JSON.parse(n)}catch{throw a("CONFIG_JSON")}let r=0;try{if(!e||e.version!==1||!Array.isArray(e.sensitiveWords)||Object.keys(e).some(o=>!["version","sensitiveWords"].includes(o)))throw a("CONFIG_SCHEMA");if(e.sensitiveWords.length>1e3)throw a("CONFIG_SIZE",{limit:1e3});let t=new Map;for(let o of e.sensitiveWords){if(r++,typeof o=="string"){if(!o||o.length>8192)throw a("CONFIG_SCHEMA",{rule:r,limit:8192});let l=JSON.stringify(["literal",o]);if(t.has(l)&&t.get(l)!==void 0)throw a("CONFIG_CONFLICT",{rule:r});t.set(l,void 0);continue}if(!o||typeof o!="object")throw a("CONFIG_SCHEMA",{rule:r});if(Object.hasOwn(o,"replacement")&&(typeof o.replacement!="string"||!o.replacement.trim()||o.replacement.length>8192||o.replacement.includes("__PIP_")))throw a("CONFIG_TARGET",{rule:r,limit:8192});if(o.type==="literal"){if(Object.keys(o).some(l=>!["type","value","replacement"].includes(l))||typeof o.value!="string"||!o.value||o.value.length>8192)throw a("CONFIG_SCHEMA",{rule:r,limit:8192})}else if(o.type==="regex"){if(Object.keys(o).some(l=>!["type","pattern","flags","replacement"].includes(l))||typeof o.pattern!="string"||!o.pattern||o.pattern.length>8192||o.flags!==void 0&&(typeof o.flags!="string"||!/^[gimsu]*$/.test(o.flags)))throw a("CONFIG_REGEX",{rule:r,limit:8192});try{new RegExp(o.pattern,o.flags??"")}catch{throw a("CONFIG_REGEX",{rule:r})}}else throw a("CONFIG_SCHEMA",{rule:r});let s=o.type==="literal"?JSON.stringify(["literal",o.value]):JSON.stringify(["regex",o.pattern,[...new Set((o.flags??"")+"g")].sort().join("")]);if(t.has(s)&&t.get(s)!==o.replacement)throw a("CONFIG_CONFLICT",{rule:r});t.set(s,o.replacement)}return e}catch(t){throw t instanceof A?t:a("CONFIG_SCHEMA",{rule:r})}}function ie(n,e=!1){let r;try{if(e){Le(be(n),{recursive:!0,mode:448});try{let s=oe(n,T.O_WRONLY|T.O_CREAT|T.O_EXCL,384);try{Pe(s,JSON.stringify(J,null,2)+`
+`)}finally{ne(s)}}catch(s){if(s.code!=="EEXIST")throw y(s,"CONFIG_IO")}}r=oe(n,T.O_RDONLY|T.O_NOFOLLOW|T.O_NONBLOCK);let t=De(r);if(t.size>1024*1024)throw a("CONFIG_SIZE",{bytes:t.size,limit:1024*1024});if(!t.isFile()||t.nlink!==1||process.getuid&&t.uid!==process.getuid())throw a("CONFIG_UNSAFE");process.platform!=="win32"&&Re(r,384);let o=Fe(r,"utf8");if(Buffer.byteLength(o)>1024*1024)throw a("CONFIG_SIZE",{bytes:Buffer.byteLength(o),limit:1024*1024});return{config:B(o),raw:o}}catch(t){let o=t&&typeof t=="object"&&"code"in t?t.code:void 0;throw y(t,o==="ELOOP"||o==="EISDIR"||o==="ENOTDIR"?"CONFIG_UNSAFE":"CONFIG_IO")}finally{r!==void 0&&ne(r)}}var Y=/^protecter(?:\.[a-f0-9]{32})?\.json$/;function xe(n){return new Promise((e,r)=>{let t=new ve(Ue(new URL("./validate-worker.mjs",import.meta.url)),{workerData:n,execArgv:[],resourceLimits:{maxOldGenerationSizeMb:64}}),o=!1,s=(i,c=a("WORKER_FAILED"))=>{o||(o=!0,clearTimeout(l),t.terminate(),i?e():r(c))},l=setTimeout(()=>s(!1,a("CONFIG_TIMEOUT",{timeoutMs:2e3})),2e3);t.once("message",i=>i===!0?s(!0):s(!1,b(i,"CONFIG_SCHEMA"))),t.once("error",()=>s(!1)),t.once("exit",()=>s(!1))})}function ze(n){let e=new Set,r=[];for(let o of n)for(let s of o.sensitiveWords){let l=typeof s=="string"?JSON.stringify(["literal",s,null]):s.type==="literal"?JSON.stringify(["literal",s.value,s.replacement??null]):JSON.stringify(["regex",s.pattern,[...new Set((s.flags??"")+"g")].sort().join(""),s.replacement??null]);e.has(l)||(e.add(l),r.push(s))}let t=JSON.stringify({version:1,sensitiveWords:r});if(Buffer.byteLength(t)>1024*1024)throw a("CONFIG_SIZE",{bytes:Buffer.byteLength(t),limit:1024*1024});return B(t)}function se(n){let e;try{e=d.lstatSync(n,{bigint:!0})}catch(r){throw y(r,"CONFIG_IO")}if(!e.isFile()||e.nlink!==1n||process.getuid&&e.uid!==BigInt(process.getuid()))throw a("CONFIG_UNSAFE");return`${e.dev}:${e.ino}:${e.size}:${e.mtimeNs}`}function $(n,e){let r=C(n,e),t=se(r),o=ie(r);if(se(r)!==t)throw a("MIGRATION_CHANGED");return{name:e,...o,identity:t,digest:Me("sha256").update(o.raw).digest("hex")}}function D(n,e){let r=$(n,e.name);if(r.identity!==e.identity||r.digest!==e.digest)throw a("MIGRATION_CHANGED")}function G(n){return d.readdirSync(n).filter(e=>Y.test(e)).sort()}function ae(n){if(process.platform==="win32")return;let e=d.openSync(n,d.constants.O_RDONLY);try{d.fsyncSync(e)}finally{d.closeSync(e)}}async function ce(n,e,r={}){if(!/^[a-f0-9]{32}$/.test(e))throw a("MACHINE_ID");let t=Ge(n),o=`protecter.${e}.json`,s=C(t,o);d.mkdirSync(t,{recursive:!0,mode:448});let l=C(t,".protecter-migration.lock"),i=Date.now()+(r.lockTimeoutMs??5e3);for(;;)try{d.mkdirSync(l,{mode:448});break}catch(u){if(u.code!=="EEXIST")throw y(u,"MIGRATION_IO");if(Date.now()>=i)throw a("MIGRATION_LOCKED",{timeoutMs:r.lockTimeoutMs??5e3});await new Promise(O=>setTimeout(O,50))}let c;try{let u=G(t);if(u.length>64)throw a("MIGRATION_LIMIT",{limit:64});let g=[...u].sort((I,w)=>I===o?-1:w===o?1:I.localeCompare(w)).map(I=>$(t,I)),h=ze(g.length?g.map(I=>I.config):[J]);if(await xe([h]),g.length===1&&g[0].name===o){if(D(t,g[0]),JSON.stringify(G(t))!==JSON.stringify(u))throw a("MIGRATION_CHANGED");return{path:s,config:g[0].config,raw:g[0].raw,sourceRaws:[g[0].raw],migrated:0}}let p=JSON.stringify(h,null,2)+`
+`;if(Buffer.byteLength(p)>1024*1024)throw a("CONFIG_SIZE",{bytes:Buffer.byteLength(p),limit:1024*1024});c=C(t,`.protecter-migration.${ke()}.tmp`);let N=d.openSync(c,d.constants.O_WRONLY|d.constants.O_CREAT|d.constants.O_EXCL,384);try{d.writeFileSync(N,p),d.fsyncSync(N)}finally{d.closeSync(N)}if(r.checkpoint?.("beforeCommit",s),JSON.stringify(G(t))!==JSON.stringify(u))throw a("MIGRATION_CHANGED");for(let I of g)D(t,I);d.renameSync(c,s),c=void 0,ae(t);let E=$(t,o);if(E.raw!==p)throw a("MIGRATION_CHANGED");r.checkpoint?.("afterCommit",s);for(let I of g)I.name!==o&&(r.checkpoint?.("beforeDelete",C(t,I.name)),D(t,E),D(t,I),d.unlinkSync(C(t,I.name)));ae(t);let F=[o];if(JSON.stringify(G(t))!==JSON.stringify(F))throw a("MIGRATION_CHANGED");return D(t,E),{path:s,config:h,raw:p,sourceRaws:[...new Set([...g.map(I=>I.raw),p])],migrated:g.filter(I=>I.name!==o).length}}catch(u){throw u instanceof A?u:y(u,"MIGRATION_IO")}finally{if(c)try{d.unlinkSync(c)}catch{}d.rmdirSync(l)}}import{createHash as He}from"node:crypto";import{readFileSync as Je}from"node:fs";import{execFileSync as le}from"node:child_process";function W(n){let e=n.trim().toLowerCase().replace(/-/g,"");if(!/^[a-f0-9]{32}$/.test(e)||/^0+$/.test(e))throw a("MACHINE_ID");return He("sha256").update(`pi-information-protecter:v1:${e}`).digest("hex").slice(0,32)}function ue(){try{if(process.platform==="linux")return W(Je("/etc/machine-id","utf8"));if(process.platform==="darwin"){let n=le("/usr/sbin/ioreg",["-rd1","-c","IOPlatformExpertDevice"],{encoding:"utf8",timeout:5e3,maxBuffer:1048576,stdio:["ignore","pipe","pipe"]});return W(n.match(/"IOPlatformUUID"\s*=\s*"([a-fA-F0-9-]+)"/)?.[1]??"")}if(process.platform==="win32"){let n=le("reg.exe",["query","HKLM\\SOFTWARE\\Microsoft\\Cryptography","/v","MachineGuid","/reg:64"],{encoding:"utf8",timeout:5e3,maxBuffer:65536,stdio:["ignore","pipe","pipe"]});return W(n.match(/MachineGuid\s+REG_SZ\s+([a-fA-F0-9-]+)/i)?.[1]??"")}}catch{}throw a("MACHINE_ID")}import*as f from"node:fs";import{randomUUID as Be}from"node:crypto";var fe=32*1024*1024,de=8*1024*1024;function $e(n){let e=r=>String(r).padStart(2,"0");return`${n.getFullYear()}-${e(n.getMonth()+1)}-${e(n.getDate())} ${e(n.getHours())}:${e(n.getMinutes())}:${e(n.getSeconds())}`}function X(n,e,r=e){let t=f.openSync(n,(e?f.constants.O_RDWR|(r?f.constants.O_CREAT:0):f.constants.O_RDONLY)|f.constants.O_NOFOLLOW|f.constants.O_NONBLOCK,384);try{let o=f.fstatSync(t);if(!o.isFile()||o.nlink!==1||process.getuid&&o.uid!==process.getuid())throw a("AUDIT_UNSAFE");return process.platform!=="win32"&&f.fchmodSync(t,384),t}catch(o){throw f.closeSync(t),y(o,"AUDIT_UNSAFE")}}function M(n){let e=n&&typeof n=="object"&&"code"in n?n.code:void 0;return y(n,e==="ELOOP"||e==="EISDIR"||e==="ENOTDIR"?"AUDIT_UNSAFE":"AUDIT_IO")}async function ge(n){let e=`${n}.lock`,r=Date.now()+2e3;for(;;)try{return f.mkdirSync(e,{mode:448}),e}catch(t){if(t.code!=="EEXIST")throw y(t,"AUDIT_IO");if(Date.now()>=r)throw a("AUDIT_LOCKED",{timeoutMs:2e3});await new Promise(o=>setTimeout(o,25))}}async function me(n){let e=await ge(n),r;try{try{r=X(n,!0,!1)}catch(o){if(o.code==="ENOENT")return 0;throw o}let t=f.fstatSync(r).size;return f.ftruncateSync(r,0),f.fsyncSync(r),t}catch(t){throw M(t)}finally{try{r!==void 0&&f.closeSync(r)}finally{f.rmdirSync(e)}}}async function pe(n,e,r){if(!r.length)return;let t=new Date,o=Be(),s=Buffer.from(r.map(([c,u])=>JSON.stringify({version:1,time:$e(t),timezoneOffset:-t.getTimezoneOffset(),requestId:o,provider:e||"unknown",original:u,replacement:c})).join(`
 `)+`
-`);if(o.length>te)throw c("AUDIT_BATCH_LIMIT",{bytes:o.length,limit:te});let f=await re(n),s;try{s=$(n,!0);let a=d.fstatSync(s).size;if(a+o.length>ee)throw c("AUDIT_FULL",{bytes:a+o.length,limit:ee});if(a){let l=Buffer.alloc(1);if(d.readSync(s,l,0,1,a-1),l[0]!==10)throw c("AUDIT_PARTIAL")}try{let l=0;for(;l<o.length;){let O=d.writeSync(s,o,l,o.length-l,a+l);if(!O)throw c("AUDIT_IO");l+=O}d.fsyncSync(s)}catch(l){throw d.ftruncateSync(s,a),d.fsyncSync(s),b(l)}}catch(a){throw b(a)}finally{s!==void 0&&d.closeSync(s),d.rmdirSync(f)}}function oe(n,e=20){if(!Number.isInteger(e)||e<1||e>100)throw c("INTERNAL",{limit:100});let t;try{try{t=$(n,!1)}catch(p){if(p.code==="ENOENT")return{records:[],truncated:!1};throw p}let r=d.fstatSync(t).size,i=Math.max(0,r-1024*1024),o=Buffer.alloc(r-i),f=d.readSync(t,o,0,o.length,i),s=o.subarray(0,f).toString("utf8");if(i){let p=s.indexOf(`
-`);s=p<0?"":s.slice(p+1)}let a=s.split(`
-`),l=a.pop()!=="",O=[],u=!1;for(let p of a.slice(-e))try{let m=JSON.parse(p);if(m.version!==1||typeof m.time!="string"||typeof m.provider!="string"||typeof m.original!="string"||typeof m.replacement!="string"||typeof m.requestId!="string"||typeof m.timezoneOffset!="number")throw new Error;O.push(m)}catch{u=!0}return{records:O,truncated:i>0||a.length>e||l||u}}catch(r){throw b(r)}finally{t!==void 0&&d.closeSync(t)}}var x=class{constructor(e,t=2e3,r=Q){this.configDir=e;this.timeoutMs=t;this.machineId=r}configDir;timeoutMs;machineId;tokens=new Map;queue=Promise.resolve();workers=new Set;closed=!1;snapshot;lastError;get lastDiagnostic(){return this.lastError?{...this.lastError}:void 0}get lastDiagnosticText(){return this.lastError?S(this.lastError):void 0}async initialize(){try{if(this.closed)throw c("NOT_READY");this.snapshot=void 0;let e;try{e=this.machineId()}catch{throw c("MACHINE_ID")}let t=await K(this.configDir,e);if(this.closed)throw c("NOT_READY");this.snapshot=t,this.lastError=void 0}catch(e){let t=y(e,"CONFIG_IO");throw this.lastError=t.diagnostic,t}}get configPath(){return this.snapshot?.path??""}get auditPath(){return this.configPath?this.configPath.replace(/\.json$/,".jsonl"):""}auditRecords(e=20){if(!this.ready)throw this.notReady();return oe(this.auditPath,e)}clearAuditRecords(){let e=this.queue.then(()=>{if(!this.ready)throw this.notReady();return ne(this.auditPath)});return this.queue=e.catch(()=>{}),e}get ruleCount(){return this.snapshot?.config.sensitiveWords.length??0}get ready(){return!!this.snapshot&&!this.closed}get mappingCount(){return this.tokens.size}redact(e,t="unknown"){let r=this.queue.then(()=>this.scan(e,t)).catch(i=>{let o=y(i,"INTERNAL");throw this.lastError=o.diagnostic,o});return this.queue=r.catch(()=>{}),r}notReady(){return this.lastError?c(this.lastError.code,this.lastError):c("NOT_READY")}async scan(e,t){if(!this.ready)throw this.notReady();let{config:r,sourceRaws:i}=this.snapshot,o;try{o=JSON.stringify(e)}catch{throw c("PAYLOAD_JSON")}if(!o)throw c("PAYLOAD_JSON");if(Buffer.byteLength(o)>8*1024*1024)throw c("PAYLOAD_SIZE",{bytes:Buffer.byteLength(o),limit:8*1024*1024});let f;try{f=JSON.parse(o)}catch{throw c("PAYLOAD_JSON")}let s=await new Promise((a,l)=>{let O=!1,u;try{u=new ke(be(new URL("./scan-worker.mjs",import.meta.url)),{workerData:{payload:f,rules:r.sensitiveWords,entries:[...this.tokens],configRaws:i},execArgv:[],resourceLimits:{maxOldGenerationSizeMb:128}})}catch(I){l(y(I,"WORKER_FAILED"));return}this.workers.add(u);let p=(I,w=c("WORKER_FAILED"))=>{if(!O){if(O=!0,clearTimeout(m),this.workers.delete(u),u.terminate(),!I||this.closed){l(this.closed?c("NOT_READY"):w);return}a(I)}},m=setTimeout(()=>p(void 0,c("SCAN_TIMEOUT",{timeoutMs:this.timeoutMs})),this.timeoutMs);u.once("message",I=>{I?.failed?p(void 0,D(I.diagnostic,"SCAN_INTERNAL")):I&&Array.isArray(I.additions)&&Array.isArray(I.hits)?p(I):p()}),u.once("error",()=>p()),u.once("exit",()=>p())});if(this.closed)throw c("NOT_READY");if(await ie(this.auditPath,t,s.hits),this.closed)throw c("NOT_READY");for(let[a,l]of s.additions)this.tokens.set(a,l);return s.payload}restoreText(e){let t=o=>o.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),r=[...this.tokens.keys()].filter(o=>!/^__PIP_[a-f0-9]{48}__$/.test(o)),i=new RegExp(["__PIP_[a-f0-9]{48}__",...r.sort((o,f)=>f.length-o.length).map(t)].join("|"),"g");return e.replace(i,o=>this.tokens.get(o)??o)}restore(e,t=0){if(t>80)throw new Error("protecter: 响应层级过深。");if(typeof e=="string")return this.restoreText(e);if(Array.isArray(e))return e.map(r=>this.restore(r,t+1));if(e&&typeof e=="object"){let r=Object.create(null);for(let[i,o]of Object.entries(e)){let f=this.restoreText(i);if(Object.hasOwn(r,f))throw new Error("protecter: 响应键冲突。");r[f]=this.restore(o,t+1)}return r}return e}close(){this.closed=!0,this.snapshot=void 0,this.tokens.clear();for(let e of this.workers)e.terminate();this.workers.clear()}};import{realpathSync as xe,statSync as se,readdirSync as ve}from"node:fs";import{homedir as Pe}from"node:os";import{basename as J,dirname as T,isAbsolute as Fe,relative as ce,resolve as v}from"node:path";import{fileURLToPath as Le}from"node:url";function Me(n,e){let t=n.replace(/^@/,"");return t.startsWith("file://")&&(t=Le(t)),(t==="~"||t.startsWith("~/"))&&(t=Pe()+t.slice(1)),v(e,t)}function z(n){try{return xe(n)}catch{let e=T(n);return e===n?n:v(z(e),ce(e,n))}}function Ge(n,e){let t=ce(n,e);return t===""||!t.startsWith("..")&&!Fe(t)}function ae(n,e){try{let t=se(n),r=se(e);return t.dev===r.dev&&t.ino===r.ino}catch{return!1}}function fe(n,e,t,r){if(!r)return!0;let i=z(v(r));if(["bash","powershell"].includes(n)){let s=typeof e.command=="string"?e.command:"";if(/protecter(?:\.[a-f0-9]{32})?\.jsonl?|\.protecter-migration/i.test(s)||s.includes(r))return!0}let o=e.path??e.file_path??e.filePath,f=["grep","find","ls"].includes(n);if(typeof o!="string"&&!f)return!1;try{let s=Me(typeof o=="string"?o:".",t),a=z(s),l=/^protecter\.[a-f0-9]{32}\.jsonl(?:\.lock)?$/,O=ve(T(i)).filter(u=>l.test(u)).some(u=>ae(s,v(T(i),u)));return T(a)===T(i)&&(G.test(J(a))||l.test(J(a))||J(a).startsWith(".protecter-migration"))||a===i||ae(s,r)||O||f&&Ge(a,i)}catch{return!0}}function $e(n){let e=new x(Ue()),t=/^0\.85\./.test(le)&&Number(le.split(".")[2])>=1,r=!1,i,o=f=>{let s=S(f);return i={at:new Date().toISOString(),text:s},s};n.on("session_start",async(f,s)=>{try{if(!t)throw c("UNSUPPORTED_PI");await e.initialize(),r=!0;let a=e.ruleCount;s.ui.setStatus("protecter",`SPI Protecter · ${a} rules`),a===0&&s.ui.notify("SPI Protecter: empty rules; edit local machine config and /reload / 规则为空，请编辑本地机器配置后重载。","warning")}catch(a){r=!1,s.ui.setStatus("protecter","SPI Protecter · not ready / 未就绪"),s.ui.notify(o(y(a,"CONFIG_IO").diagnostic),"error")}}),n.on("before_provider_request",async(f,s)=>{try{if(!t)throw c("UNSUPPORTED_PI");let a=await e.redact(f.payload,s.model?.provider??"unknown");return r=!0,a}catch(a){r=!1;let l=o(y(a,"INTERNAL").diagnostic);try{await s.abort()}catch{}try{s.ui.notify(l,"error")}catch{}return{}}}),n.on("message_end",f=>{if(f.message.role!=="assistant")return;let s=f.message;return{message:{...s,content:s.content.map(a=>a.type==="text"?{...a,text:e.restoreText(a.text)}:a.type==="thinking"?{...a,thinking:e.restoreText(a.thinking)}:a.type==="toolCall"?{...a,arguments:e.restore(a.arguments)}:a),...s.errorMessage?{errorMessage:e.restoreText(s.errorMessage)}:{}}}}),n.registerMarkdownTransformer((f,s)=>s.messageType==="user"?f:e.restoreText(f)),n.on("tool_call",(f,s)=>{if(!r)return{block:!0,reason:e.lastDiagnosticText??i?.text??S(c("NOT_READY").diagnostic)};let a=e.restore(f.input);for(let l of Object.keys(f.input))delete f.input[l];if(Object.assign(f.input,a),fe(f.toolName,f.input,s.cwd,e.configPath))return{block:!0,reason:"SPI Protecter blocked tool access to the protected configuration or audit log; edit it locally / 禁止工具访问受保护的配置或审计日志，请用户在本地编辑。"}}),n.on("session_before_compact",(f,s)=>(s.ui.notify("SPI Protecter：暂不支持远程上下文压缩，请使用 /new 开始新会话。","warning"),{cancel:!0})),n.on("session_before_tree",f=>f.preparation.userWantsSummary?{cancel:!0}:void 0),n.registerCommand("protecter",{description:"View local protection records / 查看本地保护记录",handler:async(f,s)=>{let a=f.trim().split(/\s+/).filter(Boolean),l=a[0]??"logs";if(!["status","reload","logs"].includes(l)||l!=="logs"&&a.length>1||a.length>2||a[1]!==void 0&&a[1]!=="clear"&&!/^(?:[1-9]\d?|100)$/.test(a[1])){s.ui.notify("Usage / 用法: /protecter [logs [1-100|clear]|status|reload]. No secrets in arguments / 不要在参数中输入秘密。","info");return}if(l==="logs"){if(s.mode!=="tui"){s.ui.notify("Local TUI required / 请在本地 TUI 查看记录。","warning");return}if(a[1]==="clear"){try{if(!e.ready)throw new Error;if(!await s.ui.confirm("Clear current audit log? / 清空当前审计日志？","Irreversible. Only this machine's log; config and mappings stay. Later requests may add records. / 不可撤销，仅清空本机日志，保留配置和映射，后续请求可能新增记录。"))return;await s.waitForIdle();let u=await e.clearAuditRecords();r=e.ready,s.ui.notify(`Audit cleared: ${u} bytes / 已清空日志：${u} 字节。`,"info")}catch(u){s.ui.notify(o(y(u,"AUDIT_IO").diagnostic),"error")}return}try{let{records:u,truncated:p}=e.auditRecords(Number(a[1]??20));if(!u.length){s.ui.notify("No readable records / 暂无可读记录。","info");return}let m=E=>JSON.stringify(E).replace(/[\u007f-\u009f\u202a-\u202e\u2066-\u2069]/g,P=>`\\u${P.charCodeAt(0).toString(16).padStart(4,"0")}`),I=u.map((E,P)=>`${P+1}. ${m(E.time)} | ${m(E.provider).slice(0,120)}`),w=await s.ui.select(`Protection records / 保护记录${p?" (limited tail / 有限尾部)":""}`,I),R=w===void 0?-1:I.indexOf(w);if(R<0||!await s.ui.confirm("Sensitive plaintext / 敏感明文","Reveal locally? Never share this view / 确认本地显示？请勿分享此界面。"))return;let h=m(u[R]);await s.ui.editor("Local preview; edits discarded / 本地预览，编辑不保存",h.length>2e4?h.slice(0,2e4)+`
-[Preview truncated / 预览截断]`:h)}catch(u){s.ui.notify(o(y(u,"AUDIT_IO").diagnostic),"error")}return}if(l==="reload"){await s.waitForIdle(),await s.reload();return}let O=e.lastDiagnosticText??i?.text;s.ui.notify([`SPI Protecter: ${e.ready?"ready / 就绪":"not ready / 未就绪"}; ${e.ruleCount} rules / 规则; ${e.mappingCount} mappings / 映射. Memory snapshot; /reload to refresh / 内存快照，重载后更新。`,O?`
-Last block / 最近拦截${i?` @ ${i.at}`:""}:
+`);if(s.length>de)throw a("AUDIT_BATCH_LIMIT",{bytes:s.length,limit:de});let l=await ge(n),i;try{i=X(n,!0);let c=f.fstatSync(i).size;if(c+s.length>fe)throw a("AUDIT_FULL",{bytes:c+s.length,limit:fe});if(c){let u=Buffer.alloc(1);if(f.readSync(i,u,0,1,c-1),u[0]!==10)throw a("AUDIT_PARTIAL")}try{let u=0;for(;u<s.length;){let O=f.writeSync(i,s,u,s.length-u,c+u);if(!O)throw a("AUDIT_IO");u+=O}f.fsyncSync(i)}catch(u){throw f.ftruncateSync(i,c),f.fsyncSync(i),M(u)}}catch(c){throw M(c)}finally{i!==void 0&&f.closeSync(i),f.rmdirSync(l)}}function he(n,e=20){if(!Number.isInteger(e)||e<1||e>100)throw a("INTERNAL",{limit:100});let r;try{try{r=X(n,!1)}catch(h){if(h.code==="ENOENT")return{records:[],truncated:!1};throw h}let t=f.fstatSync(r).size,o=Math.max(0,t-1024*1024),s=Buffer.alloc(t-o),l=f.readSync(r,s,0,s.length,o),i=s.subarray(0,l).toString("utf8");if(o){let h=i.indexOf(`
+`);i=h<0?"":i.slice(h+1)}let c=i.split(`
+`),u=c.pop()!=="",O=[],g=!1;for(let h of c.slice(-e))try{let p=JSON.parse(h);if(p.version!==1||typeof p.time!="string"||typeof p.provider!="string"||typeof p.original!="string"||typeof p.replacement!="string"||typeof p.requestId!="string"||typeof p.timezoneOffset!="number")throw new Error;O.push(p)}catch{g=!0}return{records:O,truncated:o>0||c.length>e||u||g}}catch(t){throw M(t)}finally{r!==void 0&&f.closeSync(r)}}var k=class{constructor(e,r=2e3,t=ue){this.configDir=e;this.timeoutMs=r;this.machineId=t}configDir;timeoutMs;machineId;tokens=new Map;queue=Promise.resolve();workers=new Set;closed=!1;snapshot;lastError;restorePattern;restoreSize=-1;get lastDiagnostic(){return this.lastError?{...this.lastError}:void 0}get lastDiagnosticText(){return this.lastError?S(this.lastError):void 0}async initialize(){try{if(this.closed)throw a("NOT_READY");this.snapshot=void 0;let e;try{e=this.machineId()}catch{throw a("MACHINE_ID")}let r=await ce(this.configDir,e);if(this.closed)throw a("NOT_READY");this.snapshot=r,this.lastError=void 0}catch(e){let r=y(e,"CONFIG_IO");throw this.lastError=r.diagnostic,r}}get configPath(){return this.snapshot?.path??""}get auditPath(){return this.configPath?this.configPath.replace(/\.json$/,".jsonl"):""}auditRecords(e=20){if(!this.ready)throw this.notReady();return he(this.auditPath,e)}clearAuditRecords(){let e=this.queue.then(()=>{if(!this.ready)throw this.notReady();return me(this.auditPath)});return this.queue=e.catch(()=>{}),e}get ruleCount(){return this.snapshot?.config.sensitiveWords.length??0}get ready(){return!!this.snapshot&&!this.closed}get mappingCount(){return this.tokens.size}redact(e,r="unknown"){let t=this.queue.then(()=>this.scan(e,r)).catch(o=>{let s=y(o,"INTERNAL");throw this.lastError=s.diagnostic,s});return this.queue=t.catch(()=>{}),t}notReady(){return this.lastError?a(this.lastError.code,this.lastError):a("NOT_READY")}async scan(e,r){if(!this.ready)throw this.notReady();let{config:t,sourceRaws:o}=this.snapshot,s;try{s=JSON.stringify(e)}catch{throw a("PAYLOAD_JSON")}if(!s)throw a("PAYLOAD_JSON");if(Buffer.byteLength(s)>8*1024*1024)throw a("PAYLOAD_SIZE",{bytes:Buffer.byteLength(s),limit:8*1024*1024});let l;try{l=JSON.parse(s)}catch{throw a("PAYLOAD_JSON")}let i=await new Promise((c,u)=>{let O=!1,g;try{g=new Ye(We(new URL("./scan-worker.mjs",import.meta.url)),{workerData:{payload:l,rules:t.sensitiveWords,entries:[...this.tokens],configRaws:o},execArgv:[],resourceLimits:{maxOldGenerationSizeMb:128}})}catch(N){u(y(N,"WORKER_FAILED"));return}this.workers.add(g);let h=(N,E=a("WORKER_FAILED"))=>{if(!O){if(O=!0,clearTimeout(p),this.workers.delete(g),g.terminate(),!N||this.closed){u(this.closed?a("NOT_READY"):E);return}c(N)}},p=setTimeout(()=>h(void 0,a("SCAN_TIMEOUT",{timeoutMs:this.timeoutMs})),this.timeoutMs);g.once("message",N=>{N?.failed?h(void 0,b(N.diagnostic,"SCAN_INTERNAL")):N&&Array.isArray(N.additions)&&Array.isArray(N.hits)?h(N):h()}),g.once("error",()=>h()),g.once("exit",()=>h())});if(this.closed)throw a("NOT_READY");if(await pe(this.auditPath,r,i.hits),this.closed)throw a("NOT_READY");for(let[c,u]of i.additions)this.tokens.set(c,u);return i.payload}restoreText(e){if(!this.tokens.size)return e;if(this.restoreSize!==this.tokens.size){let r=t=>t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&");this.restorePattern=new RegExp([...this.tokens.keys()].sort((t,o)=>o.length-t.length).map(r).join("|"),"g"),this.restoreSize=this.tokens.size}return e.replace(this.restorePattern,r=>this.tokens.get(r)??r)}restore(e,r=0){if(r>80)throw a("RESTORE_COMPLEXITY",{node:r});if(typeof e=="string")return this.restoreText(e);if(Array.isArray(e))return e.map(t=>this.restore(t,r+1));if(e&&typeof e=="object"){let t=Object.create(null);for(let[o,s]of Object.entries(e)){let l=this.restoreText(o);if(Object.hasOwn(t,l))throw a("RESTORE_KEY_COLLISION");t[l]=this.restore(s,r+1)}return t}return e}close(){this.closed=!0,this.snapshot=void 0,this.tokens.clear();for(let e of this.workers)e.terminate();this.workers.clear()}};import{realpathSync as Xe,statSync as Ie,readdirSync as je}from"node:fs";import{homedir as Ke}from"node:os";import{basename as j,dirname as L,isAbsolute as qe,relative as Ne,resolve as v}from"node:path";import{fileURLToPath as Ze}from"node:url";function Ve(n,e){let r=n.replace(/^@/,"");return r.startsWith("file://")&&(r=Ze(r)),(r==="~"||r.startsWith("~/"))&&(r=Ke()+r.slice(1)),v(e,r)}function K(n){try{return Xe(n)}catch{let e=L(n);return e===n?n:v(K(e),Ne(e,n))}}function Qe(n,e){let r=Ne(n,e);return r===""||!r.startsWith("..")&&!qe(r)}function ye(n,e){try{let r=Ie(n),t=Ie(e);return r.dev===t.dev&&r.ino===t.ino}catch{return!1}}function Oe(n,e,r,t){if(!t)return!0;let o=K(v(t));if(["bash","powershell"].includes(n)){let i=typeof e.command=="string"?e.command:"";if(/protecter(?:\.[a-f0-9]{32})?\.jsonl?|\.protecter-migration/i.test(i)||i.includes(t))return!0}let s=e.path??e.file_path??e.filePath,l=["grep","find","ls"].includes(n);if(typeof s!="string"&&!l)return!1;try{let i=Ve(typeof s=="string"?s:".",r),c=K(i),u=/^protecter\.[a-f0-9]{32}\.jsonl(?:\.lock)?$/,O=je(L(o)).filter(g=>u.test(g)).some(g=>ye(i,v(L(o),g)));return L(c)===L(o)&&(Y.test(j(c))||u.test(j(c))||j(c).startsWith(".protecter-migration"))||c===o||ye(i,t)||O||l&&Qe(c,o)}catch{return!0}}function tt(n){Q(H());let e=new k(et()),r=/^0\.85\./.test(Ee)&&Number(Ee.split(".")[2])>=1,t=!1,o,s=l=>{let i=S(l);return o={at:new Date().toISOString(),text:i},i};n.on("session_start",async(l,i)=>{try{if(!r)throw a("UNSUPPORTED_PI");await e.initialize(),t=!0;let c=e.ruleCount;i.ui.setStatus("protecter",m("statusBarRules",{rules:R("rules",c)})),c===0&&i.ui.notify(m("emptyRules"),"warning")}catch(c){t=!1,i.ui.setStatus("protecter",m("statusBarNotReady")),i.ui.notify(s(y(c,"CONFIG_IO").diagnostic),"error")}}),n.on("before_provider_request",async(l,i)=>{try{if(!r)throw a("UNSUPPORTED_PI");let c=await e.redact(l.payload,i.model?.provider??"unknown");return t=!0,c}catch(c){t=!1;let u=s(y(c,"INTERNAL").diagnostic);try{await i.abort()}catch{}try{i.ui.notify(u,"error")}catch{}return{}}}),n.on("message_end",l=>{if(l.message.role!=="assistant")return;let i=l.message;return{message:{...i,content:i.content.map(c=>c.type==="text"?{...c,text:e.restoreText(c.text)}:c.type==="thinking"?{...c,thinking:e.restoreText(c.thinking)}:c.type==="toolCall"?{...c,arguments:e.restore(c.arguments)}:c),...i.errorMessage?{errorMessage:e.restoreText(i.errorMessage)}:{}}}}),n.registerMarkdownTransformer((l,i)=>i.messageType==="user"?l:e.restoreText(l)),n.on("tool_call",(l,i)=>{if(!t)return{block:!0,reason:e.lastDiagnosticText??o?.text??S(a("NOT_READY").diagnostic)};let c=e.restore(l.input);for(let u of Object.keys(l.input))delete l.input[u];if(Object.assign(l.input,c),Oe(l.toolName,l.input,i.cwd,e.configPath))return{block:!0,reason:m("toolBlocked")}}),n.on("session_before_compact",(l,i)=>(i.ui.notify(m("compactUnsupported"),"warning"),{cancel:!0})),n.on("session_before_tree",l=>l.preparation.userWantsSummary?{cancel:!0}:void 0),n.registerCommand("protecter",{description:m("commandDescription"),handler:async(l,i)=>{let c=l.trim().split(/\s+/).filter(Boolean),u=c[0]??"logs";if(!["status","reload","logs"].includes(u)||u!=="logs"&&c.length>1||c.length>2||c[1]!==void 0&&c[1]!=="clear"&&!/^(?:[1-9]\d?|100)$/.test(c[1])){i.ui.notify(m("usage"),"info");return}if(u==="logs"){if(i.mode!=="tui"){i.ui.notify(m("logsTuiOnly"),"warning");return}if(c[1]==="clear"){try{if(!e.ready)throw a("NOT_READY");if(!await i.ui.confirm(m("clearTitle"),m("clearBody")))return;await i.waitForIdle();let p=await e.clearAuditRecords();t=e.ready,i.ui.notify(m("cleared",{bytes:R("bytes",p)}),"info")}catch(p){i.ui.notify(s(y(p,"AUDIT_IO").diagnostic),"error")}return}try{let{records:p,truncated:N}=e.auditRecords(Number(c[1]??20));if(!p.length){i.ui.notify(m("logsNone"),"info");return}let E=P=>JSON.stringify(P).replace(/[\u007f-\u009f\u202a-\u202e\u2066-\u2069]/g,x=>`\\u${x.charCodeAt(0).toString(16).padStart(4,"0")}`),F=p.map((P,x)=>`${x+1}. ${E(P.time)} | ${E(P.provider).slice(0,120)}`),I=await i.ui.select(m("logsSelectTitle")+(N?m("logsTruncated"):""),F),w=I===void 0?-1:F.indexOf(I);if(w<0||!await i.ui.confirm(m("logsRevealTitle"),m("logsRevealBody")))return;let U=E(p[w]);await i.ui.editor(m("logsPreviewTitle"),U.length>2e4?`${U.slice(0,2e4)}
+${m("logsPreviewTruncated")}`:U)}catch(p){i.ui.notify(s(y(p,"AUDIT_IO").diagnostic),"error")}return}if(u==="reload"){await i.waitForIdle(),await i.reload();return}let O=e.lastDiagnosticText??o?.text,g=m("statusLine",{state:m(e.ready?"statusReady":"statusNotReady"),rules:R("rules",e.ruleCount),mappings:R("mappings",e.mappingCount)}),h=O?`
+${m("statusLastBlock",{at:o?.at??""})}
 ${O}`:`
-No recorded block in this session / 本会话暂无拦截记录。`].join(""),e.ready?"info":"error")}}),n.on("session_shutdown",()=>e.close())}export{$e as default};
+${m("statusNoBlock")}`;i.ui.notify(g+h,e.ready?"info":"error")}}),n.on("session_shutdown",()=>e.close())}export{tt as default};

package/dist/scan-worker.mjs

@@ -1,2 +1,2 @@
 /*! SPI Protecter | MIT | see LICENSE / SPI 隐私保护插件 | MIT 许可 */
-import{parentPort as L,workerData as w}from"node:worker_threads";import{randomBytes as b}from"node:crypto";var u,T=0;function f(l,I){throw{code:l,rule:u,otherRule:I,node:T}}try{let x=function(e,r){let t=g.get(e);if(t)return r!==void 0&&t!==r&&f("FIXED_MAPPING_CONFLICT"),t;if(r!==void 0)return d.size>=5e4&&f("SCAN_MAPPING_LIMIT"),d.has(r)&&d.get(r)!==e&&f("FIXED_ALIAS_REUSED"),r.includes(e)&&f("FIXED_SENSITIVE_TARGET"),g.set(e,r),d.set(r,e),N.push([r,e]),r;d.size>=5e4&&f("SCAN_MAPPING_LIMIT");do t=`__PIP_${b(24).toString("hex")}__`;while(d.has(t)||D.includes(t));return g.set(e,t),d.set(t,e),N.push([t,e]),t},m=function(e){let r=[];for(let n of S)if(u=n.rule,n.literal===void 0){n.regex.lastIndex=0;for(let i of e.matchAll(n.regex))i[0].length||f("SCAN_ZERO_WIDTH"),r.push([i.index,i.index+i[0].length,n.replacement,n.rule]),++y>1e5&&f("SCAN_MATCH_LIMIT")}else{if(!n.literal)continue;let i=0;for(;(i=e.indexOf(n.literal,i))!==-1;)r.push([i,i+n.literal.length,n.replacement,n.rule]),++y>1e5&&f("SCAN_MATCH_LIMIT"),i++}r.sort((n,i)=>n[0]-i[0]||i[1]-n[1]);let t=[];for(let n of r){let i=t.at(-1);i&&n[0]<i[1]?((i[2]!==void 0||n[2]!==void 0)&&((i[0]!==n[0]||i[1]!==n[1]||i[2]!==void 0&&n[2]!==void 0&&i[2]!==n[2])&&(u=i[3],f("FIXED_OVERLAP",n[3])),i[2]===void 0&&n[2]!==void 0&&(i[3]=n[3]),i[2]??=n[2]),i[1]=Math.max(i[1],n[1])):t.push([...n])}let s="",c=0;for(let[n,i,o,a]of t){u=a;let _=x(e.slice(n,i),o);C.add(_),s+=e.slice(c,n)+_,c=i}return s+e.slice(c)},p=function(e){let r="",t=0,s=o=>o.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),c=[...d.keys()].filter(o=>!/^__PIP_[a-f0-9]{48}__$/.test(o)),n=new RegExp(["__PIP_[a-f0-9]{48}__",...c.sort((o,a)=>a.length-o.length).map(s)].join("|"),"g"),i=[...e.matchAll(n)].filter(o=>d.has(o[0]));for(let o of S)if(!(!o.regex||!c.length)){u=o.rule,o.regex.lastIndex=0;for(let a of e.matchAll(o.regex))++y>1e5&&f("SCAN_MATCH_LIMIT"),a[0].length||f("SCAN_ZERO_WIDTH"),i.some(_=>c.includes(_[0])&&a.index<_.index+_[0].length&&a.index+a[0].length>_.index)&&f("FIXED_ALIAS_CROSSING")}for(let o of i)d.has(o[0])&&(r+=m(e.slice(t,o.index))+o[0],t=o.index+o[0].length);return r+m(e.slice(t))},A=function(e,r=0){if(T=++M,u=void 0,(M>2e5||r>80)&&f("SCAN_COMPLEXITY"),typeof e=="string"){if(E.some(t=>e.includes(t)))return p(e);if(/^\s*[[{]/.test(e)){let t;try{t=JSON.parse(e)}catch{}if(t&&typeof t=="object"){let s=JSON.stringify(A(t,r+1)),c=p(s);if(c===s)return s;try{JSON.parse(c)}catch{f("SCAN_JSON_REWRITE")}return c}}return p(e)}if(typeof e=="number"){let t=p(String(e));return t===String(e)?e:t}if(Array.isArray(e))return e.map(t=>A(t,r+1));if(e&&typeof e=="object"){typeof e.type=="string"&&/image|audio|video|document|(^|_)file($|_)/i.test(e.type)&&f("SCAN_ATTACHMENT"),Object.keys(e).some(s=>/^(inlineData|inline_data|fileData|file_data|image_url|input_audio)$/.test(s))&&f("SCAN_ATTACHMENT");let t=Object.create(null);for(let[s,c]of Object.entries(e)){let n=p(s);Object.hasOwn(t,n)&&f("SCAN_KEY_COLLISION"),t[n]=A(c,r+1)}return t}if(e===null||typeof e=="boolean")return e;f("PAYLOAD_JSON")},h=function(e,r,t=0){if(t>80&&f("SCAN_COMPLEXITY"),typeof e=="string"){if(e.includes(r))return!0;let s;try{s=JSON.parse(e)}catch{return!1}return s&&typeof s=="object"?h(s,r,t+1):!1}return Array.isArray(e)?e.some(s=>h(s,r,t+1)):e&&typeof e=="object"?Object.entries(e).some(([s,c])=>s.includes(r)||h(c,r,t+1)):!1};J=x,H=m,X=p,$=A,F=h;let{payload:l,rules:I,entries:O,configRaws:R}=w,g=new Map(O.map(([e,r])=>[r,e])),d=new Map(O),N=[],C=new Set,S=I.map((e,r)=>{let t=r+1;return typeof e=="string"?{literal:e,rule:t}:e.type==="literal"?{literal:e.value,replacement:e.replacement,rule:t}:{rule:t,replacement:e.replacement,regex:new RegExp(e.pattern,[...new Set((e.flags??"")+"g")].join(""))}});for(let e of g.keys())S.push({literal:e});let E=[...new Set(R.flatMap(e=>[e,JSON.stringify(JSON.parse(e))]))];for(let e of E)S.push({literal:e});let D=JSON.stringify(l),y=0,M=0,P=A(l),j=[...C].filter(e=>h(P,e)).map(e=>[e,d.get(e)]);L.postMessage({payload:P,additions:N,hits:j})}catch(l){L.postMessage({failed:!0,diagnostic:{code:typeof l?.code=="string"?l.code:"SCAN_INTERNAL",rule:l?.rule??u,otherRule:l?.otherRule,node:l?.node??T}})}var J,H,X,$,F;
+import{parentPort as J,workerData as k}from"node:worker_threads";import{randomBytes as H}from"node:crypto";var $=[[48,57],[65,90],[97,122],[192,214],[216,246],[248,255],[256,383],[7680,7935],[913,937],[945,969],[940,974],[1040,1103],[1488,1514],[1569,1594],[1601,1610],[3585,3630],[3632,3635],[3636,3642],[3648,3652],[3655,3662],[12353,12438],[12449,12538],[44032,55203],[19968,40869]],P=BigInt(Number.MAX_SAFE_INTEGER);function C(s){if(s<=1n)return 0n;let u=s.toString(2).length,l=Math.ceil(u/8),h=(1n<<BigInt(u))-1n;for(let d=0;d<64;d++){let f=0n;for(let g of H(l))f=f<<8n|BigInt(g);if(f&=h,f<s)return f}return s-1n}function U(s){return $.find(([u,l])=>s>=u&&s<=l)}function j(s){let u="";for(let l of s){let h=l.codePointAt(0),d=U(h);if(!d){u+=l;continue}let[f,g]=d,y=BigInt(g-f+1);u+=String.fromCodePoint(f+Number(C(y)))}return u}function F(s){if(!/^\d+$/.test(s))return;if(s.length===1)return s==="0"?void 0:String(1n+C(9n));if(s.startsWith("0")){let d="";for(let f of s)d+=f==="0"?"0":String(1n+C(9n));return d}let u=10n**BigInt(s.length-1),l=10n**BigInt(s.length)-1n,h=l>P?P:l;if(!(h<u))return String(u+C(h-u+1n))}function B(s){let u=Number(s);return Number.isFinite(u)&&String(u)===s}var N,M=0;function c(s,u){throw{code:s,rule:N,otherRule:u,node:M}}try{let L=function(e,r){for(let n=0;n<64;n++){let t=r&&/^\d+$/.test(e)?F(e):j(e);if(!(!t||t===e)&&!f.has(t)&&!d.has(t)&&!X.includes(t))return t}},D=function(e,r,n=!1){let t=d.get(e);return t?(r!==void 0&&t!==r&&c("FIXED_MAPPING_CONFLICT"),t):r!==void 0?(f.size>=5e4&&c("SCAN_MAPPING_LIMIT"),f.has(r)&&f.get(r)!==e&&c("FIXED_ALIAS_REUSED"),r.includes(e)&&c("FIXED_SENSITIVE_TARGET"),d.set(e,r),f.set(r,e),g.push([r,e]),r):(f.size>=5e4&&c("SCAN_MAPPING_LIMIT"),t=L(e,n),t||c("SCAN_UNIQUE_FAILED"),d.set(e,t),f.set(t,e),g.push([t,e]),t)},E=function(e,r=!1){let n=[];for(let o of T)if(N=o.rule,o.literal===void 0){o.regex.lastIndex=0;for(let i of e.matchAll(o.regex))i[0].length||c("SCAN_ZERO_WIDTH"),n.push([i.index,i.index+i[0].length,o.replacement,o.rule]),++O>1e5&&c("SCAN_MATCH_LIMIT")}else{if(!o.literal)continue;let i=0;for(;(i=e.indexOf(o.literal,i))!==-1;)n.push([i,i+o.literal.length,o.replacement,o.rule]),++O>1e5&&c("SCAN_MATCH_LIMIT"),i++}n.sort((o,i)=>o[0]-i[0]||i[1]-o[1]);let t=[];for(let o of n){let i=t.at(-1);i&&o[0]<i[1]?((i[2]!==void 0||o[2]!==void 0)&&((i[0]!==o[0]||i[1]!==o[1]||i[2]!==void 0&&o[2]!==void 0&&i[2]!==o[2])&&(N=i[3],c("FIXED_OVERLAP",o[3])),i[2]===void 0&&o[2]!==void 0&&(i[3]=o[3]),i[2]??=o[2]),i[1]=Math.max(i[1],o[1])):t.push([...o])}let x="",p=0;for(let[o,i,a,A]of t){N=A;let S=D(e.slice(o,i),a,r);y.add(S),x+=e.slice(p,o)+S,p=i}return x+e.slice(p)},_=function(e,r=!1){let n="",t=0,x=a=>a.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),p=[...f.keys()];if(!p.length)return E(e,r);let o=new RegExp(p.sort((a,A)=>A.length-a.length).map(x).join("|"),"g"),i=[...e.matchAll(o)].filter(a=>f.has(a[0]));for(let a of T)if(!(!a.regex||!p.length)){N=a.rule,a.regex.lastIndex=0;for(let A of e.matchAll(a.regex))++O>1e5&&c("SCAN_MATCH_LIMIT"),A[0].length||c("SCAN_ZERO_WIDTH"),i.some(S=>p.includes(S[0])&&A.index<S.index+S[0].length&&A.index+A[0].length>S.index)&&c("FIXED_ALIAS_CROSSING")}for(let a of i)f.has(a[0])&&(n+=E(e.slice(t,a.index),r)+a[0],t=a.index+a[0].length);return n+E(e.slice(t),r)},I=function(e,r=0){if(M=++b,N=void 0,(b>2e5||r>80)&&c("SCAN_COMPLEXITY"),typeof e=="string"){if(R.some(n=>e.includes(n)))return _(e);if(/^\s*[[{]/.test(e)){let n;try{n=JSON.parse(e)}catch{}if(n&&typeof n=="object"){let t=JSON.stringify(I(n,r+1)),x=_(t);if(x===t)return t;try{JSON.parse(x)}catch{c("SCAN_JSON_REWRITE")}return x}}return _(e)}if(typeof e=="number"){let n=String(e),t=_(n,!0);return t===n?e:(B(t)||c("SCAN_NUMBER_UNSAFE"),Number(t))}if(Array.isArray(e))return e.map(n=>I(n,r+1));if(e&&typeof e=="object"){typeof e.type=="string"&&/image|audio|video|document|(^|_)file($|_)/i.test(e.type)&&c("SCAN_ATTACHMENT"),Object.keys(e).some(t=>/^(inlineData|inline_data|fileData|file_data|image_url|input_audio)$/.test(t))&&c("SCAN_ATTACHMENT");let n=Object.create(null);for(let[t,x]of Object.entries(e)){let p=_(t);Object.hasOwn(n,p)&&c("SCAN_KEY_COLLISION"),n[p]=I(x,r+1)}return n}if(e===null||typeof e=="boolean")return e;c("PAYLOAD_JSON")},m=function(e,r,n=0){if(n>80&&c("SCAN_COMPLEXITY"),typeof e=="string"){if(e.includes(r))return!0;let t;try{t=JSON.parse(e)}catch{return!1}return t&&typeof t=="object"?m(t,r,n+1):!1}return Array.isArray(e)?e.some(t=>m(t,r,n+1)):e&&typeof e=="object"?Object.entries(e).some(([t,x])=>t.includes(r)||m(x,r,n+1)):!1};W=L,Y=D,z=E,K=_,V=I,Z=m;let{payload:s,rules:u,entries:l,configRaws:h}=k,d=new Map(l.map(([e,r])=>[r,e])),f=new Map(l),g=[],y=new Set,T=u.map((e,r)=>{let n=r+1;return typeof e=="string"?{literal:e,rule:n}:e.type==="literal"?{literal:e.value,replacement:e.replacement,rule:n}:{rule:n,replacement:e.replacement,regex:new RegExp(e.pattern,[...new Set((e.flags??"")+"g")].join(""))}});for(let e of d.keys())T.push({literal:e});let R=[...new Set(h.flatMap(e=>[e,JSON.stringify(JSON.parse(e))]))];for(let e of R)T.push({literal:e});let X=JSON.stringify(s),O=0,b=0,w=I(s),G=[...y].filter(e=>m(w,e)).map(e=>[e,f.get(e)]);J.postMessage({payload:w,additions:g,hits:G})}catch(s){J.postMessage({failed:!0,diagnostic:{code:typeof s?.code=="string"?s.code:"SCAN_INTERNAL",rule:s?.rule??N,otherRule:s?.otherRule,node:s?.node??M}})}var W,Y,z,K,V,Z;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-information-protecter",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Sensitive Personal Information (SPI) Protecter — local reversible privacy redaction for Pi",
   "type": "module",
   "license": "MIT",