@max10240/opencode-plugin-sensitive-protection 0.0.0-stage → 1.0.14

package/README.md

@@ -1,3 +1,62 @@
-# Temporary Holding Version
+# @max10240/opencode-plugin-sensitive-protection
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+登记保护文件，在文件读取或工具输出进入模型上下文前阻断或脱敏。可独立使用，不依赖加解密插件。
+
+## 能力
+
+- `register_sensitive_file`：登记文件，读取内容到内存用于匹配，不输出文件内容；
+- `/protect-sensitive-file <path>`：server 命令登记；
+- `/protect-sensitive-file-ui` / keymap：TUI 弹出路径输入并登记；
+- `read` 精确路径命中保护文件时抛出 `Tool.Error`；
+- 所有 tool 输出命中保护内容时，将敏感片段替换为 `[REDACTED:PROTECTED]`；
+- 模型请求上下文和 HTTP 请求体做最终脱敏；
+- 按 `kid`/路径持久化登记表。
+
+不拦截 `grep`、`shell`、`edit`、`write` 的输入；它们在输出阶段脱敏。
+
+## 配置
+
+```jsonc
+{
+  "sensitiveProtection": {
+    "enabled": true,
+    "blockReads": true,
+    "redactContext": true,
+    "redactHttp": true,
+    "maxContentBytes": 8388608
+  }
+}
+```
+
+- `enabled` 默认 `true`；
+- `blockReads` 默认 `true`；
+- `maxContentBytes` 默认 8 MiB，硬上限 64 MiB；
+- 内容匹配支持整段、逐行、JSON 转义、Base64/Base64URL、Hex。
+
+## 逃生舱
+
+当前项目可放置：
+
+```text
+.opencode/sensitive-protection.json
+```
+
+```json
+{ "enabled": false }
+```
+
+只关闭当前 project/location 的保护，不影响加解密插件。
+
+## 数据
+
+登记表保存到：
+
+```text
+<XDG_DATA_HOME 或 ~/.local/share>/opencode/sensitive-protection/registry.json
+```
+
+只保存路径和 metadata，不保存文件内容。
+
+## 边界
+
+插件 hook 不能保证所有编码、压缩、拆分、MCP/子 Agent 内部操作都被识别；强隔离需要 OS 沙箱或独立用户。

package/dist/index.js

@@ -0,0 +1 @@
+export { default, setupSensitiveProtection, REDACTION_TOKEN, REGISTER_TOOL_NAME } from "./src/index.js";

package/dist/src/index.js

@@ -0,0 +1,171 @@
+import { Plugin } from "@opencode/plugin";
+import { Error as ToolError } from "@opencode/plugin/promise/tool";
+import { parseProtectionOptions } from "./options.js";
+import { ProtectionRegistry, resolveProtectedPath } from "./registry.js";
+export { REDACTION_TOKEN } from "./registry.js";
+export const REGISTER_TOOL_NAME = "register_sensitive_file";
+export async function setupSensitiveProtection(context) {
+    let options;
+    try {
+        options = await parseProtectionOptions(context.options, context.location.directory);
+    }
+    catch (error) {
+        console.warn(`Sensitive protection disabled: ${error instanceof Error ? error.message : "invalid options"}`);
+        return async () => { };
+    }
+    if (!options.enabled)
+        return async () => { };
+    const registry = new ProtectionRegistry(options.dataDirectory, options.maxContentBytes);
+    await registry.load();
+    const registerPath = async (value, input = {}) => {
+        const resolved = await resolveProtectedPath(value, context.location.directory);
+        const result = await registry.register(resolved, {
+            role: input.role ?? "manual",
+            keyID: input.keyID,
+            label: input.label,
+        });
+        return { path: resolved, bytes: result.bytes };
+    };
+    const disposals = [];
+    try {
+        disposals.push(await context.tool.transform((editor) => {
+            editor.add({
+                name: REGISTER_TOOL_NAME,
+                options: { codemode: false },
+                description: "Register an existing file as protected. The file is read locally for redaction; its contents are never output.",
+                input: {
+                    type: "object",
+                    properties: {
+                        file: { type: "string", description: "Existing file path to protect." },
+                        role: { type: "string", enum: ["encrypt-input", "decrypt-output", "manual"] },
+                        keyID: { type: "string" },
+                        label: { type: "string" },
+                        sessionID: { type: "string" },
+                        toolCallID: { type: "string" },
+                    },
+                    required: ["file"],
+                    additionalProperties: false,
+                },
+                execute: async (rawInput) => {
+                    const input = rawInput;
+                    if (typeof input.file !== "string" || !input.file.trim())
+                        throw new Error("file is required");
+                    const role = input.role === "encrypt-input" || input.role === "decrypt-output" ? input.role : "manual";
+                    const result = await registerPath(input.file, {
+                        role,
+                        ...(typeof input.keyID === "string" ? { keyID: input.keyID } : {}),
+                        ...(typeof input.label === "string" ? { label: input.label } : {}),
+                    });
+                    return {
+                        content: "Protected file registered.",
+                        metadata: { registered: true, file: result.path, bytes: result.bytes },
+                    };
+                },
+            });
+        }));
+        if (options.blockReads) {
+            disposals.push(await context.tool.hook("execute.before", async (event) => {
+                if (event.tool !== "read" || !event.input || typeof event.input !== "object")
+                    return;
+                const value = event.input.path;
+                if (typeof value !== "string")
+                    return;
+                const resolved = await resolveProtectedPath(value, context.location.directory).catch(() => undefined);
+                if (resolved && registry.has(resolved)) {
+                    throw new ToolError({ message: "Blocked: this file is protected; use an approved viewer instead." });
+                }
+            }));
+        }
+        disposals.push(await context.tool.hook("execute.after", async (event) => {
+            if (registry.size === 0)
+                return;
+            if (event.status === "error") {
+                const error = event.error;
+                const message = registry.redactValue(error.message);
+                const metadata = registry.redactValue(error.metadata);
+                if (!message.changed && !metadata.changed)
+                    return;
+                if (message.changed)
+                    error.message = String(message.value);
+                if (metadata.changed)
+                    error.metadata = metadata.value;
+                return;
+            }
+            const result = event.result;
+            const content = registry.redactValue(result.content);
+            const output = registry.redactValue(result.output);
+            const metadata = registry.redactValue(result.metadata);
+            if (!content.changed && !output.changed && !metadata.changed)
+                return;
+            result.content = content.value;
+            result.output = output.value;
+            result.metadata = {
+                ...(metadata.value && typeof metadata.value === "object" && !Array.isArray(metadata.value) ? metadata.value : {}),
+                redacted: true,
+                reason: "protected-sensitive-content",
+            };
+        }));
+        if (options.redactContext) {
+            disposals.push(await context.session.hook("context", async (event) => {
+                if (registry.size === 0)
+                    return;
+                const messages = registry.redactValue(event.messages);
+                const system = registry.redactValue(event.system);
+                if (messages.changed)
+                    event.messages = messages.value;
+                if (system.changed)
+                    event.system = system.value;
+            }));
+        }
+        if (options.redactHttp) {
+            disposals.push(await context.session.hook("http.request", async (event) => {
+                if (registry.size === 0)
+                    return;
+                try {
+                    const method = event.request.method.toUpperCase();
+                    if (method === "GET" || method === "HEAD")
+                        return;
+                    const body = await event.request.clone().text();
+                    const redacted = registry.redact(body);
+                    if (redacted === body)
+                        return;
+                    event.request = new Request(event.request.url, {
+                        method: event.request.method,
+                        headers: event.request.headers,
+                        body: redacted,
+                    });
+                }
+                catch {
+                    // Never break the provider request because optional redaction failed.
+                }
+            }));
+        }
+        disposals.push(await context.command.transform((editor) => {
+            editor.add({
+                name: "protect-sensitive-file",
+                description: "Register a file as protected from model context.",
+                execute: async (invocation) => {
+                    const text = typeof invocation.prompt.text === "string"
+                        ? invocation.prompt.text.trim()
+                        : "";
+                    if (!text)
+                        throw new Error("A file path is required");
+                    await registerPath(text);
+                },
+            });
+        }));
+    }
+    catch (error) {
+        await Promise.allSettled(disposals.map((item) => item.dispose()));
+        console.warn(`Sensitive protection disabled: ${error instanceof Error ? error.message : "setup failed"}`);
+        return async () => { };
+    }
+    return async () => {
+        await Promise.allSettled(disposals.map((item) => item.dispose()));
+        await registry.flush();
+    };
+}
+export default Plugin.define({
+    id: "max10240.sensitive-protection",
+    setup: setupSensitiveProtection,
+});

package/dist/src/options.js

@@ -0,0 +1,39 @@
+import os from "node:os";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+export const DEFAULT_MAX_CONTENT_BYTES = 8 * 1024 * 1024;
+export const MAX_CONTENT_BYTES_LIMIT = 64 * 1024 * 1024;
+export function dataDirectory(environment = process.env, home = os.homedir()) {
+    const base = environment.XDG_DATA_HOME || path.join(home, ".local", "share");
+    return path.join(base, "opencode", "sensitive-protection");
+}
+export async function projectEscapeHatch(directory) {
+    const file = path.join(directory, ".opencode", "sensitive-protection.json");
+    try {
+        const parsed = JSON.parse(await readFile(file, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return true;
+        const value = parsed;
+        if (value.enabled === false || value.disabled === true)
+            return false;
+        return true;
+    }
+    catch {
+        return true;
+    }
+}
+export async function parseProtectionOptions(raw = {}, directory, environment = process.env) {
+    const configured = raw.maxContentBytes;
+    if (configured !== undefined && (typeof configured !== "number" || !Number.isSafeInteger(configured) || configured < 1 || configured > MAX_CONTENT_BYTES_LIMIT)) {
+        throw new Error(`maxContentBytes must be an integer between 1 and ${MAX_CONTENT_BYTES_LIMIT}`);
+    }
+    const enabled = raw.enabled !== false && (await projectEscapeHatch(directory));
+    return {
+        enabled,
+        blockReads: raw.blockReads !== false,
+        redactContext: raw.redactContext !== false,
+        redactHttp: raw.redactHttp !== false,
+        maxContentBytes: configured === undefined ? DEFAULT_MAX_CONTENT_BYTES : configured,
+        dataDirectory: dataDirectory(environment),
+    };
+}

package/dist/src/registry.js

@@ -0,0 +1,175 @@
+import { lstat, mkdir, readFile, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import os from "node:os";
+export const REDACTION_TOKEN = "[REDACTED:PROTECTED]";
+export class ProtectionRegistry {
+    directory;
+    maxContentBytes;
+    entries = new Map();
+    saveQueue = Promise.resolve();
+    constructor(directory, maxContentBytes) {
+        this.directory = directory;
+        this.maxContentBytes = maxContentBytes;
+    }
+    get size() {
+        return this.entries.size;
+    }
+    has(value) {
+        return this.entries.has(value);
+    }
+    async load() {
+        const file = path.join(this.directory, "registry.json");
+        let parsed;
+        try {
+            parsed = JSON.parse(await readFile(file, "utf8"));
+        }
+        catch {
+            return;
+        }
+        if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.entries))
+            return;
+        for (const raw of parsed.entries) {
+            if (!raw || typeof raw !== "object")
+                continue;
+            const entry = raw;
+            if (typeof entry.path !== "string" || typeof entry.role !== "string" || typeof entry.createdAt !== "number")
+                continue;
+            try {
+                await this.register(entry.path, {
+                    role: entry.role,
+                    keyID: entry.keyID,
+                    label: entry.label,
+                    createdAt: entry.createdAt,
+                    persist: false,
+                });
+            }
+            catch {
+                // The file may have been removed since the registry was written.
+            }
+        }
+    }
+    async register(value, input) {
+        const resolved = await realpath(value);
+        const info = await lstat(resolved);
+        if (info.isSymbolicLink())
+            throw new Error("Protected file must not be a symbolic link");
+        if (!info.isFile())
+            throw new Error("Protected file must be a regular file");
+        if (info.size > this.maxContentBytes)
+            throw new Error(`Protected file exceeds the ${this.maxContentBytes} byte limit`);
+        const content = await readFile(resolved);
+        const patterns = buildPatterns(content);
+        const entry = {
+            path: resolved,
+            role: input.role,
+            ...(input.keyID === undefined ? {} : { keyID: input.keyID }),
+            ...(input.label === undefined ? {} : { label: input.label }),
+            createdAt: input.createdAt ?? Date.now(),
+            patterns,
+        };
+        this.entries.set(resolved, entry);
+        if (input.persist !== false)
+            void this.queueSave();
+        return { path: resolved, bytes: content.length };
+    }
+    redact(text) {
+        let value = text;
+        for (const entry of this.entries.values()) {
+            for (const pattern of entry.patterns) {
+                if (pattern && value.includes(pattern))
+                    value = value.split(pattern).join(REDACTION_TOKEN);
+            }
+        }
+        return value;
+    }
+    redactValue(value) {
+        if (this.entries.size === 0)
+            return { value, changed: false };
+        if (typeof value === "string") {
+            const next = this.redact(value);
+            return { value: next, changed: next !== value };
+        }
+        if (Array.isArray(value)) {
+            let changed = false;
+            const next = value.map((item) => {
+                const result = this.redactValue(item);
+                if (result.changed)
+                    changed = true;
+                return result.value;
+            });
+            return { value: next, changed };
+        }
+        if (value && typeof value === "object") {
+            let changed = false;
+            const next = {};
+            for (const [key, item] of Object.entries(value)) {
+                const result = this.redactValue(item);
+                if (result.changed)
+                    changed = true;
+                next[key] = result.value;
+            }
+            return { value: next, changed };
+        }
+        return { value, changed: false };
+    }
+    async flush() {
+        await this.queueSave();
+    }
+    queueSave() {
+        this.saveQueue = this.saveQueue.then(() => this.save()).catch(() => { });
+        return this.saveQueue;
+    }
+    async save() {
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const file = path.join(this.directory, "registry.json");
+        const temporary = path.join(this.directory, `.registry.${randomUUID()}.tmp`);
+        const entries = [...this.entries.values()].map(({ patterns: _patterns, ...entry }) => entry);
+        try {
+            await writeFile(temporary, JSON.stringify({ version: 1, entries }, null, 2), { mode: 0o600, flag: "wx" });
+            await rename(temporary, file);
+        }
+        finally {
+            await unlink(temporary).catch(() => { });
+        }
+    }
+}
+function buildPatterns(content) {
+    const text = content.toString("utf8");
+    if (!text)
+        return [];
+    const patterns = new Set();
+    const add = (value) => {
+        if (value && value.length >= 8)
+            patterns.add(value);
+    };
+    add(text);
+    for (const line of text.split("\n")) {
+        add(line.replace(/\r$/, ""));
+    }
+    const escaped = JSON.stringify(text).slice(1, -1);
+    if (escaped !== text) {
+        add(escaped);
+        for (const line of escaped.split("\\n"))
+            add(line);
+    }
+    if (content.length <= 1024 * 1024) {
+        add(content.toString("base64"));
+        add(content.toString("base64url"));
+        add(content.toString("hex"));
+        add(content.toString("hex").toUpperCase());
+    }
+    return [...patterns].sort((left, right) => right.length - left.length);
+}
+export async function resolveProtectedPath(value, directory) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error("file must be a non-empty path");
+    const root = path.resolve(os.tmpdir());
+    const expanded = value === "~" ? process.env.HOME ?? "" : value.startsWith("~/") ? path.join(process.env.HOME ?? "", value.slice(2)) : value === "$TMPDIR" || value === "${TMPDIR}" ? root : value.startsWith("$TMPDIR/") ? path.join(root, value.slice(8)) : value.startsWith("${TMPDIR}/") ? path.join(root, value.slice(11)) : value;
+    const candidate = path.isAbsolute(expanded) ? expanded : path.resolve(directory, expanded);
+    return realpath(candidate);
+}
+export async function fileIsRegular(value) {
+    const info = await stat(value).catch(() => undefined);
+    return info?.isFile() === true;
+}

package/dist/src/tui.js

@@ -0,0 +1,57 @@
+// @bun
+// src/tui.tsx
+import { Plugin } from "@opencode/plugin/tui";
+var tui_default = Plugin.define({
+  id: "max10240.sensitive-protection.tui",
+  setup: setupSensitiveProtectionTui
+});
+function setupSensitiveProtectionTui(context) {
+  if (context.options.enabled === false)
+    return;
+  context.keymap.layer(() => ({
+    commands: [{
+      id: "sensitive-protection.register",
+      title: "Protect sensitive file",
+      description: "Register an existing file as protected",
+      group: "Sensitive",
+      bind: false,
+      palette: true,
+      slash: {
+        name: "protect-sensitive-file-ui"
+      },
+      run: async () => {
+        const file = await context.ui.dialog.prompt({
+          title: "Protect sensitive file",
+          description: "Existing file path",
+          placeholder: "/absolute/path"
+        });
+        if (!file?.trim())
+          return;
+        const route = context.ui.router.current();
+        if (route.type !== "session") {
+          await context.ui.dialog.alert({
+            title: "Protect sensitive file",
+            message: "Open a session first"
+          });
+          return;
+        }
+        try {
+          await context.client.session.command({
+            sessionID: route.sessionID,
+            name: "protect-sensitive-file",
+            text: file.trim()
+          });
+        } catch (error) {
+          await context.ui.dialog.alert({
+            title: "Protection failed",
+            message: error instanceof Error ? error.message : "Unable to register this file"
+          });
+        }
+      }
+    }]
+  }));
+}
+export {
+  tui_default as default,
+  setupSensitiveProtectionTui
+};

package/dist/tui.js

@@ -0,0 +1,7 @@
+// @bun
+// tui.tsx
+import { default as default2, setupSensitiveProtectionTui } from "./src/tui.js";
+export {
+  default2 as default,
+  setupSensitiveProtectionTui
+};

package/package.json

@@ -1,6 +1,53 @@
 {
+  "$schema": "https://json.schemastore.org/package.json",
   "name": "@max10240/opencode-plugin-sensitive-protection",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.14",
+  "description": "Register protected files and redact their contents before they enter model context",
+  "type": "module",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./tui": "./dist/src/tui.js"
+  },
+  "scripts": {
+    "test": "bun test test/*.test.ts && bun test --conditions=browser --preload @opentui/solid/preload test/tui",
+    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json && bun build.mjs",
+    "prepack": "node ../../scripts/sync-recommended-rules.mjs && npm run build"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "security",
+    "redaction"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@opencode/plugin": "^2.0.9"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.2",
+    "@opentui/core": "^0.5.10",
+    "@opentui/solid": "^0.5.10",
+    "solid-js": "^1.9.15"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Max10240/opencode-plugin-unicorn.git",
+    "directory": "packages/opencode-plugin-sensitive-protection"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.5.10",
+    "@opentui/solid": ">=0.5.10",
+    "solid-js": ">=1.9.0"
+  }
+}