opencode-discord-notify 0.5.1 → 0.7.0

package/README.md

@@ -8,35 +8,28 @@
 ![Discord Webhook](https://img.shields.io/badge/Discord-Webhook-5865F2?logo=discord&logoColor=fff)
 ![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=fff)
 
-English | [日本語](README-JP.md)
-
 <p align="center">
   <img src="assets/image/sample-forum-ch.png" width="700" alt="Discord Forum channel example" />
 </p>
 
-A plugin that posts OpenCode events to a Discord webhook.
+**Get real-time OpenCode notifications directly in your Discord server.**
 
-It is optimized for Discord Forum channel webhooks: it creates one thread per session (via `thread_name`) and posts subsequent updates to the same thread.
-It also works with regular text channel webhooks (in that case, it falls back to posting directly to the channel because threads cannot be created).
+This plugin creates organized threads in Discord Forum channels for each OpenCode session, keeping you updated on session events, permissions, todos, and conversations.
 
-## What it does
+## Features
 
-- `session.created`: session started → queues a start notification (thread creation / sending may happen later when required info is available)
-- `permission.updated`: permission request → posts a notification
-- `session.idle`: session finished → posts a notification
-- `session.error`: error → posts a notification (skips if `sessionID` is not present)
-- `todo.updated`: todo updates → posts a checklist (keeps received order; excludes `cancelled`)
-- `message.updated`: does not notify (tracked for role inference; may emit previously-held `text` later)
-- `message.part.updated`: message content/tool results updates →
-  - `text`: user text is posted immediately; assistant text is posted only when finalized (when `time.end` exists)
-  - `tool`: not posted
-  - `reasoning`: not posted
+- **Session tracking**: Automatic thread creation for each session
+- **Real-time updates**: Permission requests, session completion, errors
+- **Todo checklists**: Visual todo updates with status icons
+- **Smart notifications**: User messages sent immediately, agent responses when finalized
+- **Mention support**: Optional `@everyone` or `@here` mentions for important events
+- **Fallback webhooks**: Send critical mentions to text channels for guaranteed delivery
 
-## Setup
+## Quick Start
 
-### 1) Add the plugin
+### 1. Install the plugin
 
-Add this plugin to your `opencode.json` / `opencode.jsonc` and restart OpenCode.
+Add to your `opencode.json` or `opencode.jsonc`:
 
 ```jsonc
 {
@@ -44,76 +37,232 @@ Add this plugin to your `opencode.json` / `opencode.jsonc` and restart OpenCode.
 }
 ```
 
-### 2) Create a Discord webhook
-
-- Recommended: create a webhook in a Discord Forum channel.
-- A webhook in a regular text channel also works, but thread creation using `thread_name` is a Forum-oriented behavior.
-
-### 3) Environment variables
-
-Required:
-
-- `DISCORD_WEBHOOK_URL`: Discord webhook URL (if not set, the plugin does nothing)
-
-Optional:
-
-- `DISCORD_WEBHOOK_USERNAME`: username for webhook posts
-- `DISCORD_WEBHOOK_AVATAR_URL`: avatar URL for webhook posts
-- `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)
-- `DISCORD_SEND_PARAMS`: comma-separated list of keys to include as embed fields.
-  - **Allowed keys**: `sessionID`, `permissionID`, `type`, `pattern`, `messageID`, `callID`, `partID`, `role`, `directory`, `projectID`
-  - **Default behavior** (unset/empty): all fields are disabled (nothing sent)
-  - **To send all fields**: list all keys explicitly
-  - **Note**: `session.created` always includes `sessionID` regardless
-
-## Notes / behavior
-
-- 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`
-  2. session title
-  3. `session <sessionID>`
-  4. `untitled`
-- If thread creation fails (e.g. on non-Forum webhooks), it falls back to posting directly to the channel.
-- `permission.updated` / `session.idle` may be queued until the thread name becomes available.
-- `session.error` is skipped when `sessionID` is missing in the upstream payload.
-- `DISCORD_WEBHOOK_COMPLETE_MENTION=@everyone` (or `@here`) is included as message content, but Forum webhooks may not actually ping (it may just show as plain text).
-- `DISCORD_WEBHOOK_PERMISSION_MENTION=@everyone` (or `@here`) is included as message content for `permission.updated`, but Forum webhooks may not actually ping (it may just show as plain text).
-- `todo.updated` posts a checklist in the order received (`in_progress` = `[▶]`, `completed` = `[✓]`, `cancelled` excluded). Long lists may be truncated to fit embed constraints (if empty: `(no todos)`; if truncated: adds `...and more`).
-- `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)
-- `DISCORD_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
-
-1. Start OpenCode → a new thread appears in the Forum channel on the first notification timing
-2. Trigger a permission request → a notification is posted to the same thread (if the thread isn't created yet, it may be created later)
-3. Finish the session → `session.idle` is posted (if you set `DISCORD_WEBHOOK_COMPLETE_MENTION`, it may not actually ping in Forum webhooks)
-4. Trigger an error → `session.error` is posted (skipped if no `sessionID`; if you set `DISCORD_WEBHOOK_COMPLETE_MENTION`, it may not actually ping in Forum webhooks)
+Restart OpenCode.
+
+### 2. Create a Discord webhook
+
+1. Open your Discord server settings
+2. Go to a **Forum channel** (recommended) or text channel
+3. Navigate to **Integrations** → **Webhooks**
+4. Click **New Webhook** and copy the webhook URL
+
+### 3. Set the webhook URL
+
+Set the environment variable:
+
+```bash
+export DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/..."
+```
+
+**That's it!** Start using OpenCode and watch notifications appear in Discord.
+
+## Configuration
+
+### Environment Variables
+
+| Variable                                | Required | Default                                        | Description                                                                                                          |
+| --------------------------------------- | -------- | ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `DISCORD_WEBHOOK_URL`                   | ✅ Yes   | -                                              | Discord webhook URL. Plugin is disabled if not set.                                                                  |
+| `DISCORD_WEBHOOK_USERNAME`              | ❌ No    | -                                              | Custom username for webhook posts                                                                                    |
+| `DISCORD_WEBHOOK_AVATAR_URL`            | ❌ No    | -                                              | Custom avatar URL for webhook posts                                                                                  |
+| `DISCORD_WEBHOOK_COMPLETE_MENTION`      | ❌ No    | -                                              | Add `@everyone` or `@here` to session completion/error notifications                                                 |
+| `DISCORD_WEBHOOK_PERMISSION_MENTION`    | ❌ No    | -                                              | Add `@everyone` or `@here` to permission request notifications                                                       |
+| `DISCORD_WEBHOOK_EXCLUDE_INPUT_CONTEXT` | ❌ No    | `1`                                            | Set to `0` to include file context in notifications                                                                  |
+| `DISCORD_WEBHOOK_SHOW_ERROR_ALERT`      | ❌ No    | `1`                                            | Set to `0` to disable error toast notifications                                                                      |
+| `DISCORD_SEND_PARAMS`                   | ❌ No    | -                                              | Comma-separated embed fields: `sessionID,permissionID,type,pattern,messageID,callID,partID,role,directory,projectID` |
+| `DISCORD_WEBHOOK_FALLBACK_URL`          | ❌ No    | -                                              | Fallback webhook URL for text channel (sends mentions here too for guaranteed ping)                                  |
+| `DISCORD_NOTIFY_QUEUE_DB_PATH`          | ❌ No    | `~/.config/opencode/discord-notify-queue.db`   | Custom path for the persistent queue database (automatically uses `:memory:` in test environment)                    |
+
+### Example Configuration
+
+**Basic usage:**
+
+```bash
+export DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/your-webhook-url"
+```
+
+**With mentions and fallback:**
+
+```bash
+export DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/forum-webhook-url"
+export DISCORD_WEBHOOK_FALLBACK_URL="https://discord.com/api/webhooks/text-channel-webhook-url"
+export DISCORD_WEBHOOK_COMPLETE_MENTION="@everyone"
+export DISCORD_WEBHOOK_PERMISSION_MENTION="@here"
+```
+
+**With custom appearance:**
+
+```bash
+export DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/your-webhook-url"
+export DISCORD_WEBHOOK_USERNAME="OpenCode Bot"
+export DISCORD_WEBHOOK_AVATAR_URL="https://example.com/avatar.png"
+```
+
+## Advanced
+
+<details>
+<summary><strong>Event Handling Details</strong></summary>
+
+### Supported Events
+
+- **`session.created`**: Queues session start notification (sent when thread info is available)
+- **`permission.updated`**: Posts permission request immediately
+- **`session.idle`**: Posts session completion notification
+- **`session.error`**: Posts error notification (skipped if `sessionID` missing)
+- **`todo.updated`**: Posts checklist with `[▶]` (in progress), `[✓]` (completed); excludes cancelled
+- **`message.updated`**: Tracked internally for role detection (not posted)
+- **`message.part.updated`**:
+  - `text`: User messages posted immediately; agent messages posted when finalized
+  - `tool`: Not posted
+  - `reasoning`: Not posted
+
+</details>
+
+<details>
+<summary><strong>Thread Creation Behavior</strong></summary>
+
+### Thread Naming Priority
+
+Thread names use the first available option (max 100 chars):
+
+1. First user text message
+2. Session title
+3. `session <sessionID>`
+4. `untitled`
+
+### Forum vs Text Channel
+
+- **Forum channels**: Creates a new thread per session using `thread_name`
+- **Text channels**: Posts directly (threads not supported)
+- **Fallback**: If thread creation fails, falls back to direct channel posting
+
+</details>
+
+<details>
+<summary><strong>Mention & Fallback Behavior</strong></summary>
+
+### Why Fallback Webhooks?
+
+Discord Forum webhooks **do not trigger pings** for `@everyone` or `@here` mentions. They appear as plain text.
+
+To ensure you get notified:
+
+1. Set `DISCORD_WEBHOOK_URL` to your Forum webhook (for organized threads)
+2. Set `DISCORD_WEBHOOK_FALLBACK_URL` to a text channel webhook (for actual pings)
+3. Messages with mentions will be sent to **both** webhooks
+
+### Fallback Message Format
+
+Fallback messages always include:
+
+- `sessionID` field
+- `thread title` field (same as Forum thread name)
+
+This provides context when viewing notifications in the text channel.
+
+</details>
+
+<details>
+<summary><strong>Error Handling & Rate Limits</strong></summary>
+
+### Persistent Queue (v0.7.0+)
+
+All notifications are stored in a local SQLite database before sending:
+
+- **Database location**: `~/.config/opencode/discord-notify-queue.db` (customizable via `DISCORD_NOTIFY_QUEUE_DB_PATH`)
+- **Worker process**: Automatically processes queued messages in the background
+- **Auto-start**: Worker starts when first user message is sent
+- **Auto-stop**: Worker stops when queue is empty
+- **Batch size**: Processes 1 message at a time to ensure thread ID consistency
+
+**Benefits**:
+- Messages survive OpenCode restarts
+- Prevents data loss during network issues
+- Ensures correct thread naming with user's first message
+
+### Retry Logic
+
+All failed requests are automatically retried with the following behavior:
+
+- **Max retries**: 5 attempts per message
+- **Retry tracking**: Each retry updates `retry_count` and `last_error` in the queue database
+- **Warning notifications**: Shows toast with retry count (e.g., "Retry 3/5. Error: ...")
+- **Final failure**: After 5 failed retries, message is deleted and error notification is shown
+
+### HTTP 429 (Rate Limit)
+
+- Waits for `retry_after` seconds (or ~10s if not provided)
+- Automatically retries up to 5 times before discarding
+- Messages remain in queue database during retry period
+
+### Other Failed Requests
+
+- Shows OpenCode TUI toast notification (controlled by `DISCORD_WEBHOOK_SHOW_ERROR_ALERT`)
+- Logs error details for debugging
+- Messages persist in queue for up to 5 retry attempts
+
+</details>
+
+<details>
+<summary><strong>Field Customization</strong></summary>
+
+### `DISCORD_SEND_PARAMS`
+
+Controls which metadata fields appear in embeds.
+
+**Allowed keys:**
+
+- `sessionID`, `permissionID`, `type`, `pattern`, `messageID`, `callID`, `partID`, `role`, `directory`, `projectID`
+
+**Default behavior (unset/empty):**
+
+- No fields sent (cleaner embeds)
+
+**To send all fields:**
+
+```bash
+export DISCORD_SEND_PARAMS="sessionID,permissionID,type,pattern,messageID,callID,partID,role,directory,projectID"
+```
+
+**Note:** `session.created` always includes `sessionID` regardless of this setting.
+
+</details>
 
 ## Development
 
-- Install deps: `npm i`
-- Format: `npx prettier . --write`
-- Plugin source: `src/index.ts`
+### Setup
+
+```bash
+npm install
+```
+
+### Format Code
+
+```bash
+npx prettier . --write
+```
+
+### Plugin Source
+
+Main implementation: `src/index.ts`
+
+## Roadmap
+
+- [ ] Support multiple webhooks for routing by event type
+- [ ] Customizable notification templates
+- [ ] Configuration file support (e.g., `opencode-discord-notify.config.json`)
+- [x] Enhanced rate limit handling (smarter retry logic, message queuing)
+- [x] CI/CD (automated linting, formatting, testing)
+
+## Contributing
+
+PRs and issues are welcome! Please feel free to:
 
-## Roadmap (planned)
+- Report bugs
+- Request features
+- Submit improvements
+- Share feedback
 
-- Publish as an npm package (to make install/update easier)
-- Support multiple webhooks / multiple channels (route by use case)
-- Allow customizing notifications (events, message templates, mention policy)
-  - Consider reading a config file (e.g. `opencode-discord-notify.config.json`) and resolving values from env vars as needed
-- Improve Discord limitations handling (rate-limit retry, split posts, better truncation rules)
-- Improve CI (automate lint/format; add basic tests)
+---
 
-PRs and issues are welcome.
+**License:** MIT

package/dist/index.d.ts

@@ -1,5 +1,30 @@
 import { Plugin } from '@opencode-ai/plugin';
 
+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 const plugin: Plugin;
 
-export { plugin as default };
+export { type DiscordExecuteWebhookBody, plugin as default };

package/dist/index.js

@@ -1,3 +1,210 @@
+// src/utils/db.ts
+import { Database } from "bun:sqlite";
+import fs from "fs";
+import os from "os";
+import path from "path";
+function getDbPath() {
+  if (process.env.NODE_ENV === "test" || process.env.VITEST === "true") {
+    return ":memory:";
+  }
+  return process.env.DISCORD_NOTIFY_QUEUE_DB_PATH || path.join(os.homedir(), ".config", "opencode", "discord-notify-queue.db");
+}
+function initDatabase() {
+  const dbPath = getDbPath();
+  if (dbPath !== ":memory:") {
+    const dbDir = path.dirname(dbPath);
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+    }
+  }
+  const db = new Database(dbPath);
+  db.run("PRAGMA journal_mode = WAL;");
+  db.run(`
+    CREATE TABLE IF NOT EXISTS discord_queue (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      thread_id TEXT,
+      webhook_body TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      retry_count INTEGER DEFAULT 0,
+      last_error TEXT
+    );
+  `);
+  db.run(`
+    CREATE INDEX IF NOT EXISTS idx_session_created
+    ON discord_queue(session_id, created_at);
+  `);
+  return db;
+}
+
+// src/queue/persistent-queue.ts
+var PersistentQueue = class {
+  db;
+  constructor(deps) {
+    this.db = deps.db;
+  }
+  enqueue(message) {
+    const query = this.db.query(`
+      INSERT INTO discord_queue (session_id, thread_id, webhook_body, created_at)
+      VALUES (?, ?, ?, ?)
+    `);
+    query.run(
+      message.sessionId,
+      message.threadId,
+      JSON.stringify(message.webhookBody),
+      Date.now()
+    );
+  }
+  dequeue(limit) {
+    const query = this.db.query(`
+      SELECT * FROM discord_queue
+      ORDER BY created_at ASC, id ASC
+      LIMIT ?
+    `);
+    const rows = query.all(limit);
+    return rows.map((row) => ({
+      id: row.id,
+      sessionId: row.session_id,
+      threadId: row.thread_id,
+      webhookBody: JSON.parse(row.webhook_body),
+      createdAt: row.created_at,
+      retryCount: row.retry_count,
+      lastError: row.last_error
+    }));
+  }
+  delete(id) {
+    this.db.query("DELETE FROM discord_queue WHERE id = ?").run(id);
+  }
+  updateThreadId(sessionId, threadId) {
+    this.db.query(
+      `
+      UPDATE discord_queue
+      SET thread_id = ?
+      WHERE session_id = ? AND thread_id IS NULL
+    `
+    ).run(threadId, sessionId);
+  }
+  count() {
+    const result = this.db.query("SELECT COUNT(*) as count FROM discord_queue").get();
+    return result.count;
+  }
+  updateRetryCount(id, retryCount, lastError) {
+    this.db.query(
+      `
+      UPDATE discord_queue
+      SET retry_count = ?, last_error = ?
+      WHERE id = ?
+    `
+    ).run(retryCount, lastError, id);
+  }
+};
+
+// src/queue/worker.ts
+var POLL_INTERVAL_MS = 1e3;
+var BATCH_SIZE = 1;
+var MAX_RETRIES = 5;
+var QueueWorker = class {
+  deps;
+  isRunning = false;
+  abortController;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get running() {
+    return this.isRunning;
+  }
+  async start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.abortController = new AbortController();
+    await this.poll(this.abortController.signal);
+  }
+  stop() {
+    this.abortController?.abort();
+    this.isRunning = false;
+  }
+  async poll(signal) {
+    while (!signal.aborted) {
+      const messages = this.deps.queue.dequeue(BATCH_SIZE);
+      if (messages.length === 0) {
+        this.stop();
+        return;
+      }
+      for (const message of messages) {
+        if (signal.aborted) break;
+        await this.processMessage(message);
+      }
+      await this.sleep(POLL_INTERVAL_MS);
+    }
+  }
+  async processMessage(message) {
+    try {
+      if (!message.threadId) {
+        const threadName = this.deps.buildThreadName(message.sessionId);
+        const res = await this.deps.postWebhook(
+          {
+            webhookUrl: this.deps.webhookUrl,
+            wait: true,
+            body: {
+              ...message.webhookBody,
+              thread_name: threadName,
+              username: this.deps.username,
+              avatar_url: this.deps.avatarUrl
+            }
+          },
+          this.deps.postDeps
+        );
+        if (res?.channel_id) {
+          this.deps.queue.updateThreadId(message.sessionId, res.channel_id);
+          message.threadId = res.channel_id;
+          this.deps.onThreadCreated?.(message.sessionId, res.channel_id);
+        }
+        this.deps.queue.delete(message.id);
+        return;
+      }
+      await this.deps.postWebhook(
+        {
+          webhookUrl: this.deps.webhookUrl,
+          threadId: message.threadId,
+          body: {
+            ...message.webhookBody,
+            username: this.deps.username,
+            avatar_url: this.deps.avatarUrl
+          }
+        },
+        this.deps.postDeps
+      );
+      this.deps.queue.delete(message.id);
+    } catch (error) {
+      const currentRetry = message.retryCount || 0;
+      if (currentRetry < MAX_RETRIES) {
+        this.deps.queue.updateRetryCount(
+          message.id,
+          currentRetry + 1,
+          error.message || "Unknown error"
+        );
+        await this.deps.maybeAlertError({
+          key: `discord_queue_retry:${message.id}`,
+          title: "Discord notification retry",
+          message: `Failed to send notification. Retry ${currentRetry + 1}/${MAX_RETRIES}. Error: ${error.message}`,
+          variant: "warning"
+        });
+        return;
+      }
+      await this.deps.maybeAlertError({
+        key: `discord_queue_error:${message.id}`,
+        title: "Discord notification failed",
+        message: `Failed to send notification after ${MAX_RETRIES} retries. Message discarded.`,
+        variant: "error"
+      });
+      this.deps.queue.delete(message.id);
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
 // src/index.ts
 var DISCORD_FIELD_VALUE_MAX_LENGTH = 1024;
 var DISCORD_EMBED_DESCRIPTION_MAX_LENGTH = 4096;
@@ -260,6 +467,49 @@ async function postDiscordWebhook(input, deps) {
     `Discord webhook failed: ${response.status} ${response.statusText} ${text}`
   );
 }
+async function postFallbackIfNeeded(input, deps) {
+  const {
+    body,
+    mention,
+    sessionID,
+    fallbackUrl,
+    firstUserTextBySession,
+    lastSessionInfo
+  } = input;
+  if (!fallbackUrl || !mention) return;
+  const fallbackBody = {
+    ...body,
+    // thread_nameは削除（テキストチャネルでは不要）
+    thread_name: void 0
+  };
+  if (fallbackBody.embeds && fallbackBody.embeds.length > 0) {
+    const originalEmbed = fallbackBody.embeds[0];
+    const threadTitle = firstUserTextBySession.get(sessionID) || lastSessionInfo.get(sessionID)?.title;
+    const additionalFields = buildFields([
+      ["sessionID", sessionID],
+      ["thread title", threadTitle]
+    ]);
+    fallbackBody.embeds = [
+      {
+        ...originalEmbed,
+        fields: [
+          ...originalEmbed.fields ?? [],
+          ...additionalFields ?? []
+        ]
+      }
+    ];
+  }
+  try {
+    await postDiscordWebhook(
+      {
+        webhookUrl: fallbackUrl,
+        body: fallbackBody
+      },
+      deps
+    );
+  } catch (e) {
+  }
+}
 var GLOBAL_GUARD_KEY = "__opencode_discord_notify_registered__";
 var plugin = async ({ client }) => {
   const globalWithGuard = globalThis;
@@ -281,6 +531,7 @@ var plugin = async ({ client }) => {
   const showErrorAlert = showErrorAlertRaw !== "0";
   const waitOnRateLimitMs = DEFAULT_RATE_LIMIT_WAIT_MS;
   const sendParams = parseSendParams(getEnv("DISCORD_SEND_PARAMS"));
+  const fallbackWebhookUrl = (getEnv("DISCORD_WEBHOOK_FALLBACK_URL") ?? "").trim() || void 0;
   const lastAlertAtByKey = /* @__PURE__ */ new Map();
   const sentTextPartIds = /* @__PURE__ */ new Set();
   const showToast = async ({ title, message, variant }) => {
@@ -322,8 +573,22 @@ var plugin = async ({ client }) => {
     maybeAlertError,
     waitOnRateLimitMs
   };
+  const db = initDatabase();
+  const persistentQueue = new PersistentQueue({ db });
   const sessionToThread = /* @__PURE__ */ new Map();
-  const pendingPostsBySession = /* @__PURE__ */ new Map();
+  const queueWorker = new QueueWorker({
+    queue: persistentQueue,
+    postWebhook: postDiscordWebhook,
+    postDeps,
+    maybeAlertError,
+    webhookUrl: webhookUrl ?? "",
+    username,
+    avatarUrl,
+    buildThreadName: (sessionID) => buildThreadName(sessionID),
+    onThreadCreated: (sessionID, threadID) => {
+      sessionToThread.set(sessionID, threadID);
+    }
+  });
   const firstUserTextBySession = /* @__PURE__ */ new Map();
   const pendingTextPartsByMessageId = /* @__PURE__ */ new Map();
   const messageRoleById = /* @__PURE__ */ new Map();
@@ -347,97 +612,47 @@ var plugin = async ({ client }) => {
     );
     if (fromSessionId)
       return fromSessionId.slice(0, DISCORD_THREAD_NAME_MAX_LENGTH);
-    return "untitled";
-  }
-  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;
+    return "(untitled)";
+  }
+  function buildSessionCreatedEmbed(sessionID) {
+    const info = lastSessionInfo.get(sessionID);
+    if (!info) return void 0;
+    const embed = {
+      title: "Session started",
+      description: info.title,
+      url: info.shareUrl,
+      color: COLORS.info,
+      timestamp: info.createdAt,
+      fields: buildFields(
+        filterSendFields(
+          [
+            ["sessionID", sessionID],
+            ["projectID", info.projectID],
+            ["directory", info.directory],
+            ["share", info.shareUrl]
+          ],
+          withForcedSendParams(sendParams, ["sessionID"])
+        )
+      )
+    };
+    return { embeds: [embed] };
   }
   function enqueueToThread(sessionID, body) {
     if (!webhookUrl) {
       void showMissingUrlToastOnce();
       return;
     }
-    const queue = pendingPostsBySession.get(sessionID) ?? [];
-    queue.push(body);
-    pendingPostsBySession.set(sessionID, queue);
-  }
-  async function flushPending(sessionID) {
-    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 }
-            },
-            postDeps
-          );
-          sentCount += 1;
-        }
-      } else {
-        for (const body of queue) {
-          await postDiscordWebhook(
-            { webhookUrl, body: { ...body, username, avatar_url: avatarUrl } },
-            postDeps
-          );
-          sentCount += 1;
-        }
-      }
-      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;
-    }
+    const threadId = sessionToThread.get(sessionID) || null;
+    persistentQueue.enqueue({
+      sessionId: sessionID,
+      threadId,
+      webhookBody: body
+    });
   }
-  function shouldFlush(sessionID) {
-    return sessionToThread.has(sessionID) || firstUserTextBySession.has(sessionID);
+  function startWorkerIfNeeded() {
+    if (!queueWorker.running) {
+      void queueWorker.start();
+    }
   }
   function buildCompleteMention() {
     return buildMention(completeMention, "DISCORD_WEBHOOK_COMPLETE_MENTION");
@@ -462,10 +677,17 @@ var plugin = async ({ client }) => {
     if (role === "user" && text.trim() === "" || text.trim() === "(empty)") {
       return;
     }
-    if (role === "user" && !firstUserTextBySession.has(sessionID)) {
+    const isFirstUserText = role === "user" && !firstUserTextBySession.has(sessionID);
+    if (isFirstUserText) {
       const normalized = normalizeThreadTitle(text);
       if (normalized) firstUserTextBySession.set(sessionID, normalized);
     }
+    if (role === "user" && !sessionToThread.has(sessionID)) {
+      const sessionCreatedBody = buildSessionCreatedEmbed(sessionID);
+      if (sessionCreatedBody) {
+        enqueueToThread(sessionID, sessionCreatedBody);
+      }
+    }
     const embed = {
       title: getTextPartEmbedTitle(role),
       color: COLORS.info,
@@ -486,11 +708,7 @@ var plugin = async ({ client }) => {
       )
     };
     enqueueToThread(sessionID, { embeds: [embed] });
-    if (role === "user") {
-      await flushPending(sessionID);
-    } else if (shouldFlush(sessionID)) {
-      await flushPending(sessionID);
-    }
+    startWorkerIfNeeded();
   }
   return {
     event: async ({ event }) => {
@@ -500,35 +718,20 @@ var plugin = async ({ client }) => {
             const info = event.properties?.info;
             const sessionID = info?.id;
             if (!sessionID) return;
-            const title = info?.title ?? "(untitled)";
-            const shareUrl = info?.share?.url;
-            const createdAt = toIsoTimestamp(info?.time?.created);
-            const embed = {
-              title: "Session started",
-              description: title,
-              url: shareUrl,
-              color: COLORS.info,
-              timestamp: createdAt,
-              fields: buildFields(
-                filterSendFields(
-                  [
-                    ["sessionID", sessionID],
-                    ["projectID", info?.projectID],
-                    ["directory", info?.directory],
-                    ["share", shareUrl]
-                  ],
-                  withForcedSendParams(sendParams, ["sessionID"])
-                )
-              )
-            };
-            lastSessionInfo.set(sessionID, { title, shareUrl });
-            enqueueToThread(sessionID, { embeds: [embed] });
+            lastSessionInfo.set(sessionID, {
+              title: info?.title,
+              shareUrl: info?.share?.url,
+              createdAt: toIsoTimestamp(info?.time?.created),
+              projectID: info?.projectID,
+              directory: info?.directory
+            });
             return;
           }
           case "permission.updated": {
             const p = event.properties;
             const sessionID = p?.sessionID;
             if (!sessionID) return;
+            const mention = buildPermissionMention();
             const embed = {
               title: "Permission required",
               description: p?.title,
@@ -548,17 +751,30 @@ var plugin = async ({ client }) => {
                 )
               )
             };
-            const mention = buildPermissionMention();
-            enqueueToThread(sessionID, {
+            const body = {
               content: mention ? `${mention.content}` : void 0,
               allowed_mentions: mention?.allowed_mentions,
               embeds: [embed]
-            });
+            };
+            enqueueToThread(sessionID, body);
+            await postFallbackIfNeeded(
+              {
+                body,
+                mention,
+                sessionID,
+                fallbackUrl: fallbackWebhookUrl,
+                firstUserTextBySession,
+                lastSessionInfo
+              },
+              postDeps
+            );
+            startWorkerIfNeeded();
             return;
           }
           case "session.idle": {
             const sessionID = event.properties?.sessionID;
             if (!sessionID) return;
+            const mention = buildCompleteMention();
             const embed = {
               title: "Session completed",
               color: COLORS.success,
@@ -569,12 +785,24 @@ var plugin = async ({ client }) => {
                 )
               )
             };
-            const mention = buildCompleteMention();
-            enqueueToThread(sessionID, {
+            const body = {
               content: mention ? `${mention.content}` : void 0,
               allowed_mentions: mention?.allowed_mentions,
               embeds: [embed]
-            });
+            };
+            enqueueToThread(sessionID, body);
+            await postFallbackIfNeeded(
+              {
+                body,
+                mention,
+                sessionID,
+                fallbackUrl: fallbackWebhookUrl,
+                firstUserTextBySession,
+                lastSessionInfo
+              },
+              postDeps
+            );
+            startWorkerIfNeeded();
             return;
           }
           case "session.error": {
@@ -601,12 +829,25 @@ var plugin = async ({ client }) => {
             };
             if (!sessionID) return;
             const mention = buildCompleteMention();
-            enqueueToThread(sessionID, {
-              content: mention ? `$Session error` : void 0,
+            const body = {
+              // 🐛 既存バグ修正: `$Session error` → `${mention.content}`
+              content: mention ? `${mention.content}` : void 0,
               allowed_mentions: mention?.allowed_mentions,
               embeds: [embed]
-            });
-            await flushPending(sessionID);
+            };
+            enqueueToThread(sessionID, body);
+            await postFallbackIfNeeded(
+              {
+                body,
+                mention,
+                sessionID,
+                fallbackUrl: fallbackWebhookUrl,
+                firstUserTextBySession,
+                lastSessionInfo
+              },
+              postDeps
+            );
+            startWorkerIfNeeded();
             return;
           }
           case "todo.updated": {
@@ -622,6 +863,7 @@ var plugin = async ({ client }) => {
               description: buildTodoChecklist(p?.todos)
             };
             enqueueToThread(sessionID, { embeds: [embed] });
+            startWorkerIfNeeded();
             return;
           }
           case "message.updated": {
@@ -677,6 +919,10 @@ var plugin = async ({ client }) => {
         }
       } catch {
       }
+    },
+    __test__: {
+      queueWorker,
+      persistentQueue
     }
   };
 };
@@ -687,7 +933,8 @@ plugin.__test__ = {
   toIsoTimestamp,
   postDiscordWebhook,
   parseSendParams,
-  getTodoStatusMarker
+  getTodoStatusMarker,
+  postFallbackIfNeeded
 };
 var index_default = plugin;
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-discord-notify",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "A plugin that posts OpenCode events to a Discord webhook.",
   "license": "MIT",
   "type": "module",
@@ -25,9 +25,9 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --out-dir dist --clean",
+    "build": "tsup src/index.ts --format esm --dts --out-dir dist --clean --external bun:sqlite",
     "format": "prettier . --write",
-    "test": "vitest run",
+    "test": "bun test",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {

package/README-JP.md

@@ -1,117 +0,0 @@
-# opencode-discord-notify
-
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![npm version](https://img.shields.io/npm/v/opencode-discord-notify?logo=npm&logoColor=fff)](https://www.npmjs.com/package/opencode-discord-notify)
-[![npm downloads](https://img.shields.io/npm/dm/opencode-discord-notify?logo=npm&logoColor=fff)](https://www.npmjs.com/package/opencode-discord-notify)
-[![npm license](https://img.shields.io/npm/l/opencode-discord-notify?logo=npm&logoColor=fff)](https://www.npmjs.com/package/opencode-discord-notify)
-![OpenCode Plugin](https://img.shields.io/badge/OpenCode-Plugin-4c8bf5)
-![Discord Webhook](https://img.shields.io/badge/Discord-Webhook-5865F2?logo=discord&logoColor=fff)
-![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=fff)
-
-[English](README.md) | 日本語
-
-<p align="center">
-  <img src="assets/image/sample-forum-ch.png" width="700" alt="Discord Forum channel example" />
-</p>
-
-OpenCode のイベントを Discord Webhook に通知するプラグインです。
-Discord の Forum チャンネル webhook を前提に、セッション開始時（または最初の通知タイミング）にスレッド（投稿）を作成して、その後の更新を同スレッドに流します。
-通常のテキストチャンネル webhook でも利用できます（その場合はスレッドが作れないため、チャンネルへ直投稿します）。
-
-## できること
-
-- `session.created`: セッション開始 → 開始通知をキュー（スレッド作成/送信は後続イベントで条件が揃ったタイミングで実行されることがある）
-- `permission.updated`: 権限要求 → 通知
-- `session.idle`: セッション完了 → 通知
-- `session.error`: エラー → 通知（`sessionID` が無いケースは通知しない）
-- `todo.updated`: Todo 更新 → チェックリスト形式で通知（順序は受信順 / `cancelled` は除外）
-- `message.updated`: メッセージ情報更新 → 通知しない（role 判定用に追跡。role 未確定で保留した `text` part を後から通知することがある）
-- `message.part.updated`: メッセージ本文/ツール結果更新 → `text` は user は即時通知、assistant は確定時（`time.end`）のみ通知。`tool` は通知しない（`reasoning` は通知しない / 重複イベントは抑制）
-
-## セットアップ
-
-### 1) プラグイン配置
-
-`opencode.json` / `opencode.jsonc` にプラグインを追加します。
-
-OpenCode を再起動してください。
-
-```jsonc
-{
-  "plugin": ["opencode-discord-notify@latest"],
-}
-```
-
-### 2) Discord 側の準備
-
-- Discord の Forum チャンネルで Webhook を作成してください。
-- テキストチャンネル webhook でも動きますが、スレッド作成（`thread_name`）は Forum 向けの挙動が前提です。
-
-### 3) 環境変数
-
-必須:
-
-- `DISCORD_WEBHOOK_URL`: Discord webhook URL（未設定の場合は no-op）
-
-任意:
-
-- `DISCORD_WEBHOOK_USERNAME`: 投稿者名
-- `DISCORD_WEBHOOK_AVATAR_URL`: アイコン URL
-- `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` で無効化）
-- `DISCORD_SEND_PARAMS`: embed の fields として送るキーをカンマ区切りで指定。
-  - **指定可能キー**: `sessionID`, `permissionID`, `type`, `pattern`, `messageID`, `callID`, `partID`, `role`, `directory`, `projectID`
-  - **デフォルト動作**（未設定・空文字）: 全て無効化（何も送信しない）
-  - **全て送信したい場合**: 全キーを列挙してください
-  - **注意**: `session.created` は `DISCORD_SEND_PARAMS` に関わらず `sessionID` を必ず含みます
-
-## 仕様メモ
-
-- `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`
-  2. session title
-  3. `session <sessionID>`
-  4. `untitled`
-- Forum スレッド作成に失敗した場合は、取りこぼし防止のためチャンネル直投稿にフォールバックします（テキストチャンネル webhook など）。
-- `permission.updated` / `session.idle` は thread がまだ作られていない場合、いったん通知をキューし、スレッド作成に必要な情報（スレッド名など）が揃ったタイミングで送信されることがあります（取りこぼし防止）。
-- `session.error` は upstream の payload で `sessionID` が optional のため、`sessionID` が無い場合は通知しません。
-- `DISCORD_WEBHOOK_COMPLETE_MENTION=@everyone`（または `@here`）を設定すると、通知本文にその文字列を含めて投稿します。ただし Forum webhook の仕様上、ping は常に発生しません（文字列として表示されるだけ）。
-- `DISCORD_WEBHOOK_PERMISSION_MENTION=@everyone`（または `@here`）を設定すると、`permission.updated` の通知本文にその文字列を含めて投稿します。ただし Forum webhook の仕様上、ping は常に発生しません（文字列として表示されるだけ）。
-- `todo.updated` は、`todos` を受信した順のままチェックリスト形式で通知します（`in_progress` は `[▶]`、`completed` は `[✓]`、`cancelled` は除外）。長い/大量の todo は Discord embed の制約に合わせて省略されることがあります（空の場合は `(no todos)` / 省略時は `...and more` を付与）。
-- `message.updated` は通知しません（role 判定用に追跡。role 未確定で保留した `text` part を後から通知することがあります）。
-- `message.part.updated` は以下の方針です。
-  - `text`: user は即時通知。assistant は `part.time.end` がある確定時のみ通知（ストリーミング途中更新は通知しない）
-    - embed タイトルは `User says` / `Agent says` です
-  - `tool`: 通知しない
-  - `reasoning`: 通知しない（内部思考が含まれる可能性があるため）
-- `DISCORD_SEND_PARAMS` の制御対象は embed の fields のみです（title/description/content/timestamp などは対象外）。また `share` は fields としては送りません（Session started の embed URL には `shareUrl` を使います）。
-
-## 動作確認（手動）
-
-1. OpenCode を起動してセッション開始 → 最初の通知タイミングで Forum にスレッドが増える
-2. 権限要求が出るケースを作る → 同スレッドに通知（未作成なら後続イベントの通知タイミングでスレッド作成されることがある）
-3. セッション完了 → `session.idle` が通知される（`DISCORD_WEBHOOK_COMPLETE_MENTION` 設定時は本文に `@everyone` / `@here` を含めて投稿するが Forum webhook では ping は発生しない）
-4. エラー発生 → `session.error` が通知される（`sessionID` 無しは通知されない / `DISCORD_WEBHOOK_COMPLETE_MENTION` 設定時は本文に `@everyone` / `@here` を含めて投稿するが Forum webhook では ping は発生しない）
-
-## 開発
-
-- 依存のインストール: `npm i`
-- フォーマット: `npx prettier . --write`
-- プラグイン本体: `src/index.ts`
-
-## 今後の展望（予定）
-
-- npm パッケージとして公開（インストール/更新を簡単にする）
-- 複数 webhook / 複数チャンネル対応（用途別に振り分け）
-- 通知内容のカスタマイズ（通知するイベント、本文テンプレ、メンション付与ポリシーなど）
-  - 設定ファイル（例: `opencode-discord-notify.config.json`）を読み取り、必要に応じて環境変数から値を解決する方式も検討
-- Discord の制限対策を強化（レート制限時のリトライ、分割投稿、長文省略ルールの改善）
-- CI 整備（lint/format の自動化、簡単なテスト追加）
-
-**PR / Issue 大歓迎です。**