opencode-discord-notify 0.1.1 → 0.3.0

package/README-JP.md

@@ -62,10 +62,14 @@ OpenCode を再起動してください。
 - `DISCORD_WEBHOOK_COMPLETE_MENTION`: `session.idle` / `session.error` の通知本文に付けるメンション（`@everyone` または `@here` のみ許容。Forum webhook の仕様上、ping は常に発生しない）
 - `DISCORD_WEBHOOK_PERMISSION_MENTION`: `permission.updated` の通知本文に付けるメンション（`DISCORD_WEBHOOK_COMPLETE_MENTION` へのフォールバックなし。`@everyone` または `@here` のみ許容。Forum webhook の仕様上、ping は常に発生しない）
 - `DISCORD_WEBHOOK_EXCLUDE_INPUT_CONTEXT`: `1` のとき input context（`<file>` から始まる user `text` part）を通知しない（デフォルト: `1` / `0` で無効化）
+- `DISCORD_WEBHOOK_SHOW_ERROR_ALERT`: `1` のとき Discord webhook の送信が失敗した場合に OpenCode TUI のトーストを表示します（429 含む）（デフォルト: `1` / `0` で無効化）
+- `SEND_PARAMS`: embed の fields として送るキーをカンマ区切りで指定。指定可能キー: `sessionID`, `permissionID`, `type`, `pattern`, `messageID`, `callID`, `partID`, `role`, `directory`, `projectID`。未設定・空文字・空要素のみの場合は全て選択。`session.created` は `SEND_PARAMS` に関わらず `sessionID`, `projectID`, `directory` を必ず含みます。
 
 ## 仕様メモ
 
-- `DISCORD_WEBHOOK_URL` 未設定の場合は no-op（ログに警告のみ）です。
+- `DISCORD_WEBHOOK_URL` 未設定の場合は no-op です。
+- Discord webhook の送信が失敗した場合、OpenCode TUI のトーストを表示することがあります（`DISCORD_WEBHOOK_SHOW_ERROR_ALERT` で制御）。
+- HTTP 429 の場合は `retry_after` があればそれを優先し、なければ 10 秒程度待って 1 回だけリトライし、それでも失敗した場合は warning トーストを表示します。
 - Forum スレッド作成時は `?wait=true` を付け、レスポンスの `channel_id` を thread ID として利用します。
 - スレッド名（`thread_name`）は以下の優先度です（最大100文字）。
   1. 最初の user `text`
@@ -81,8 +85,10 @@ OpenCode を再起動してください。
 - `message.updated` は通知しません（role 判定用に追跡。role 未確定で保留した `text` part を後から通知することがあります）。
 - `message.part.updated` は以下の方針です。
   - `text`: user は即時通知。assistant は `part.time.end` がある確定時のみ通知（ストリーミング途中更新は通知しない）
+    - embed タイトルは `User says` / `Agent says` です
   - `tool`: 通知しない
   - `reasoning`: 通知しない（内部思考が含まれる可能性があるため）
+- `SEND_PARAMS` の制御対象は embed の fields のみです（title/description/content/timestamp などは対象外）。また `share` は fields としては送りません（Session started の embed URL には `shareUrl` を使います）。
 
 ## 動作確認（手動）
 

package/README.md

@@ -64,10 +64,14 @@ Optional:
 - `DISCORD_WEBHOOK_COMPLETE_MENTION`: mention to put in `session.idle` / `session.error` messages (only `@everyone` or `@here` supported; Forum webhooks may not actually ping due to Discord behavior)
 - `DISCORD_WEBHOOK_PERMISSION_MENTION`: mention to put in `permission.updated` messages (no fallback to `DISCORD_WEBHOOK_COMPLETE_MENTION`; only `@everyone` or `@here` supported; Forum webhooks may not actually ping due to Discord behavior)
 - `DISCORD_WEBHOOK_EXCLUDE_INPUT_CONTEXT`: when set to `1`, exclude "input context" (user `text` parts that start with `<file>`) from notifications (default: `1`; set to `0` to disable)
+- `DISCORD_WEBHOOK_SHOW_ERROR_ALERT`: when set to `1`, show an OpenCode TUI toast when Discord webhook requests fail (includes 429). (default: `1`; set to `0` to disable)
+- `SEND_PARAMS`: comma-separated list of keys to include as embed fields. Allowed keys: `sessionID`, `permissionID`, `type`, `pattern`, `messageID`, `callID`, `partID`, `role`, `directory`, `projectID`. If unset, empty, or containing only empty elements, all keys are selected. `session.created` always includes `sessionID`, `projectID`, `directory` regardless.
 
 ## Notes / behavior
 
-- If `DISCORD_WEBHOOK_URL` is not set, it becomes a no-op (logs a warning only).
+- If `DISCORD_WEBHOOK_URL` is not set, it becomes a no-op.
+- If a webhook request fails, it may show an OpenCode TUI toast (controlled by `DISCORD_WEBHOOK_SHOW_ERROR_ALERT`).
+- On HTTP 429, it waits `retry_after` seconds if provided (otherwise ~10s) and retries once; if it still fails, it shows a warning toast.
 - For Forum thread creation, it appends `?wait=true` and uses `channel_id` in the response as the thread ID.
 - `thread_name` priority order (max 100 chars):
   1. first user `text`
@@ -83,8 +87,10 @@ Optional:
 - `message.updated` is not posted (tracked for role inference; may post a previously-held text part later).
 - `message.part.updated` policy:
   - `text`: user is posted immediately; assistant is posted only when finalized (when `part.time.end` exists)
+    - Embed titles are `User says` / `Agent says`
   - `tool`: not posted
   - `reasoning`: not posted (to avoid exposing internal thoughts)
+- `SEND_PARAMS` controls embed fields only (it does not affect title/description/content/timestamp). `share` is not an embed field (but Session started uses `shareUrl` as the embed URL).
 
 ## Manual test
 

package/dist/index.d.ts

@@ -1,5 +1,68 @@
 import { Plugin } from '@opencode-ai/plugin';
 
+type DiscordWebhookMessageResponse = {
+    id: string;
+    channel_id: string;
+};
+type DiscordEmbed = {
+    title?: string;
+    description?: string;
+    url?: string;
+    color?: number;
+    timestamp?: string;
+    fields?: Array<{
+        name: string;
+        value: string;
+        inline?: boolean;
+    }>;
+};
+type DiscordAllowedMentions = {
+    parse?: Array<'everyone' | 'roles' | 'users'>;
+    roles?: string[];
+    users?: string[];
+};
+type DiscordExecuteWebhookBody = {
+    content?: string;
+    username?: string;
+    avatar_url?: string;
+    thread_name?: string;
+    embeds?: DiscordEmbed[];
+    allowed_mentions?: DiscordAllowedMentions;
+};
+declare function toIsoTimestamp(ms: unknown): string | undefined;
+declare function buildFields(fields: Array<[string, unknown]>, inline?: boolean): DiscordEmbed['fields'];
+declare function buildMention(mention: string | undefined, nameForLog: string): {
+    content?: string;
+    allowed_mentions?: DiscordAllowedMentions;
+} | undefined;
+declare function buildTodoChecklist(todos: unknown): string;
+type ToastVariant = 'info' | 'success' | 'warning' | 'error';
+type MaybeAlertError = (input: {
+    key: string;
+    title?: string;
+    message: string;
+    variant: ToastVariant;
+}) => Promise<void>;
+type PostDiscordWebhookDeps = {
+    showErrorAlert: boolean;
+    maybeAlertError: MaybeAlertError;
+    waitOnRateLimitMs: number;
+    fetchImpl?: typeof fetch;
+    sleepImpl?: (ms: number) => Promise<void>;
+};
+declare function postDiscordWebhook(input: {
+    webhookUrl: string;
+    threadId?: string;
+    wait?: boolean;
+    body: DiscordExecuteWebhookBody;
+}, deps: PostDiscordWebhookDeps): Promise<DiscordWebhookMessageResponse | undefined>;
 declare const plugin: Plugin;
+declare const __test__: {
+    buildMention: typeof buildMention;
+    buildTodoChecklist: typeof buildTodoChecklist;
+    buildFields: typeof buildFields;
+    toIsoTimestamp: typeof toIsoTimestamp;
+    postDiscordWebhook: typeof postDiscordWebhook;
+};
 
-export { plugin as default };
+export { __test__, plugin as default };

package/dist/index.js

@@ -1,4 +1,17 @@
 // src/index.ts
+var SEND_PARAM_KEYS = [
+  "sessionID",
+  "permissionID",
+  "type",
+  "pattern",
+  "messageID",
+  "callID",
+  "partID",
+  "role",
+  "directory",
+  "projectID"
+];
+var SEND_PARAM_KEY_SET = new Set(SEND_PARAM_KEYS);
 var COLORS = {
   info: 5793266,
   success: 5763719,
@@ -32,6 +45,23 @@ function buildFields(fields, inline = false) {
   }
   return result.length ? result : void 0;
 }
+function isSendParamKey(value) {
+  return SEND_PARAM_KEY_SET.has(value);
+}
+function filterSendFields(fields, allowed) {
+  return fields.filter(([name]) => {
+    if (!isSendParamKey(name)) return false;
+    return allowed.has(name);
+  });
+}
+function getTextPartEmbedTitle(role) {
+  return role === "user" ? "User says" : "Agent says";
+}
+function withForcedSendParams(base, forced) {
+  const next = new Set(base);
+  for (const key of forced) next.add(key);
+  return next;
+}
 function getEnv(name) {
   try {
     return process.env[name];
@@ -39,6 +69,17 @@ function getEnv(name) {
     return void 0;
   }
 }
+function parseSendParams(raw) {
+  if (raw === void 0) return new Set(SEND_PARAM_KEYS);
+  const tokens = raw.split(",").map((v) => v.trim()).filter(Boolean);
+  if (!tokens.length) return new Set(SEND_PARAM_KEYS);
+  const result = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    if (!SEND_PARAM_KEY_SET.has(token)) continue;
+    result.add(token);
+  }
+  return result;
+}
 function withQuery(url, params) {
   const u = new URL(url);
   for (const [k, v] of Object.entries(params)) {
@@ -47,45 +88,165 @@ function withQuery(url, params) {
   }
   return u.toString();
 }
-async function postDiscordWebhook(input) {
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function truncateText(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  if (maxLength <= 3) return value.slice(0, maxLength);
+  return value.slice(0, maxLength - 3) + "...";
+}
+function buildMention(mention, nameForLog) {
+  void nameForLog;
+  if (!mention) return void 0;
+  if (mention === "@everyone" || mention === "@here") {
+    return {
+      content: mention,
+      allowed_mentions: {
+        parse: ["everyone"]
+      }
+    };
+  }
+  return {
+    content: mention,
+    allowed_mentions: {
+      parse: []
+    }
+  };
+}
+function normalizeTodoContent(value) {
+  return safeString(value).replace(/\s+/g, " ").trim();
+}
+function buildTodoChecklist(todos) {
+  const maxDescription = 4096;
+  const items = Array.isArray(todos) ? todos : [];
+  let matchCount = 0;
+  let description = "";
+  let truncated = false;
+  for (const item of items) {
+    const status = item?.status;
+    if (status === "cancelled") continue;
+    const content = normalizeTodoContent(item?.content);
+    if (!content) continue;
+    const marker = status === "completed" ? "[\u2713]" : status === "in_progress" ? "[\u25B6]" : "[ ]";
+    const line = `> ${marker} ${truncateText(content, 200)}`;
+    const nextChunk = (description ? "\n" : "") + line;
+    if (description.length + nextChunk.length > maxDescription) {
+      truncated = true;
+      break;
+    }
+    description += nextChunk;
+    matchCount += 1;
+  }
+  if (!description) {
+    return "> (no todos)";
+  }
+  if (truncated || matchCount < items.length) {
+    const moreLine = `${description ? "\n" : ""}> ...and more`;
+    if (description.length + moreLine.length <= maxDescription) {
+      description += moreLine;
+    }
+  }
+  return description;
+}
+async function postDiscordWebhook(input, deps) {
   const { webhookUrl, threadId, wait, body } = input;
+  const fetchImpl = deps.fetchImpl ?? globalThis.fetch;
+  const sleepImpl = deps.sleepImpl ?? sleep;
   const url = withQuery(webhookUrl, {
     thread_id: threadId,
     wait: wait ? "true" : void 0
   });
-  const response = await fetch(url, {
+  const requestInit = {
     method: "POST",
     headers: {
       "content-type": "application/json"
     },
     body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new Error(
-      `Discord webhook failed: ${response.status} ${response.statusText} ${text}`
-    );
-  }
-  if (!wait) return void 0;
-  const json = await response.json().catch(() => void 0);
-  if (!json || typeof json !== "object") return void 0;
-  const channelId = json.channel_id;
-  const messageId = json.id;
-  if (typeof channelId !== "string" || typeof messageId !== "string")
+  };
+  const doRequest = async () => {
+    return await fetchImpl(url, requestInit);
+  };
+  const parseRetryAfterFromText = (text2) => {
+    if (!text2) return void 0;
+    try {
+      const json = JSON.parse(text2);
+      const value = json?.retry_after;
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+        return value;
+      }
+    } catch {
+    }
     return void 0;
-  return {
-    id: messageId,
-    channel_id: channelId
   };
+  const parseRetryAfterFromHeader = (headers) => {
+    const raw = headers.get("Retry-After");
+    if (!raw) return void 0;
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < 0) return void 0;
+    return value;
+  };
+  const response = await doRequest();
+  if (response.ok) {
+    if (!wait) return void 0;
+    const json = await response.json().catch(() => void 0);
+    if (!json || typeof json !== "object") return void 0;
+    const channelId = json.channel_id;
+    const messageId = json.id;
+    if (typeof channelId !== "string" || typeof messageId !== "string")
+      return void 0;
+    return { id: messageId, channel_id: channelId };
+  }
+  if (response.status === 429) {
+    const text2 = await response.text().catch(() => "");
+    const retryAfterSeconds = parseRetryAfterFromText(text2) ?? parseRetryAfterFromHeader(response.headers);
+    const waitMs = retryAfterSeconds === void 0 ? deps.waitOnRateLimitMs : Math.ceil(retryAfterSeconds * 1e3);
+    await sleepImpl(waitMs);
+    const retryResponse = await doRequest();
+    if (!retryResponse.ok) {
+      if (deps.showErrorAlert) {
+        await deps.maybeAlertError({
+          key: `discord_webhook_error:${retryResponse.status}`,
+          title: "Discord webhook rate-limited",
+          message: `Discord webhook returned 429 (rate limited). Waited ${Math.round(
+            waitMs / 1e3
+          )}s and retried, but it still failed.`,
+          variant: "warning"
+        });
+      }
+      const retryText = await retryResponse.text().catch(() => "");
+      throw new Error(
+        `Discord webhook failed: ${retryResponse.status} ${retryResponse.statusText} ${retryText}`
+      );
+    }
+    if (!wait) return void 0;
+    const json = await retryResponse.json().catch(() => void 0);
+    if (!json || typeof json !== "object") return void 0;
+    const channelId = json.channel_id;
+    const messageId = json.id;
+    if (typeof channelId !== "string" || typeof messageId !== "string")
+      return void 0;
+    return { id: messageId, channel_id: channelId };
+  }
+  if (deps.showErrorAlert) {
+    await deps.maybeAlertError({
+      key: `discord_webhook_error:${response.status}`,
+      title: "Discord webhook error",
+      message: `Discord webhook failed: ${response.status} ${response.statusText}`,
+      variant: "error"
+    });
+  }
+  const text = await response.text().catch(() => "");
+  throw new Error(
+    `Discord webhook failed: ${response.status} ${response.statusText} ${text}`
+  );
 }
 var GLOBAL_GUARD_KEY = "__opencode_discord_notify_registered__";
-var plugin = async () => {
+var plugin = async ({ client }) => {
   const globalWithGuard = globalThis;
   if (globalWithGuard[GLOBAL_GUARD_KEY]) {
-    return {
-      event: async () => {
-      }
-    };
+    return { event: async () => {
+    } };
   }
   globalWithGuard[GLOBAL_GUARD_KEY] = true;
   const webhookUrl = getEnv("DISCORD_WEBHOOK_URL");
@@ -97,15 +258,44 @@ var plugin = async () => {
   const permissionMention = permissionMentionRaw || void 0;
   const excludeInputContextRaw = (getEnv("DISCORD_WEBHOOK_EXCLUDE_INPUT_CONTEXT") ?? "1").trim();
   const excludeInputContext = excludeInputContextRaw !== "0";
+  const showErrorAlertRaw = (getEnv("DISCORD_WEBHOOK_SHOW_ERROR_ALERT") ?? "1").trim();
+  const showErrorAlert = showErrorAlertRaw !== "0";
+  const waitOnRateLimitMs = 1e4;
+  const toastCooldownMs = 3e4;
+  const sendParams = parseSendParams(getEnv("SEND_PARAMS"));
+  const lastAlertAtByKey = /* @__PURE__ */ new Map();
+  const showToast = async ({ title, message, variant }) => {
+    try {
+      await client.tui.showToast({
+        body: { title, message, variant, duration: 8e3 }
+      });
+    } catch {
+    }
+  };
+  const maybeAlertError = async ({
+    key,
+    title,
+    message,
+    variant
+  }) => {
+    if (!showErrorAlert) return;
+    const now = Date.now();
+    const last = lastAlertAtByKey.get(key);
+    if (last !== void 0 && now - last < toastCooldownMs) return;
+    lastAlertAtByKey.set(key, now);
+    await showToast({ title, message, variant });
+  };
+  const postDeps = {
+    showErrorAlert,
+    maybeAlertError,
+    waitOnRateLimitMs
+  };
   const sessionToThread = /* @__PURE__ */ new Map();
-  const threadCreateInFlight = /* @__PURE__ */ new Map();
   const pendingPostsBySession = /* @__PURE__ */ new Map();
   const firstUserTextBySession = /* @__PURE__ */ new Map();
   const pendingTextPartsByMessageId = /* @__PURE__ */ new Map();
-  const sessionSerial = /* @__PURE__ */ new Map();
-  const lastSessionInfo = /* @__PURE__ */ new Map();
-  const lastPartSnapshotById = /* @__PURE__ */ new Map();
   const messageRoleById = /* @__PURE__ */ new Map();
+  const lastSessionInfo = /* @__PURE__ */ new Map();
   function normalizeThreadTitle(value) {
     return safeString(value).replace(/\s+/g, " ").trim();
   }
@@ -125,182 +315,104 @@ var plugin = async () => {
     if (fromSessionId) return fromSessionId.slice(0, 100);
     return "untitled";
   }
-  async function sendToChannel(body) {
-    if (!webhookUrl) return;
-    await postDiscordWebhook({
-      webhookUrl,
-      body: {
-        ...body,
-        username,
-        avatar_url: avatarUrl
-      }
+  async function ensureThread(sessionID) {
+    if (!webhookUrl) return void 0;
+    const existing = sessionToThread.get(sessionID);
+    if (existing) return existing;
+    const queue = pendingPostsBySession.get(sessionID);
+    const first = queue?.[0];
+    if (!first) return void 0;
+    const threadName = buildThreadName(sessionID);
+    const res = await postDiscordWebhook(
+      {
+        webhookUrl,
+        wait: true,
+        body: {
+          ...first,
+          thread_name: threadName,
+          username,
+          avatar_url: avatarUrl
+        }
+      },
+      postDeps
+    ).catch(async (e) => {
+      await postDiscordWebhook(
+        { webhookUrl, body: { ...first, username, avatar_url: avatarUrl } },
+        postDeps
+      ).catch(() => {
+      });
+      return void 0;
     });
+    if (res?.channel_id) {
+      sessionToThread.set(sessionID, res.channel_id);
+      const nextQueue = pendingPostsBySession.get(sessionID);
+      if (nextQueue?.[0] === first) {
+        nextQueue.shift();
+        if (nextQueue.length) pendingPostsBySession.set(sessionID, nextQueue);
+        else pendingPostsBySession.delete(sessionID);
+      }
+      return res.channel_id;
+    }
+    return void 0;
   }
   function enqueueToThread(sessionID, body) {
     const queue = pendingPostsBySession.get(sessionID) ?? [];
     queue.push(body);
     pendingPostsBySession.set(sessionID, queue);
   }
-  function enqueueSerial(sessionID, task) {
-    const prev = sessionSerial.get(sessionID) ?? Promise.resolve();
-    const next = prev.then(task, task);
-    sessionSerial.set(sessionID, next);
-    next.finally(() => {
-      if (sessionSerial.get(sessionID) === next) sessionSerial.delete(sessionID);
-    });
-    return next;
-  }
-  async function ensureThread(sessionID) {
-    if (!webhookUrl) return void 0;
-    const existingThreadId = sessionToThread.get(sessionID);
-    if (existingThreadId) return existingThreadId;
-    const inflight = threadCreateInFlight.get(sessionID);
-    if (inflight) return await inflight;
-    const create = (async () => {
-      const queue = pendingPostsBySession.get(sessionID) ?? [];
-      const first = queue.shift();
-      if (queue.length) pendingPostsBySession.set(sessionID, queue);
-      else pendingPostsBySession.delete(sessionID);
-      if (!first) return void 0;
-      const threadName = buildThreadName(sessionID);
-      try {
-        const res = await postDiscordWebhook({
-          webhookUrl,
-          wait: true,
-          body: {
-            ...first,
-            thread_name: threadName,
-            username,
-            avatar_url: avatarUrl
-          }
-        });
-        if (res?.channel_id) {
-          sessionToThread.set(sessionID, res.channel_id);
-          return res.channel_id;
-        }
-        warn(`failed to capture thread_id for session ${sessionID}`);
-        return void 0;
-      } catch (e) {
-        await sendToChannel(first);
-        return void 0;
-      } finally {
-        threadCreateInFlight.delete(sessionID);
-      }
-    })();
-    threadCreateInFlight.set(sessionID, create);
-    return await create;
-  }
   async function flushPending(sessionID) {
-    return enqueueSerial(sessionID, async () => {
-      if (!webhookUrl) return;
-      const threadId = sessionToThread.get(sessionID) ?? await ensureThread(sessionID);
-      const queue = pendingPostsBySession.get(sessionID);
-      if (!queue?.length) return;
-      try {
-        if (threadId) {
-          for (const body of queue) {
-            await postDiscordWebhook({
+    if (!webhookUrl) return;
+    const threadId = sessionToThread.get(sessionID) ?? await ensureThread(sessionID);
+    const queue = pendingPostsBySession.get(sessionID);
+    if (!queue?.length) return;
+    let sentCount = 0;
+    try {
+      if (threadId) {
+        for (const body of queue) {
+          await postDiscordWebhook(
+            {
               webhookUrl,
               threadId,
-              body: {
-                ...body,
-                username,
-                avatar_url: avatarUrl
-              }
-            });
-          }
-        } else {
-          for (const body of queue) {
-            await sendToChannel(body);
-          }
+              body: { ...body, username, avatar_url: avatarUrl }
+            },
+            postDeps
+          );
+          sentCount += 1;
+        }
+      } else {
+        for (const body of queue) {
+          await postDiscordWebhook(
+            { webhookUrl, body: { ...body, username, avatar_url: avatarUrl } },
+            postDeps
+          );
+          sentCount += 1;
         }
-      } finally {
-        pendingPostsBySession.delete(sessionID);
       }
-    });
+      pendingPostsBySession.delete(sessionID);
+    } catch (e) {
+      const current = pendingPostsBySession.get(sessionID);
+      if (!current?.length) throw e;
+      const rest = current.slice(sentCount);
+      if (rest.length) pendingPostsBySession.set(sessionID, rest);
+      else pendingPostsBySession.delete(sessionID);
+      throw e;
+    }
   }
   function shouldFlush(sessionID) {
     return sessionToThread.has(sessionID) || firstUserTextBySession.has(sessionID);
   }
-  function warn(message, error) {
-    if (error) console.warn(`[opencode-discord-notify] ${message}`, error);
-    else console.warn(`[opencode-discord-notify] ${message}`);
-  }
-  function buildMention(mention, nameForLog) {
-    if (!mention) return void 0;
-    if (mention === "@everyone" || mention === "@here") {
-      return {
-        content: mention,
-        allowed_mentions: {
-          parse: ["everyone"]
-        }
-      };
-    }
-    warn(
-      `${nameForLog} is set but unsupported: ${mention}. Only @everyone/@here are supported.`
-    );
-    return {
-      content: mention,
-      allowed_mentions: {
-        parse: []
-      }
-    };
-  }
   function buildCompleteMention() {
     return buildMention(completeMention, "DISCORD_WEBHOOK_COMPLETE_MENTION");
   }
   function buildPermissionMention() {
     return buildMention(permissionMention, "DISCORD_WEBHOOK_PERMISSION_MENTION");
   }
-  function normalizeTodoContent(value) {
-    return safeString(value).replace(/\s+/g, " ").trim();
-  }
-  function truncateText(value, maxLength) {
-    if (value.length <= maxLength) return value;
-    if (maxLength <= 3) return value.slice(0, maxLength);
-    return value.slice(0, maxLength - 3) + "...";
-  }
   function setIfChanged(map, key, next) {
     const prev = map.get(key);
     if (prev === next) return false;
     map.set(key, next);
     return true;
   }
-  function buildTodoChecklist(todos) {
-    const maxDescription = 4096;
-    const items = Array.isArray(todos) ? todos : [];
-    let matchCount = 0;
-    let description = "";
-    let truncated = false;
-    for (const item of items) {
-      const status = item?.status;
-      if (status === "cancelled") continue;
-      const content = normalizeTodoContent(item?.content);
-      if (!content) continue;
-      const marker = status === "completed" ? "[\u2713]" : status === "in_progress" ? "[\u25B6]" : "[ ]";
-      const line = `> ${marker} ${truncateText(content, 200)}`;
-      const nextChunk = (description ? "\n" : "") + line;
-      if (description.length + nextChunk.length > maxDescription) {
-        truncated = true;
-        break;
-      }
-      description += nextChunk;
-      matchCount += 1;
-    }
-    if (!description) {
-      return "> (no todos)";
-    }
-    if (truncated || matchCount < items.length) {
-      const moreLine = `${description ? "\n" : ""}> ...and more`;
-      if (description.length + moreLine.length <= maxDescription) {
-        description += moreLine;
-      }
-    }
-    return description;
-  }
-  if (!webhookUrl) {
-    warn("DISCORD_WEBHOOK_URL is not set; plugin will be a no-op");
-  }
   return {
     event: async ({ event }) => {
       try {
@@ -310,8 +422,6 @@ var plugin = async () => {
             const sessionID = info?.id;
             if (!sessionID) return;
             const title = info?.title ?? "(untitled)";
-            const directory = info?.directory;
-            const projectID = info?.projectID;
             const shareUrl = info?.share?.url;
             const createdAt = toIsoTimestamp(info?.time?.created);
             const embed = {
@@ -321,13 +431,19 @@ var plugin = async () => {
               color: COLORS.info,
               timestamp: createdAt,
               fields: buildFields(
-                [
-                  ["sessionID", sessionID],
-                  ["projectID", projectID],
-                  ["directory", directory],
-                  ["share", shareUrl]
-                ],
-                false
+                filterSendFields(
+                  [
+                    ["sessionID", sessionID],
+                    ["projectID", info?.projectID],
+                    ["directory", info?.directory],
+                    ["share", shareUrl]
+                  ],
+                  withForcedSendParams(sendParams, [
+                    "sessionID",
+                    "projectID",
+                    "directory"
+                  ])
+                )
               )
             };
             lastSessionInfo.set(sessionID, { title, shareUrl });
@@ -335,87 +451,6 @@ var plugin = async () => {
             if (shouldFlush(sessionID)) await flushPending(sessionID);
             return;
           }
-          case "permission.updated": {
-            const p = event.properties;
-            const sessionID = p?.sessionID;
-            if (!sessionID) return;
-            const embed = {
-              title: "Permission required",
-              description: p?.title,
-              color: COLORS.warning,
-              timestamp: toIsoTimestamp(p?.time?.created),
-              fields: buildFields(
-                [
-                  ["sessionID", sessionID],
-                  ["permissionID", p?.id],
-                  ["type", p?.type],
-                  ["pattern", p?.pattern],
-                  ["messageID", p?.messageID],
-                  ["callID", p?.callID]
-                ],
-                false
-              )
-            };
-            const mention = buildPermissionMention();
-            enqueueToThread(sessionID, {
-              content: mention ? `${mention.content} Permission required` : void 0,
-              allowed_mentions: mention?.allowed_mentions,
-              embeds: [embed]
-            });
-            if (shouldFlush(sessionID)) await flushPending(sessionID);
-            return;
-          }
-          case "session.idle": {
-            const sessionID = event.properties?.sessionID;
-            if (!sessionID) return;
-            const embed = {
-              title: "Session completed",
-              color: COLORS.success,
-              fields: buildFields([["sessionID", sessionID]], false)
-            };
-            const mention = buildCompleteMention();
-            enqueueToThread(sessionID, {
-              content: mention ? `${mention.content} Session completed` : void 0,
-              allowed_mentions: mention?.allowed_mentions,
-              embeds: [embed]
-            });
-            await flushPending(sessionID);
-            return;
-          }
-          case "session.error": {
-            const p = event.properties;
-            const sessionID = p?.sessionID;
-            const errorStr = safeString(p?.error);
-            const embed = {
-              title: "Session error",
-              color: COLORS.error,
-              description: errorStr ? errorStr.length > 4096 ? errorStr.slice(0, 4093) + "..." : errorStr : void 0,
-              fields: buildFields([["sessionID", sessionID]], false)
-            };
-            if (!sessionID) return;
-            const mention = buildCompleteMention();
-            enqueueToThread(sessionID, {
-              content: mention ? `${mention.content} Session error` : void 0,
-              allowed_mentions: mention?.allowed_mentions,
-              embeds: [embed]
-            });
-            await flushPending(sessionID);
-            return;
-          }
-          case "todo.updated": {
-            const p = event.properties;
-            const sessionID = p?.sessionID;
-            if (!sessionID) return;
-            const embed = {
-              title: "Todo updated",
-              color: COLORS.info,
-              fields: buildFields([["sessionID", sessionID]], false),
-              description: buildTodoChecklist(p?.todos)
-            };
-            enqueueToThread(sessionID, { embeds: [embed] });
-            if (shouldFlush(sessionID)) await flushPending(sessionID);
-            return;
-          }
           case "message.updated": {
             const info = event.properties?.info;
             const messageID = info?.id;
@@ -433,33 +468,32 @@ var plugin = async () => {
                   if (!sessionID || !partID || type !== "text") continue;
                   const text = safeString(pendingPart?.text);
                   if (role === "user" && excludeInputContext && isInputContextText(text)) {
-                    const snapshot2 = JSON.stringify({
+                    const snapshot = JSON.stringify({
                       type,
                       role,
                       skipped: "input_context"
                     });
-                    setIfChanged(lastPartSnapshotById, partID, snapshot2);
+                    setIfChanged(/* @__PURE__ */ new Map(), partID, snapshot);
                     continue;
                   }
-                  const snapshot = JSON.stringify({ type, role, text });
-                  if (!setIfChanged(lastPartSnapshotById, partID, snapshot))
-                    continue;
                   if (role === "user" && !firstUserTextBySession.has(sessionID)) {
                     const normalized = normalizeThreadTitle(text);
                     if (normalized)
                       firstUserTextBySession.set(sessionID, normalized);
                   }
                   const embed = {
-                    title: role === "user" ? "Message part updated: text (user)" : "Message part updated: text (assistant)",
+                    title: getTextPartEmbedTitle(role),
                     color: COLORS.info,
                     fields: buildFields(
-                      [
-                        ["sessionID", sessionID],
-                        ["messageID", messageID],
-                        ["partID", partID],
-                        ["role", role]
-                      ],
-                      false
+                      filterSendFields(
+                        [
+                          ["sessionID", sessionID],
+                          ["messageID", messageID],
+                          ["partID", partID],
+                          ["role", role]
+                        ],
+                        sendParams
+                      )
                     ),
                     description: truncateText(text || "(empty)", 4096)
                   };
@@ -480,43 +514,43 @@ var plugin = async () => {
             const type = part?.type;
             if (!sessionID || !messageID || !partID || !type) return;
             if (type === "reasoning") return;
+            const role = messageRoleById.get(messageID);
+            if (role !== "assistant" && role !== "user") {
+              const list = pendingTextPartsByMessageId.get(messageID) ?? [];
+              list.push(part);
+              pendingTextPartsByMessageId.set(messageID, list);
+              return;
+            }
             if (type === "text") {
-              const role = messageRoleById.get(messageID);
-              if (role !== "assistant" && role !== "user") {
-                const list = pendingTextPartsByMessageId.get(messageID) ?? [];
-                list.push(part);
-                pendingTextPartsByMessageId.set(messageID, list);
-                return;
-              }
               if (role === "assistant" && !part?.time?.end) return;
               const text = safeString(part?.text);
               if (role === "user" && excludeInputContext && isInputContextText(text)) {
-                const snapshot2 = JSON.stringify({
+                const snapshot = JSON.stringify({
                   type,
                   role,
                   skipped: "input_context"
                 });
-                setIfChanged(lastPartSnapshotById, partID, snapshot2);
+                setIfChanged(/* @__PURE__ */ new Map(), partID, snapshot);
                 return;
               }
-              const snapshot = JSON.stringify({ type, role, text });
-              if (!setIfChanged(lastPartSnapshotById, partID, snapshot)) return;
               if (role === "user" && !firstUserTextBySession.has(sessionID)) {
                 const normalized = normalizeThreadTitle(text);
                 if (normalized)
                   firstUserTextBySession.set(sessionID, normalized);
               }
               const embed = {
-                title: role === "user" ? "Message part updated: text (user)" : "Message part updated: text (assistant)",
+                title: getTextPartEmbedTitle(role),
                 color: COLORS.info,
                 fields: buildFields(
-                  [
-                    ["sessionID", sessionID],
-                    ["messageID", messageID],
-                    ["partID", partID],
-                    ["role", role]
-                  ],
-                  false
+                  filterSendFields(
+                    [
+                      ["sessionID", sessionID],
+                      ["messageID", messageID],
+                      ["partID", partID],
+                      ["role", role]
+                    ],
+                    sendParams
+                  )
                 ),
                 description: truncateText(text || "(empty)", 4096)
               };
@@ -526,21 +560,26 @@ var plugin = async () => {
               } else if (shouldFlush(sessionID)) {
                 await flushPending(sessionID);
               }
-              return;
             }
-            if (type === "tool") return;
             return;
           }
           default:
             return;
         }
-      } catch (e) {
-        warn(`failed handling event ${event.type}`, e);
+      } catch {
       }
     }
   };
 };
+var __test__ = {
+  buildMention,
+  buildTodoChecklist,
+  buildFields,
+  toIsoTimestamp,
+  postDiscordWebhook
+};
 var index_default = plugin;
 export {
+  __test__,
   index_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-discord-notify",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "A plugin that posts OpenCode events to a Discord webhook.",
   "license": "MIT",
   "type": "module",
@@ -27,6 +27,7 @@
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --out-dir dist --clean",
     "format": "prettier . --write",
+    "test": "vitest run",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
@@ -38,7 +39,8 @@
     "prettier": "^3.7.4",
     "prettier-plugin-organize-imports": "^4.3.0",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.16"
   },
   "keywords": [
     "opencode",