前几天看到: 让 GPT5.2 在 OpenCode 里说人话思路，我进行了尝试，他使用了 gemini-3-flash 对 GPT5.2 的思考块进行翻译，我用过之后，经常翻译超时，于是想到，能不能让 GPT5.2 自己翻译自己，基于这位佬友的代码进行了二开，效果嘎嘎好。效果如图：

安装：
1、复制本帖最下方代码，保存为 think-translator.ts（文件名随意）
2、打开 think-translator.ts
3、把 GPT5.2 的中转 API 信息写到 6~8 行（加了注释了，一眼就能看到）
4、把 think-translator.ts 放到 C:\Users\xxxx (你的名字).config\opencode\plugin 里，opencode 会自动加载
5、完事，开蹬

import type { Plugin } from "@opencode-ai/plugin";
import type { Message, Part } from "@opencode-ai/sdk";

declare function require(id: string): unknown;

// OpenAI 兼容接口（可用 /v1、/v1/chat/completions 或 /v1/responses 作为 baseURL）
const TRANSLATION_BASE_URL = "https://www.right.codes/codex/v1";// 填你的订阅 地址（示例是right code）
const TRANSLATION_API_KEY = ""; // 填你的订阅 Key
const TRANSLATION_MODEL_ID = "gpt-5.2"; // 可选：gpt-5.2 | gpt-5.2-low | gpt-5.2-medium

type PartEvent = Part & {
  time?: {
    end?: unknown;
  };
  text?: string;
};

type PatchResult = {
  response?: {
    status?: number;
  };
};

type ProviderConfig = {
  baseURL: string;
  apiKey: string;
  modelID: string;
};


const START_TAG = "[〔翻译开始〕]";
const END_TAG = "[〔翻译结束〕]";

const TITLE_TRANSLATION_PREFIX = "〔译: ";
const TITLE_TRANSLATION_SUFFIX = "〕";

function stripTranslationBlocks(text: string): string {
  while (true) {
    const start = text.indexOf(START_TAG);
    if (start === -1) return text;

    const end = text.indexOf(END_TAG, start + START_TAG.length);
    if (end === -1) return text.slice(0, start).trimEnd();

    const after = end + END_TAG.length;
    let restStart = after;
    while (restStart < text.length && text[restStart] === "\n") restStart += 1;

    const left = text.slice(0, start).trimEnd();
    const right = text.slice(restStart);
    text = left ? left + "\n\n" + right : right;
  }
}

function stripTitleTranslation(title: string): string {
  const start = title.indexOf(TITLE_TRANSLATION_PREFIX);
  if (start === -1) return title.trim();

  const end = title.indexOf(TITLE_TRANSLATION_SUFFIX, start + TITLE_TRANSLATION_PREFIX.length);
  if (end === -1) return title.slice(0, start).trim();

  return (title.slice(0, start) + title.slice(end + TITLE_TRANSLATION_SUFFIX.length)).trim();
}

function applyTitleTranslation(base: string, translation: string): string {
  if (!base.startsWith("**")) return base;
  const end = base.indexOf("**", 2);
  if (end === -1) return base;

  const rawTitle = base.slice(2, end);
  const title = stripTitleTranslation(rawTitle);
  if (!title) return base;

  const suffix = translation ? ` ${TITLE_TRANSLATION_PREFIX}${translation}${TITLE_TRANSLATION_SUFFIX}` : "";
  const combined = `**${title}${suffix}**`;
  return combined + base.slice(end + 2);
}

function extractTitleAndBody(base: string): { title: string; body: string } {
  if (!base.startsWith("**")) return { title: "", body: base };

  const end = base.indexOf("**", 2);
  if (end === -1) return { title: "", body: base };

  const rawTitle = base.slice(2, end);
  const title = stripTitleTranslation(rawTitle);
  const body = base.slice(end + 2).replace(/^\s+/, "");
  return { title, body };
}

function buildTranslationBlockPending(): string {
  return `${START_TAG}\n译文生成中…\n${END_TAG}`;
}

function buildTranslationBlockDone(bodyCn: string): string {
  const text = bodyCn.trim();
  return `${START_TAG}\n${text}\n${END_TAG}`;
}


function loadProviderConfigFromOpencodeConfig(_directory: string): ProviderConfig {
  return {
    baseURL: TRANSLATION_BASE_URL,
    apiKey: TRANSLATION_API_KEY,
    modelID: TRANSLATION_MODEL_ID,
  };
}

function extractSseTextParts(data: string): string {
  let parsed: unknown;
  try {
    parsed = JSON.parse(data);
  } catch {
    return "";
  }

  // OpenAI Chat Completions streaming: { choices: [{ delta: { content: "..." } }] }
  const chat = parsed as {
    choices?: Array<{
      delta?: { content?: string; text?: string };
      message?: { content?: string };
      text?: string;
    }>;
  };

  let out = "";
  for (const choice of chat.choices ?? []) {
    const d = choice.delta;
    if (d && typeof d.content === "string") out += d.content;
    else if (d && typeof d.text === "string") out += d.text;
    else if (choice.message && typeof choice.message.content === "string") out += choice.message.content;
    else if (typeof choice.text === "string") out += choice.text;
  }
  if (out) return out;

  // OpenAI Responses streaming (common proxy format): { type: "response.output_text.delta", delta: "..." }
  const resp = parsed as {
    type?: string;
    delta?: string;
    output_text?: string;
    text?: string;
    output?: Array<{
      content?: Array<{ type?: string; text?: string }>;
    }>;
    response?: {
      output?: Array<{
        content?: Array<{ type?: string; text?: string }>; // input_text / output_text
      }>;
    };
  };

  if (resp.type && typeof resp.delta === "string") return resp.delta;
  if (typeof resp.output_text === "string") return resp.output_text;
  if (resp.type && typeof resp.text === "string" && resp.type.endsWith(".delta")) return resp.text;

  // Non-stream JSON fallbacks (responses/chat) can also land here in some proxies.
  if (resp.response?.output) {
    let joined = "";
    for (const item of resp.response.output) {
      for (const c of item.content ?? []) {
        if (typeof c.text === "string") joined += c.text;
      }
    }
    if (joined) return joined;
  }

  if (resp.output) {
    let joined = "";
    for (const item of resp.output) {
      for (const c of item.content ?? []) {
        if (typeof c.text === "string") joined += c.text;
      }
    }
    if (joined) return joined;
  }

  return "";
}

type OpenAIEndpointKind = "chat.completions" | "responses";

function resolveOpenAIEndpoint(baseURL: string): { url: string; kind: OpenAIEndpointKind } {
  const base = baseURL.replace(/\/+$/, "");
  if (base.endsWith("/chat/completions")) return { url: base, kind: "chat.completions" };
  if (base.endsWith("/responses")) return { url: base, kind: "responses" };
  return { url: `${base}/chat/completions`, kind: "chat.completions" };
}

function buildTranslationPrompt(english: string): string {
  return (
    "You are a translation engine. Translate the English content to Simplified Chinese.\n" +
    "Rules (STRICT):\n" +
    "- Output ONLY the Chinese translation.\n" +
    "- No labels, no commentary.\n" +
    "- Preserve line breaks.\n" +
    "- Keep bullets as bullets.\n" +
    "- Do NOT omit or summarize any content.\n" +
    "\n" +
    "English:\n" +
    english
  );
}

async function* streamTextFromResponse(res: Response, signal?: AbortSignal): AsyncGenerator<string> {
  const contentType = res.headers.get("content-type") ?? "";
  if (contentType.includes("text/event-stream")) {
    for await (const chunk of streamSseTextParts(res, signal)) yield chunk;
    return;
  }

  if (!res.ok) {
    const msg = await res.text().catch(() => "");
    throw new Error(`http_${res.status}:${msg.slice(0, 160)}`);
  }

  const json = await res.json().catch(() => null);
  if (!json) return;

  // Reuse the same extractor for non-stream JSON.
  const text = extractSseTextParts(JSON.stringify(json));
  if (text) yield text;
}

async function* streamSseTextParts(response: Response, signal?: AbortSignal): AsyncGenerator<string> {
  if (!response.ok) {
    const msg = await response.text().catch(() => "");
    throw new Error(`http_${response.status}:${msg.slice(0, 160)}`);
  }

  const stream = response.body;
  if (!stream) return;

  const reader = stream.getReader();
  const decoder = new TextDecoder();

  let aborted = false;
  const abortError = () => new Error(String(signal?.reason ?? "aborted"));
  const onAbort = () => {
    aborted = true;
    try {
      reader.cancel();
    } catch {
      return;
    }
  };

  if (signal) {
    if (signal.aborted) onAbort();
    else signal.addEventListener("abort", onAbort, { once: true });
  }

  let buffer = "";

  const consume = function* () {
    while (true) {
      let sep = buffer.indexOf("\n\n");
      let advance = 2;
      if (sep === -1) {
        sep = buffer.indexOf("\r\n\r\n");
        advance = 4;
      }
      if (sep === -1) break;

      const chunk = buffer.slice(0, sep);
      buffer = buffer.slice(sep + advance);

      const lines = chunk.split(/\r?\n/);
      for (const line of lines) {
        const prefix = "data:";
        if (!line.startsWith(prefix)) continue;

        const data = line.slice(prefix.length).trim();
        if (!data) continue;
        if (data === "[DONE]") continue;

        const text = extractSseTextParts(data);
        if (text) yield text;
      }
    }
  };

  while (true) {
    if (aborted) throw abortError();
    const { done, value } = await reader.read();
    if (done) break;
    if (aborted) throw abortError();

    buffer += decoder.decode(value, { stream: true });
    for (const piece of consume()) yield piece;
  }

  if (aborted) throw abortError();
  buffer += "\n\n";
  for (const piece of consume()) yield piece;
}

function splitForTranslation(input: string): string[] {
  const text = input.replace(/\r\n/g, "\n").trim();
  if (!text) return [];

  const out: string[] = [];
  for (const para of text.split(/\n{2,}/g)) {
    const p = para.trim();
    if (!p) continue;

    const lines = p.split("\n");
    let buf: string[] = [];

    const flush = () => {
      const s = buf.join("\n").trim();
      if (s) out.push(s);
      buf = [];
    };

    for (const line of lines) {
      const l = line.trimEnd();
      if (/^\s*[-*•]\s+/.test(l) || /^\s*\d+\./.test(l)) {
        flush();
        out.push(l.trim());
      } else {
        buf.push(l);
      }
    }

    flush();
  }

  return out;
}

type StreamUpdate = {
  titleChunk?: string;
  bodyChunk?: string;
  done?: boolean;
};

async function translateViaOpenAIStream(
  cfg: ProviderConfig,
  input: string,
  signal?: AbortSignal
): Promise<AsyncGenerator<string>> {
  const { url, kind } = resolveOpenAIEndpoint(cfg.baseURL);
  const prompt = buildTranslationPrompt(input);

  const body =
    kind === "responses"
      ? {
          model: cfg.modelID,
          input: prompt,
          temperature: 0,
          max_output_tokens: 1024,
          stream: true,
        }
      : {
          model: cfg.modelID,
          messages: [
            { role: "system", content: "You are a translation engine." },
            { role: "user", content: prompt },
          ],
          temperature: 0,
          max_tokens: 1024,
          stream: true,
        };

  let res: Response;
  try {
    res = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Accept: "text/event-stream",
        Authorization: `Bearer ${cfg.apiKey}`,
      },
      body: JSON.stringify(body),
      signal,
    });
  } catch (e) {
    if (signal?.aborted) throw new Error(String(signal.reason ?? "aborted"));
    throw e;
  }

  async function* gen(): AsyncGenerator<string> {
    for await (const chunk of streamTextFromResponse(res, signal)) yield chunk;
  }

  return gen();
}

function renderTranslationBlock(body: string): string {
  const content = body.trim() ? body : "译文生成中…";
  return `${START_TAG}\n${content}\n${END_TAG}`;
}

function shouldFlush(lastFlush: number): boolean {
  return Date.now() - lastFlush >= 300;
}

async function translateReasoningStreamed(
  cfg: ProviderConfig,
  titleEn: string,
  bodyEn: string,
  onUpdate: (u: { titleCn?: string; bodyCn?: string; done?: boolean }) => void,
  signal?: AbortSignal
): Promise<void> {
  let titleCn = "";
  let bodyCn = "";

  let lastFlush = 0;

  const flush = (done?: boolean) => {
    onUpdate({
      titleCn: titleCn ? titleCn : "译文生成中…",
      bodyCn: bodyCn ? bodyCn : "译文生成中…",
      done,
    });
    lastFlush = Date.now();
  };

  flush(false);

  const titleTask = (async () => {
    if (!titleEn.trim()) return;

    const titleStream = await translateViaOpenAIStream(cfg, titleEn, signal);
    for await (const chunk of titleStream) {
      titleCn += chunk;
      if (shouldFlush(lastFlush)) flush(false);
    }
  })();

  const bodyTask = (async () => {
    if (!bodyEn.trim()) return;

    const segments = splitForTranslation(bodyEn);
    for (let i = 0; i < segments.length; i += 1) {
      const seg = segments[i];
      const segStream = await translateViaOpenAIStream(cfg, seg, signal);
      let segOut = "";
      for await (const chunk of segStream) {
        segOut += chunk;
        if (shouldFlush(lastFlush)) {
          const combined = (bodyCn + (bodyCn ? "\n\n" : "") + segOut).trim();
          onUpdate({ titleCn: titleCn ? titleCn : "译文生成中…", bodyCn: combined, done: false });
          lastFlush = Date.now();
        }
      }
      if (segOut.trim()) {
        bodyCn = (bodyCn + (bodyCn ? "\n\n" : "") + segOut.trim()).trim();
      }
      flush(false);
    }
  })();

  await Promise.all([titleTask, bodyTask]);
  flush(true);
}

export const ThinkTranslator: Plugin = async ({ directory, client }) => {
  const providerCfg = loadProviderConfigFromOpencodeConfig(directory);

  const patch = (client as unknown as {
    _client?: {
      patch?: (opts: { url: string; body?: unknown }) => Promise<PatchResult>;
    };
  })._client?.patch;

  const lastAssistantMessageBySession = new Map<string, string>();
  const reasoningByPartID = new Map<string, string>();
  const patchedPartIDs = new Set<string>();

  const pendingPatchByPartID = new Map<string, { part: PartEvent; text: string }>();
  const patchInFlightByPartID = new Set<string>();

  const MAX_CONCURRENT_TRANSLATIONS = 3;
  const MAX_RETRIES = 5;
  const FIRST_TOKEN_TIMEOUT_MS = 10_000;
  const TOTAL_TIMEOUT_MS = 120_000;

  type Task = {
    part: PartEvent;
    base: string;
    title: string;
    body: string;
    createdAt: number;
    attempt: number;
    generation: number;
  };

  const queue: Task[] = [];
  let running = 0;

  const flushPatch = (partID: string) => {
    if (!patch) return;
    if (patchInFlightByPartID.has(partID)) return;

    const pending = pendingPatchByPartID.get(partID);
    if (!pending) return;

    pendingPatchByPartID.delete(partID);
    patchInFlightByPartID.add(partID);

    const url = `/session/${pending.part.sessionID}/message/${pending.part.messageID}/part/${partID}`;
    const body = { ...pending.part, text: pending.text };

    let timer: ReturnType<typeof setTimeout> | undefined;
    const timeout = new Promise<never>((_r, reject) => {
      timer = setTimeout(() => reject(new Error("patch.timeout")), 2000);
    });

    Promise.race([patch({ url, body }), timeout])
      .catch(() => {
        return;
      })
      .finally(() => {
        if (timer) clearTimeout(timer);
        patchInFlightByPartID.delete(partID);
        if (pendingPatchByPartID.has(partID)) flushPatch(partID);
      });
  };

  const enqueuePatch = (p: PartEvent, updatedText: string) => {
    if (!patch) return;

    const prev = pendingPatchByPartID.get(p.id);
    if (prev && prev.text === updatedText) return;

    pendingPatchByPartID.set(p.id, { part: p, text: updatedText });
    flushPatch(p.id);
  };

  const runQueue = () => {
    while (running < MAX_CONCURRENT_TRANSLATIONS && queue.length) {
      const task = queue.shift()!;
      running += 1;

      const { part, base, title, body, createdAt } = task;

      const startAttempt = (attempt: number, generation: number) => {
        let sawFirstToken = false;
        const attemptStartedAt = Date.now();

        let titleCn = "";
        let bodyCn = "";
        let lastFlush = 0;

        const update = (u: { titleCn?: string; bodyCn?: string; done?: boolean }) => {
          const nextTitleCn = u.titleCn ?? (sawFirstToken ? titleCn : "译文生成中…");
          const nextBodyCn = u.bodyCn ?? (sawFirstToken ? bodyCn : "译文生成中…");

          const nextBase = applyTitleTranslation(base, nextTitleCn);
          const nextBlock = renderTranslationBlock(nextBodyCn);
          const nextText = nextBase + "\n\n" + nextBlock + "\n";
          enqueuePatch(part, nextText);

          if (typeof u.titleCn === "string") titleCn = u.titleCn;
          if (typeof u.bodyCn === "string") bodyCn = u.bodyCn;
        };

        const controller = new AbortController();
        const attemptSignal = controller.signal;

        let firstTokenTimer: ReturnType<typeof setTimeout> | undefined;
        firstTokenTimer = setTimeout(() => {
          if (sawFirstToken) return;
          controller.abort("first_token_timeout");
        }, FIRST_TOKEN_TIMEOUT_MS);

        const totalTimer = setTimeout(() => {
          controller.abort("total_timeout");
        }, TOTAL_TIMEOUT_MS);

        const onToken = () => {
          if (sawFirstToken) return;
          sawFirstToken = true;
          if (firstTokenTimer) {
            clearTimeout(firstTokenTimer);
            firstTokenTimer = undefined;
          }
        };

        const cleanupTimers = () => {
          if (firstTokenTimer) {
            clearTimeout(firstTokenTimer);
            firstTokenTimer = undefined;
          }
          clearTimeout(totalTimer);
        };

        const done = (finalTitle: string, finalBody: string) => {
          cleanupTimers();
          update({ titleCn: finalTitle, bodyCn: finalBody, done: true });
        };

        const fail = (msg: string) => {
          cleanupTimers();
          update({ titleCn: msg, bodyCn: msg, done: true });
        };

        (async () => {
          try {
            if (!providerCfg.baseURL.trim() || !providerCfg.apiKey.trim() || !providerCfg.modelID.trim()) {
              fail("未配置翻译接口（baseURL/apiKey/modelID）");
              return;
            }

            update({ titleCn: "译文生成中…", bodyCn: "译文生成中…", done: false });

            await translateReasoningStreamed(providerCfg, title, body, (u) => {
              if ((u.titleCn && u.titleCn.trim()) || (u.bodyCn && u.bodyCn.trim())) onToken();
              const now = Date.now();
              if (now - lastFlush < 300 && !u.done) return;
              lastFlush = now;
              update(u);
            }, attemptSignal);

            done(titleCn || "", bodyCn || "");
          } catch (e) {
            const elapsed = Date.now() - createdAt;
            const nextAttempt = attempt + 1;
            const err = String(e);

            if (elapsed >= TOTAL_TIMEOUT_MS || err.includes("total_timeout")) {
              fail("翻译超时");
              return;
            }

            if (nextAttempt <= MAX_RETRIES) {
              setTimeout(() => startAttempt(nextAttempt, generation + 1), 300 * nextAttempt);
              return;
            }

            if (err.includes("http_")) {
              const code = err.match(/http_(\d{3})/)?.[1] ?? "";
              fail(code ? `翻译失败（HTTP ${code}）` : "翻译失败");
              return;
            }

            if (err.includes("first_token_timeout")) {
              fail("翻译无响应");
              return;
            }

            fail("翻译失败");
          } finally {
            cleanupTimers();
            running -= 1;
            runQueue();
          }
        })();
      };

      startAttempt(task.attempt, task.generation);
    }
  };

  const enqueueTranslateAndPatch = (p: PartEvent, base: string) => {
    const { title, body } = extractTitleAndBody(base);

    queue.push({
      part: p,
      base,
      title,
      body,
      createdAt: Date.now(),
      attempt: 1,
      generation: 1,
    });

    runQueue();
  };

  return {
    "experimental.chat.messages.transform": async (_input, output) => {
      for (const m of output.messages ?? []) {
        if (m.info.role !== "assistant") continue;

        for (const p of m.parts ?? []) {
          if (p.type !== "text" && p.type !== "reasoning") continue;
          if (typeof p.text !== "string") continue;

          p.text = stripTranslationBlocks(p.text);
          if (p.type === "reasoning") p.text = stripTitleTranslation(p.text);
        }
      }
    },

    event: async ({ event }) => {
      if (event.type === "message.updated") {
        const info = (event.properties as { info: Message }).info;
        if (info.role === "assistant") lastAssistantMessageBySession.set(info.sessionID, info.id);
        return;
      }

      if (event.type !== "message.part.updated") return;

      const { part, delta } = event.properties as { part: Part; delta?: string };
      const p = part as unknown as PartEvent;

      const expectedMessageID = lastAssistantMessageBySession.get(p.sessionID);
      if (!expectedMessageID || p.messageID !== expectedMessageID) return;

      if (patchedPartIDs.has(p.id)) return;

      if (p.type === "reasoning" && typeof delta === "string" && delta.length) {
        const prev = reasoningByPartID.get(p.id) ?? "";
        reasoningByPartID.set(p.id, prev + delta);
      }

      if (p.type !== "reasoning" || !p.time?.end) return;

      const full = reasoningByPartID.get(p.id) ?? p.text ?? "";
      reasoningByPartID.delete(p.id);

      const base = stripTranslationBlocks(full).trimEnd();
      if (!base) return;

      const pendingBase = applyTitleTranslation(base, "标题译文生成中…");
      const pendingBlock = buildTranslationBlockPending();
      const pendingText = pendingBase + "\n\n" + pendingBlock + "\n";

      patchedPartIDs.add(p.id);
      enqueuePatch(p, pendingText);

      enqueueTranslateAndPatch(p, base);
    },
  };
};

OpenCode 竟然没有 “任务完成 / 请求权限 / 运行失败时发出通知” 这个功能。mohak34/opencode-notifier 这个插件倒是可以实现，但是最近的版本这个插件会导致 OpenCode 自带的 bun 发生 Segmentation fault，运行两步就崩溃。

于是我原汤化原食自己 vibe 了一个，把压缩包里的文件放在 ~/.config/opencode/plugins 里即可。

session-notify.zip

可以在 47 行配置是否弹出通知以及是否发出声音，一般只推荐开其中一个。Windows 可用，Linux 和 MacOS 我没测试，大概也可用，Maybe。

简介：CCometixLine (ccline) 是对于 claude code 显示一个状态栏信息的工具，由于原作者不考虑 cliproxyapi 相关的 PR, 所以自行 fork 并添加，后续如原仓库有重要 / 安全更新本 fork 会尽快合并更新.

较原仓库添加功能:

1. 模型别名 (通用)
2. cliproxyapi 额度显示 (当前只做了 opus,3pro,3flash), 每个模型都能设置别名 / 颜色

效果图:

fork 仓库:

使用方法：由于还没有配置 NPM, 只能手动安装，

1. 发现严重问题，没有配置 cliproxykey 的管理 key 的地方，请先不使用等更新，或暂时修改cliproxyapi管理的密钥为nbkey测试 (不建议)

2. 安装官方版 (安装完要配置) GitHub - Haleclipse/CCometixLine: Claude Code statusline tool written in Rust

3. 打开 fork 仓库

4. release

5. 选择对应你的系统版本下载

6. exe 覆盖官方的安装位置 C:\Users\Administrator\.claude\ccline\ccline.exe

7. 配置默认关闭需手动开启，

8. 终端命令 ccline

9. Configuration Mode

10. segment 选择 CLI Proxy API Quota , 然后 enter 开启，s 保存 (必须)

11. 可选，tab 选到 options 设置别名 / 颜色，s 保存

12. 

ps: 360 可能误报，我自己本地构建无误报，原仓库 action 自动构建有误报，如有担忧可自行 AI 审核构建

体检报告 (win64) :

https://www.virscan.org/report/e12d7b36366e6a47b9cd6c7c27295eff659659114676d513818d9238b5913eed

UniHub 是一个 插件化的本地桌面工具箱，通过安装插件来扩展功能，主打离线可用、数据不出本机、可折腾。

v1.1.0 更新要点：

• 新增官方插件：
  
  • Excalidraw（本地绘图 / 白板）
  • Ctool（40+ 开发工具：加解密 / Hash / Base64 / 时间转换等）
  • TodoList（本地待办清单）
• 新增系统应用扫描 + 全局搜索

插件开发很轻量：package.json + index.html → zip 即可安装。

项目还在早期阶段，欢迎 Star​ / Issue / PR / 插件共建 以及建议和使用反馈

链接：
jarrodwatts/claude-hud: A Claude Code plugin that shows what’s happening - context usage, active tools, running agents, and todo progress

推特看到的，plugin 安装挺简单的，可以用来了解 cc 执行的情况，然后原项目中 win11 不支持可以按下面自己修改一下：

• 找到配置文件 打开你的用户目录下的 .claude 文件夹，找到 settings.json 文件。 通常路径为：C:\Users\< 你的用户名 >\.claude\settings.json
• 修改配置 在 settings.json 文件中添加或修改 statusLine 字段。请使用以下 JSON 配置，注意 将 <username> 替换为你实际的 Windows 用户名：

{
  "statusLine": {
    "type": "command",
    "command": "node C:\\Users\\<username>\\.claude\\plugins\\cache\\claude-hud\\claude-hud\\0.0.2\\dist\\index.js"
  }
}

一些详细功能说明：

Claude HUD 主要在终端底部显示以下四类核心信息，旨在让你实时掌握 Claude Code 的运行状态：

1. 会话基础信息 (Session Info)

这是第一行内容，展示当前环境和资源消耗情况。

• 当前模型 ：显示正在使用的模型名称（如 [Opus 4.5]）。
• 上下文健康度 (Context Health)：通过可视化进度条（████░░）和百分比显示上下文窗口的使用量。颜色会随着使用量增加从绿色变为黄色，最后变红。
• 细节 ：当上下文使用率超过 85% 时，会额外显示具体的 token 使用量（输入 token 和缓存 token）；超过 95% 时会显示 COMPACT 警告。
• 配置统计 ：显示已加载的 CLAUDE.md 文件数、规则 (rules)、MCP 工具和钩子 (hooks) 的数量。
• 会话时长 ：显示当前会话已运行的时间（）。

2. 工具活动 (Tool Activity)

显示 Claude 正在使用或已经使用的工具，让你知道它是否 “卡住” 了或正在忙碌。

• 正在运行的工具 ：实时显示正在执行的工具名称及目标文件（例如 ◐ Glob: src/index.ts），让你看到它正在读取或编辑哪些文件。
• 已完成工具统计 ：聚合显示已执行完成的工具及其调用次数（例如 ✓ TaskOutput ×2 | ✓ Skill ×1）。

3. Agent 状态 (Agent Status)

追踪 Claude 内部派生的子智能体 (Sub-agents) 的行为。

• 活动状态 ：显示正在运行的 Agent 类型及其当前任务描述（例如 Explore: Explore home directory structure）。
• 耗时监控 ：显示每个 Agent 已经运行了多久，或者已完成 Agent 的总耗时。

4. 待办进度 (Todo Progress)

展示任务完成情况，直接读取 transcript 中的 todo 列表。

• 当前任务 ：显示正在进行中的具体待办事项（例如 ▸ Fix bugs in login flow）。
• 总体进度 ：以分数形式显示完成度（例如 (5/5)），全部完成后会显示绿色对勾。

通过这四行信息，将原本不可见的后台处理过程（如 Token 消耗、后台工具调用、子任务拆解）可视化，直接显示在你的输入框下方。

之前用过 @shekohex 的 opencode-google-antigravity-auth 和 @NoeFabris 的 opencode-antigravity-auth
两边的功能都想要，所以把它们合了。

主要功能：

• google_search 工具集成（来自 @shekohex）
• CLI / Anti quota 支持，通过 opencode auth login 使用（来自 @NoeFabris）
• Google Antigravity OAuth 认证，支持自动刷新 token
• 支持 gemini-3-pro-high、claude-opus-4-5-thinking 等模型
• 以及两个插件原有的其他优秀功能

安装方式：

{ "plugin": ["opencode-antigravity-auth-remix@1.0.7"] } 

仓库地址：GitHub - Darkstarrd-dev/opencode-antigravity-auth

现在可以在 opencode 里爽用双重额度，真的是踩不完，完全踩不完

antigravity 反人类，回到 opencode 舒服太多

各位佬友好，最近在折腾 NoneBot2 机器人的时候，发现有时候 LLM 或者其他插件可能会输出一些不该说的 “违禁词”，导致账号风控或者刷屏炸群。 为了解决这个问题，我先找了插件商店但是没有类似的词汇黑名单插件，我弄了一个主动审查插件 nonebot-plugin-word-censor，主要用于拦截机器人发出的消息。

项目地址 Github: https://github.com/ChlorophyTeio/nonebot-plugin-word-censor

目前插件已经上传并申请发布，商店发布检查结果已经通过。

安装插件后，机器人的处理将变为：收到 QQ 消息 → Nonebot 其他插件 → nonebot-plugin-word-censor → 发送 QQ 消息。

测试效果如图

原理主要是利用了 NoneBot 的 Bot.call_api 钩子机制。在 API 调用前，检查 data['message'] 字段。如果命中黑名单，则直接 Raise 一个 Mock 异常，欺骗上层调用者 “API 调用已完成” 或者直接中断，从而阻止请求发送到 OneBot 端。

这个审查插件比较简陋，后续会不断优化它，欢迎佬友们提 Issue 并给予意见。

Jetbrains家的KeyGen网上有很多，直接百度一下就能搜出来。
主要是ReSharper有联网验证，而且是.NET平台的软件，不能像Java一样用--javaagent直接进行注入。
这里给一个用Visual Studio拓展来解决的思路。

using HarmonyLib;
using System;

namespace ReSharperCrack
{
    [HarmonyPatch]
    internal static class Patches
    {
        static Patches()
        {
            try
            {
                var harmonyVersion = typeof(Harmony).Assembly.GetName().Version?.ToString() ?? "unknown";
                Logger.Log($"Patch loaded. Start. Harmony={harmonyVersion}, AppDomain={AppDomain.CurrentDomain.FriendlyName}");
            }
            catch (Exception ex)
            {
                Logger.Log($"Patch static ctor exception: {ex}");
            }
        }

        [HarmonyPatch("JetBrains.Application.License2.UserLicenses.UserLicenseViewSubmodel", "AddLicense")]
        [HarmonyPrefix]
        internal static bool AddLicense_Prefix(ref bool validateLicenseKey)
        {
            try
            {
                Logger.Log($"AddLicense_Prefix called. validateLicenseKey(before)={validateLicenseKey}");
                validateLicenseKey = false;
                Logger.Log($"AddLicense_Prefix finished. validateLicenseKey(after)={validateLicenseKey}");
                return true;
            }
            catch (Exception ex)
            {
                Logger.Log($"AddLicense_Prefix exception: {ex}");
                // be conservative: let original run if our prefix fails
                return true;
            }
        }

        [HarmonyPatch("JetBrains.Application.License2.NewLicenses.UserLicenseService", "VerifyCertificate")]
        [HarmonyPostfix]
        internal static void VerifyCertificate_Postfix(ref object __result)
        {
            try
            {
                Logger.Log($"VerifyCertificate_Postfix called. __result(before)={(__result == null ? "<null>" : __result + " (" + __result.GetType().FullName + ")")}");

                if ((int)__result != 0)
                {
                    __result = 0;
                }

                Logger.Log($"VerifyCertificate_Postfix finished. __result(after)={(__result == null ? "<null>" : __result + " (" + __result.GetType().FullName + ")")}");
            }
            catch (Exception ex)
            {
                Logger.Log($"VerifyCertificate_Postfix exception: {ex}");
            }
        }
    }
}

以及入口类：

/*...*/
[PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
[Guid(ReSharperCrackPackage.PackageGuidString)]
[ProvideAutoLoad(UIContextGuids80.NoSolution, PackageAutoLoadFlags.BackgroundLoad)]
public sealed class ReSharperCrackPackage : AsyncPackage
{
    protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
    {
        // 在这里加载LibHarmony的Hook
    }
}
/*...*/

编译成vsix拓展，装载在Visual Studio上。

接着，使用License Key激活就可以了。

项目简介

开发了一个 Apache Answer 的微信 OAuth 登录插件，让你的 Answer 社区可以支持微信扫码登录。

GitHub: https://github.com/starvpn/answer-user-wxcom

✨ 主要特性

• ? 标准 OAuth 2.0 协议
• ? 中英文双语支持
• ? 微信官方 Logo 样式
• ⚙️ 配置简单（只需 AppID + AppSecret ）
• ? 内置 CSRF 防护和安全验证
• ? 支持扫码登录和调用 PC 微信能力

? 一条命令安装

answer build \
--with github.com/starvpn/answer-user-wxcom \
--output ./new_answer

也支持 Docker 部署，可以和其他插件一起安装。

为什么做这个？

最近在用 Answer 搭建社区，发现国内用户更习惯微信登录。虽然 Answer 有 GitHub/Google 等登录方式，但对国内用户不太友好。于是按照 Answer 的插件机制开发了这个微信登录插件。

技术细节

• 基于 Answer 1.3.0+ 的 Connector 插件机制
• 遵循微信开放平台的网站应用接入规范
• 实现了完整的 OAuth 2.0 授权码流程
• 使用 State 参数防止 CSRF 攻击
• 支持 i18n 国际化

适用场景

• 国内的 Answer 问答社区
• 需要微信登录的技术论坛
• 企业内部知识库（配合企业微信）

大模型选择：从通用到专业的进阶之路

1. 通用全能型：ChatGPT系列

ChatGPT-4o和GPT-4在代码理解和生成方面表现卓越，特别适合：

• 插件架构设计：能够理解Typecho的插件机制，提供合理的代码结构
• PHP代码生成：准确生成符合Typecho规范的Hook挂载代码
• 问题调试：快速分析代码错误，提供修复方案

提示词示例：

请基于Typecho 1.2版本，设计一个文章浏览量统计插件。需要实现：
1. 使用Widget_Archive_Render钩子
2. 创建独立的数据表存储浏览记录
3. 防止同一用户重复刷新计数
请给出完整的插件代码结构。

2. 代码专项型：GitHub Copilot & Claude

GitHub Copilot 在具体编码环节表现出色：

• 实时代码补全，减少重复性编码工作
• 智能生成Typecho特有的Hook调用方式
• 提供多种实现方案的代码片段

Claude-3.5 Sonnet 在代码逻辑分析方面优势明显：

• 深度理解复杂业务需求
• 提供清晰的代码注释和文档
• 擅长重构和优化现有代码

3. 国产精品：DeepSeek与通义千问

对于中文开发者，这些模型有独特优势：

• 对中文注释和文档理解更精准
• 符合国内开发习惯的代码风格
• 免费或低成本使用，性价比高

实战案例：用AI开发Typecho插件

第一步：需求分析与架构设计

向AI提供清晰的Typecho版本信息和功能需求：

我需要为Typecho 1.2.1开发一个简单的SEO插件，功能包括：
- 自动生成文章meta描述
- 自定义文章关键词
- 生成XML网站地图
请设计插件目录结构和核心文件。

第二步：核心代码生成

针对具体功能模块，分段向AI请求代码：

请编写Plugin.php文件，实现以下Hook：
1. 使用Widget_Archive_Render在文章页输出meta标签
2. 使用Widget_Contents_Post_Edit在编辑页面添加SEO字段
3. 使用Action_Controller在后台添加管理菜单

第三步：调试与优化

遇到问题时，向AI提供错误信息和相关代码：

我的Typecho插件在挂载Widget_Archive_Render时出现500错误，相关代码是：
[你的代码]
错误信息是：Call to undefined method Typecho_Widget::getArchiveType()
请帮我分析和修复这个问题。

提升AI编码效果的关键技巧

1. 提供充分的上下文

• Typecho具体版本号
• PHP版本信息
• 已安装的其他插件情况
• 特殊需求或限制条件

2. 分步骤迭代开发

不要一次性要求完整插件，而是：

• 先设计插件框架
• 再实现核心功能
• 逐步添加辅助功能
• 最后进行测试优化

3. 善用代码审查

生成代码后，让AI自我审查：

请检查上面生成的代码：
1. 是否存在安全漏洞（如SQL注入、XSS攻击）
2. 是否符合Typecho编码规范
3. 是否有性能优化空间

注意事项与最佳实践

数据安全第一：AI生成的数据库操作代码需要严格验证，防止SQL注入

兼容性测试：务必在测试环境中验证插件兼容性，特别是Hook的触发时机

代码理解：不要直接复制粘贴，确保理解每一行代码的作用

版本控制：使用Git管理开发过程，便于回滚和追踪变更

结语

选择合适的AI助手，结合Typecho官方文档，能够显著提升插件开发效率。建议从简单插件开始，逐步积累经验。记住，AI是强大的辅助工具，但开发者的思考和验证同样重要。

希望这份指南能帮助您在Typecho插件开发道路上走得更远。如果您在具体实践中遇到问题，欢迎继续交流讨论！