@xiaoqiong0v0/opencode-file-tool 1.0.5 → 1.1.0

package/README.md

@@ -1,43 +1,49 @@
-# opencode-file-tool
-
-OpenCode 文件缓存与图片分析插件。自动缓存用户粘贴的图片，通过多模态模型分析，绕过主模型不支持视觉的限制。
-
-## 安装
-
-在 `opencode.json` 的 `plugin` 数组添加包名：
-
-```json
-"plugin": ["@xiaoqiong0v0/opencode-file-tool"]
-```
-
-重启 OpenCode 后自动安装。首次使用 `file_tool set-provider <模型名>` 配置视觉模型。
-
-## 功能
-
-- **文件缓存** — 粘贴图片时自动缓存到 `~/.opencode/plugins-cache/`
-- **图片分析** — 通过 `analyze_image file_id:N` 调用视觉模型分析
-- **会话父子链** — 子 agent 会话可通过 parent 链回退读取祖先会话的缓存
-- **多语言** — 支持中/英文提示
-
-## 工具
-
-| 工具 | 说明 |
-|------|------|
-| `file_tool list-provider` | 列出可用模型 |
-| `file_tool set-provider <model>` | 切换视觉模型 |
-| `file_tool list-cache [all\|N\|main\|main N]` | 查看缓存文件 |
-| `analyze_image file_id:N` | 分析指定图片 |
-
-## 命令
-
-| 命令 | 说明 |
-|------|------|
-| `/file-tool` | 触发 file_tool 工具 |
-
-## 配置
-
-`~/.config/opencode/file-tool.jsonc` 在首次启动时自动生成。
-
-## GitHub
-
-https://github.com/xiaoqiong0v0/opencode-file-tool
+# opencode-file-tool
+
+OpenCode 文件缓存与图片分析插件。自动缓存用户粘贴的图片，通过多模态模型分析，绕过主模型不支持视觉的限制。
+
+## 安装
+
+在 `opencode.json` 的 `plugin` 数组添加包名：
+
+```json
+"plugin": ["@xiaoqiong0v0/opencode-file-tool"]
+```
+
+重启 OpenCode 后自动安装。首次使用 `file_tool set-provider <模型名>` 配置视觉模型。
+
+## 功能
+
+- **文件缓存** — 粘贴图片时自动缓存到 `~/.opencode/plugins-cache/file-tool/`
+- **图片分析** — 通过 `analyze_image file_id:N` 调用视觉模型分析
+- **会话父子链** — 子 agent 会话可通过 parent 链回退读取祖先会话的缓存
+- **开关控制** — 主模型支持视觉时可用 `disable` 关闭缓存，让模型直接读取图片
+- **多语言** — 支持中/英文提示
+
+## 工具
+
+| 工具 | 说明 |
+|------|------|
+| `file_tool list-provider` | 列出可用模型 |
+| `file_tool set-provider <model>` | 切换视觉模型 |
+| `file_tool list-cache [all\|N\|main\|main N]` | 查看缓存文件 |
+| `file_tool enable` | 临时开启图片缓存（重启恢复默认） |
+| `file_tool disable` | 临时关闭图片缓存（重启恢复默认） |
+| `file_tool enable-save` | 持久开启图片缓存（写入配置） |
+| `file_tool disable-save` | 持久关闭图片缓存（写入配置） |
+| `file_tool status` | 查看缓存开关状态和当前视觉模型 |
+| `analyze_image file_id:N` | 分析指定图片 |
+
+## 命令
+
+| 命令 | 说明 |
+|------|------|
+| `/file-tool` | 触发 file_tool 工具 |
+
+## 配置
+
+`~/.config/opencode/file-tool.jsonc` 在首次启动时自动生成，支持 `enabled` 字段控制缓存开关。
+
+## GitHub
+
+https://github.com/xiaoqiong0v0/opencode-file-tool

package/dist/cache.js

@@ -0,0 +1,222 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { T } from "./i18n.js";
+import { CACHE_DIR, CACHE_EXT, CACHE_TYPES, log, MAX_CACHE_MSGS, MAX_GENERATED } from "./config.js";
+export const sessionParents = new Map();
+export const knownSessions = new Set();
+export function getRootSession(sid) {
+    let current = sid;
+    while (sessionParents.has(current))
+        current = sessionParents.get(current);
+    return current;
+}
+export function findFileInChain(sid, type, fid) {
+    const store = readTypeStore(sid, type);
+    const file = store.files[fid];
+    if (file)
+        return { store, type, file };
+    const parentSid = sessionParents.get(sid);
+    if (parentSid)
+        return findFileInChain(parentSid, type, fid);
+    return null;
+}
+function sessionDir(sid) { return join(CACHE_DIR, sid); }
+function filesDir(sid) {
+    const d = join(sessionDir(sid), "files");
+    if (!existsSync(d))
+        mkdirSync(d, { recursive: true });
+    return d;
+}
+export function readTypeStore(sid, type) {
+    try {
+        return JSON.parse(readFileSync(join(sessionDir(sid), `${type}.json`), "utf-8"));
+    }
+    catch {
+        return { nextId: 1, files: {} };
+    }
+}
+export function writeTypeStore(sid, type, data) {
+    const dir = sessionDir(sid);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${type}.json`), JSON.stringify(data, null, 2));
+}
+export function readMessages(sid) {
+    try {
+        return JSON.parse(readFileSync(join(sessionDir(sid), "messages.json"), "utf-8")) || [];
+    }
+    catch {
+        return [];
+    }
+}
+export function writeMessages(sid, msgs) {
+    const dir = sessionDir(sid);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "messages.json"), JSON.stringify(msgs, null, 2));
+}
+function removeRefs(sid, refs) {
+    let removed = 0;
+    for (const ref of refs) {
+        const [typeStr, idStr] = ref.split(":");
+        const type = typeStr;
+        const fid = parseInt(idStr, 10);
+        if (!CACHE_TYPES.includes(type) || isNaN(fid))
+            continue;
+        const store = readTypeStore(sid, type);
+        if (!store.files[fid])
+            continue;
+        delete store.files[fid];
+        writeTypeStore(sid, type, store);
+        const path = join(filesDir(sid), typeFilepath(type, store, fid));
+        rm(path, { force: true }).catch(() => { });
+        removed++;
+    }
+    return removed;
+}
+function typeFilepath(type, store, fid) {
+    const f = store.files[fid];
+    return f ? f.filename : `${type}_${fid}.${CACHE_EXT[type]}`;
+}
+export function deleteSession(sid) {
+    const dir = join(CACHE_DIR, sid);
+    if (existsSync(dir))
+        rmSync(dir, { recursive: true, force: true });
+}
+export function removeMsgCache(sid, msgId) {
+    const msgs = readMessages(sid);
+    const idx = msgs.findIndex(m => m.msgId === msgId);
+    if (idx < 0) {
+        log.info(`${sid}: msg ${msgId.slice(-8)} not in cache, skip`);
+        return;
+    }
+    const [msg] = msgs.splice(idx, 1);
+    removeRefs(sid, msg.refs);
+    writeMessages(sid, msgs);
+    log.info(`${sid}: removed msg ${msgId.slice(-8)} (${msg.refs.length} files: ${msg.refs.join(", ")})`);
+}
+function evictOldMessages(sid) {
+    const msgs = readMessages(sid);
+    if (msgs.length <= MAX_CACHE_MSGS)
+        return;
+    const expired = msgs.splice(0, msgs.length - MAX_CACHE_MSGS);
+    for (const msg of expired)
+        removeRefs(sid, msg.refs);
+    writeMessages(sid, msgs);
+}
+function evictGenerated(sid, type) {
+    if (MAX_GENERATED <= 0)
+        return;
+    const store = readTypeStore(sid, type);
+    const ids = Object.keys(store.files).map(Number).sort((a, b) => a - b);
+    const overflow = ids.length - MAX_GENERATED;
+    if (overflow <= 0)
+        return;
+    for (const fid of ids.slice(0, overflow)) {
+        delete store.files[fid];
+        const path = join(filesDir(sid), typeFilepath(type, store, fid));
+        rm(path, { force: true }).catch(() => { });
+        const msgs = readMessages(sid);
+        for (const m of msgs) {
+            const i = m.refs.indexOf(`${type}:${fid}`);
+            if (i >= 0)
+                m.refs.splice(i, 1);
+        }
+        writeMessages(sid, msgs);
+    }
+    writeTypeStore(sid, type, store);
+}
+export function registerFile(sid, type, filename, mime, msgId, buffer) {
+    const store = readTypeStore(sid, type);
+    const fid = store.nextId++;
+    store.files[fid] = { id: fid, filename, mime, msgId, cached: true };
+    writeTypeStore(sid, type, store);
+    const path = join(filesDir(sid), filename);
+    writeFileSync(path, buffer);
+    const msgs = readMessages(sid);
+    const last = msgs[msgs.length - 1];
+    const ref = `${type}:${fid}`;
+    if (last && last.msgId === msgId) {
+        last.refs.push(ref);
+    }
+    else {
+        msgs.push({ msgId, refs: [ref] });
+    }
+    writeMessages(sid, msgs);
+    if (type === "input")
+        evictOldMessages(sid);
+    else
+        evictGenerated(sid, type);
+    log.info(`${sid}: registered ${type} file ${filename} as ${ref}`);
+    return { id: fid, path };
+}
+export function registerInputFile(sid, filename, mime, msgId, dataUrl) {
+    const b64 = dataUrl.replace(/^data:\w+\/\w+;base64,/, "");
+    return registerFile(sid, "input", filename, mime, msgId, Buffer.from(b64, "base64"));
+}
+export function registerGeneratedFile(sid, type, filename, mime, msgId, buffer) {
+    return registerFile(sid, type, filename, mime, msgId, buffer);
+}
+export function readFileData(sid, type, fid) {
+    const found = findFileInChain(sid, type, fid);
+    if (!found)
+        return null;
+    try {
+        const buf = readFileSync(join(filesDir(sid), typeFilepath(type, found.store, fid)));
+        return `data:${found.file.mime || "image/png"};base64,${buf.toString("base64")}`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchToBuffer(url) {
+    const resp = await fetch(url, { signal: AbortSignal.timeout(60000) });
+    if (!resp.ok)
+        throw new Error(T("err_api", { status: String(resp.status), msg: (await resp.text().catch(() => "unknown")).slice(0, 200) }));
+    const buffer = Buffer.from(await resp.arrayBuffer());
+    const mime = resp.headers.get("content-type")?.split(";")[0] || "application/octet-stream";
+    return { buffer, mime };
+}
+export function extForMime(mime) {
+    const map = { "image/png": "png", "image/jpeg": "jpg", "image/webp": "webp", "video/mp4": "mp4", "video/webm": "webm", "audio/mpeg": "mp3", "audio/wav": "wav", "audio/ogg": "ogg" };
+    return map[mime] || "bin";
+}
+export function buildGenFilename(prefix, mime, id) {
+    return `${prefix}_${id}.${extForMime(mime)}`;
+}
+export function migrateLegacyCache(sid) {
+    const oldPath = join(CACHE_DIR, sid, "files.json");
+    if (!existsSync(oldPath))
+        return;
+    try {
+        const old = JSON.parse(readFileSync(oldPath, "utf-8"));
+        const store = { nextId: old.nextId || 1, files: {} };
+        const msgs = [];
+        for (const m of old.messages || []) {
+            const refs = [];
+            for (const fid of m.fileIds || []) {
+                const f = old.files[fid];
+                if (!f)
+                    continue;
+                const ext = extForMime(f.mime || "image/png");
+                const filename = `input_${fid}.${ext}`;
+                const src = join(filesDir(sid), fid + ".b64");
+                if (existsSync(src)) {
+                    const b64 = readFileSync(src, "utf-8");
+                    writeFileSync(join(filesDir(sid), filename), Buffer.from(b64, "base64"));
+                    rm(src, { force: true }).catch(() => { });
+                }
+                store.files[fid] = { id: fid, filename, mime: f.mime || "image/png", msgId: f.msgId || m.msgId, cached: f.cached !== false };
+                refs.push(`input:${fid}`);
+            }
+            msgs.push({ msgId: m.msgId, refs });
+        }
+        writeTypeStore(sid, "input", store);
+        writeMessages(sid, msgs);
+        rm(oldPath, { force: true }).then(() => log.info(`${sid}: migrated legacy cache`)).catch(() => { });
+    }
+    catch (e) {
+        log.error(`${sid}: migrate failed`, e instanceof Error ? e : Error(String(e)));
+    }
+}

package/dist/config.js

@@ -0,0 +1,168 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import createLogger from "@xiaoqiong0v0/opencode-plugin-logger";
+import { T, setLang } from "./i18n.js";
+export const MODEL_TYPES = ["vision", "image", "video", "tts"];
+export const CACHE_TYPES = ["input", "image", "video", "tts"];
+export const CACHE_EXT = { input: "bin", image: "png", video: "mp4", tts: "mp3" };
+export const log = createLogger("file-tool");
+export const CONFIG_DIR = process.env.HOME || process.env.USERPROFILE || "";
+export const CONFIG_PATH = join(CONFIG_DIR, ".config/opencode/file-tool.jsonc");
+export const OPENCODE_CONFIG = join(CONFIG_DIR, ".config/opencode/opencode.json");
+export const CACHE_DIR = join(CONFIG_DIR, ".opencode/plugins-cache", "file-tool");
+export let _cfg = null;
+export let MAX_CACHE_MSGS = 3;
+export let MAX_GENERATED = 5;
+export let ENABLED = true;
+export function setEnabled(v) { ENABLED = v; }
+export const FILE_TOOL_CFG_SAMPLE = `{
+  "models": {
+    "vision": "",
+    "image": "",
+    "video": "",
+    "tts": ""
+  },
+  "maxTokens": 4096,
+  "timeout": 60000,
+  "maxCacheMessages": 3,
+  "maxGenerated": 5,
+  "lang": "en",
+  "enabled": true
+}
+`;
+export const DEFAULT_CFG = {
+    models: { vision: "", image: "", video: "", tts: "" },
+    maxTokens: 4096,
+    timeout: 60000,
+    maxCacheMessages: 3,
+    maxGenerated: 5,
+    lang: "en",
+    enabled: true,
+};
+export function readJsonc(path) {
+    const raw = readFileSync(path, "utf-8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    return JSON.parse(raw);
+}
+export function splitModel(model) {
+    const idx = model.indexOf("/");
+    return idx >= 0 ? { provider: model.slice(0, idx), modelId: model.slice(idx + 1) } : { provider: "", modelId: model };
+}
+export function getProviderCreds(provider) {
+    try {
+        const oc = JSON.parse(readFileSync(OPENCODE_CONFIG, "utf-8"));
+        const prov = oc.provider?.[provider];
+        if (prov?.options?.apiKey && prov?.options?.baseURL)
+            return { apiKey: prov.options.apiKey, baseURL: prov.options.baseURL };
+    }
+    catch { }
+    return null;
+}
+export function getProviderNames() {
+    const names = new Set();
+    try {
+        const oc = JSON.parse(readFileSync(OPENCODE_CONFIG, "utf-8"));
+        for (const [pName, pVal] of Object.entries(oc.provider || {})) {
+            const p = pVal.options;
+            if (p?.apiKey && p?.baseURL)
+                names.add(pName);
+        }
+    }
+    catch { }
+    return names;
+}
+export function resolveModelRef(ref, fallbackCreds) {
+    let model = "";
+    let creds = fallbackCreds;
+    if (typeof ref === "string" && ref.trim()) {
+        model = ref.trim();
+    }
+    else if (ref && typeof ref === "object") {
+        const o = ref;
+        model = o.model || "";
+        const k = o.apiKey || fallbackCreds?.apiKey;
+        const u = o.baseURL || o.apiBaseUrl || fallbackCreds?.baseURL;
+        if (k && u)
+            creds = { apiKey: k, baseURL: u };
+    }
+    if (!model)
+        return undefined;
+    const { provider, modelId } = splitModel(model);
+    if (provider && modelId) {
+        const pc = getProviderCreds(provider);
+        if (pc)
+            return { model, provider, modelId, ...pc };
+    }
+    if (creds?.apiKey && creds?.baseURL && modelId)
+        return { model, provider, modelId, ...creds };
+    return undefined;
+}
+export function resolveConfig(raw) {
+    const models = {};
+    const fallbackCreds = raw.apiKey && (raw.apiBaseUrl || raw.baseURL)
+        ? { apiKey: raw.apiKey, baseURL: raw.apiBaseUrl || raw.baseURL }
+        : undefined;
+    const rawModels = (raw.models && typeof raw.models === "object") ? raw.models : {};
+    for (const type of MODEL_TYPES) {
+        const ref = rawModels[type] ?? (type === "vision" ? raw.model : undefined);
+        const mc = resolveModelRef(ref, fallbackCreds);
+        if (mc)
+            models[type] = mc;
+    }
+    return { models, maxTokens: raw.maxTokens || 4096, timeout: raw.timeout || 60000, maxCacheMessages: 3, maxGenerated: raw.maxGenerated >= 0 ? raw.maxGenerated : 5, lang: raw.lang === "zh" ? "zh" : "en", enabled: raw.enabled !== false };
+}
+export function loadCfg() {
+    if (!existsSync(CONFIG_PATH)) {
+        try {
+            writeFileSync(CONFIG_PATH, FILE_TOOL_CFG_SAMPLE, "utf-8");
+        }
+        catch { }
+    }
+    const raw = existsSync(CONFIG_PATH) ? readJsonc(CONFIG_PATH) : {};
+    _cfg = resolveConfig(raw);
+    MAX_CACHE_MSGS = (raw.maxCacheMessages > 0) ? raw.maxCacheMessages : 3;
+    MAX_GENERATED = raw.maxGenerated >= 0 ? raw.maxGenerated : 5;
+    ENABLED = raw.enabled !== false;
+    setLang(raw.lang || "en");
+    return _cfg;
+}
+export function reloadCfg() { loadCfg(); }
+export function getCfg() {
+    if (_cfg)
+        return _cfg;
+    const raw = existsSync(CONFIG_PATH) ? readJsonc(CONFIG_PATH) : {};
+    _cfg = resolveConfig(raw);
+    return _cfg;
+}
+export function getModelCfg(type) {
+    return getCfg().models[type];
+}
+export function requireModelCfg(type) {
+    const cfg = getModelCfg(type);
+    if (!cfg)
+        throw new Error(T("model_not_configured", { type }));
+    return cfg;
+}
+export function saveCfg(updates) {
+    const existing = existsSync(CONFIG_PATH) ? readJsonc(CONFIG_PATH) : {};
+    const merged = {};
+    for (const key of Object.keys(DEFAULT_CFG)) {
+        if (key in existing)
+            merged[key] = existing[key];
+    }
+    Object.assign(merged, updates);
+    for (const key of Object.keys(DEFAULT_CFG)) {
+        if (!(key in merged))
+            merged[key] = DEFAULT_CFG[key];
+    }
+    writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2));
+    reloadCfg();
+}
+export function writeCfgField(key, value) {
+    saveCfg({ [key]: value });
+}
+try {
+    loadCfg();
+}
+catch (e) {
+    log.error("初始化失败", e instanceof Error ? e : Error(String(e)));
+}