discord-bridge 0.1.0

package/.discord-bridge.json.example

@@ -0,0 +1,3 @@
+{
+  "channelId": "your_channel_id_here"
+}

package/.env.example

@@ -0,0 +1,3 @@
+DISCORD_BRIDGE_TOKEN=your_bot_token_here
+DISCORD_BRIDGE_USER_ID=your_user_id_here
+DISCORD_BRIDGE_PORT=13456

package/.github/workflows/publish.yml

@@ -0,0 +1,40 @@
+name: Publish to npm
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org
+
+      - name: Check if version changed
+        id: version
+        run: |
+          LOCAL_VERSION=$(node -p "require('./package.json').version")
+          NPM_VERSION=$(npm view discord-bridge version 2>/dev/null || echo "0.0.0")
+          if [ "$LOCAL_VERSION" != "$NPM_VERSION" ]; then
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+            echo "Version changed: $NPM_VERSION -> $LOCAL_VERSION"
+          else
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+            echo "Version unchanged: $LOCAL_VERSION"
+          fi
+
+      - name: Install dependencies
+        if: steps.version.outputs.changed == 'true'
+        run: npm ci
+
+      - name: Publish
+        if: steps.version.outputs.changed == 'true'
+        run: npm publish --provenance --access public

package/README.md

@@ -0,0 +1,100 @@
+# discord-bridge
+
+Claude Code と Discord の双方向通信ブリッジ。スマホから Claude Code を操作できます。
+
+## 機能
+
+- **質問 & 返答** - Discord で質問して返答を待つ
+- **通知** - 進捗・成功・警告・エラーを通知
+- **ファイル共有** - ファイルを Discord に送信
+- **メッセージ取得** - ユーザーからの指示を取得
+- **リアルタイム待機** - SSE 接続で次の指示を待機
+- **離席モード** - ターミナルを離れても Discord 経由で操作
+- **Hooks** - 通知・停止イベントを自動で Discord に転送
+
+## インストール
+
+```bash
+npm install -g discord-bridge
+```
+
+## セットアップ
+
+### 1. Discord Bot 作成
+
+1. https://discord.com/developers/applications にアクセス
+2. "New Application" をクリック → 名前を入力して作成
+3. 左メニュー "Bot" → "Reset Token" → トークンをコピー
+4. "Privileged Gateway Intents" で **MESSAGE CONTENT INTENT** を有効化
+5. 左メニュー "OAuth2" → "URL Generator"
+   - Scopes: `bot`
+   - Bot Permissions: `Send Messages`, `Read Message History`, `Attach Files`, `Embed Links`
+6. 生成された URL を開いて Bot をサーバーに追加
+
+### 2. ID の取得
+
+Discord の設定 → 詳細設定 → **開発者モード** を有効化してから:
+
+- **チャンネル ID**: チャンネル名を右クリック → "チャンネル ID をコピー"
+- **ユーザー ID**: 自分の名前を右クリック → "ユーザー ID をコピー"
+
+### 3. 環境変数の設定
+
+`~/.zshrc` に追加:
+
+```bash
+export DISCORD_BRIDGE_TOKEN="your_bot_token_here"
+export DISCORD_BRIDGE_USER_ID="your_user_id_here"
+```
+
+設定後: `source ~/.zshrc`
+
+### 4. プロジェクト設定
+
+Claude Code を使うプロジェクトのルートに `.discord-bridge.json` を作成:
+
+```json
+{
+  "channelId": "your_channel_id_here"
+}
+```
+
+### 5. Claude Code プラグインのインストール
+
+```bash
+discord-bridge install
+```
+
+Claude Code を再起動してプラグインを読み込みます。
+
+## 使い方
+
+### サーバーの起動
+
+```bash
+discord-bridge start
+```
+
+### ヘルスチェック
+
+```bash
+discord-bridge status
+```
+
+### Claude Code での利用
+
+Claude Code で以下のように話しかけてください:
+
+- 「Discord にテスト通知を送って」 - 通知テスト
+- 「離席する」 - 離席モード（Discord 経由で操作）
+
+## トラブルシューティング
+
+- **Bot がオフライン**: `DISCORD_BRIDGE_TOKEN` が正しいか確認
+- **メッセージが届かない**: MESSAGE CONTENT INTENT が有効か確認
+- **チャンネルが見つからない**: `.discord-bridge.json` の `channelId` が正しいか確認
+- **返答が受信されない**: `DISCORD_BRIDGE_USER_ID` が正しいか確認
+
+## ライセンス
+
+MIT

package/bin/cli.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { spawn } from "child_process";
+import { cpSync, existsSync, mkdirSync } from "fs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = join(__dirname, "..");
+
+const command = process.argv[2];
+
+switch (command) {
+  case "start": {
+    const serverPath = join(packageRoot, "server", "index.js");
+    const child = spawn("node", [serverPath], {
+      stdio: "inherit",
+      env: process.env,
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+    break;
+  }
+
+  case "install": {
+    const home = process.env.HOME;
+    if (!home) {
+      console.error("HOME environment variable is not set");
+      process.exit(1);
+    }
+    const target = join(home, ".claude", "plugins", "discord-bridge");
+    const source = join(packageRoot, "plugin");
+
+    if (!existsSync(source)) {
+      console.error("Plugin files not found");
+      process.exit(1);
+    }
+
+    mkdirSync(target, { recursive: true });
+    cpSync(source, target, { recursive: true });
+    console.log(`Plugin installed to ${target}`);
+    console.log("");
+    console.log("Restart Claude Code to load the plugin.");
+    break;
+  }
+
+  case "status": {
+    const port = process.env.DISCORD_BRIDGE_PORT || "13456";
+    try {
+      const res = await fetch(`http://localhost:${port}/health`);
+      const data = await res.json();
+      console.log(JSON.stringify(data, null, 2));
+    } catch {
+      console.error("Server is not running");
+      process.exit(1);
+    }
+    break;
+  }
+
+  default:
+    console.log("discord-bridge - Claude Code <-> Discord communication bridge");
+    console.log("");
+    console.log("Usage: discord-bridge <command>");
+    console.log("");
+    console.log("Commands:");
+    console.log("  start     Start the Discord bridge server");
+    console.log("  install   Install Claude Code plugin to ~/.claude/plugins/");
+    console.log("  status    Check server health");
+    break;
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "discord-bridge",
+  "version": "0.1.0",
+  "description": "Claude Code <-> Discord bidirectional communication bridge",
+  "type": "module",
+  "bin": {
+    "discord-bridge": "bin/cli.js"
+  },
+  "scripts": {
+    "start": "node server/index.js"
+  },
+  "keywords": [
+    "claude-code",
+    "discord",
+    "bridge",
+    "cli"
+  ],
+  "author": "naichi",
+  "license": "MIT",
+  "dependencies": {
+    "discord.js": "^14.16.0",
+    "express": "^5.0.0"
+  }
+}

package/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "discord-bridge",
+  "description": "Bidirectional communication bridge between Claude Code and Discord. Send questions, receive instructions, share files, and get progress updates through a dedicated Discord channel.",
+  "version": "0.1.0",
+  "author": {
+    "name": "naichi"
+  }
+}

package/plugin/README.md

@@ -0,0 +1,17 @@
+# Discord Bridge Plugin for Claude Code
+
+Claude Code と Discord の双方向通信ブリッジ。スマホから Claude Code を操作できます。
+
+## セットアップ
+
+このプラグインは `discord-bridge install` コマンドで自動的にインストールされます。
+
+詳しいセットアップ手順はリポジトリの README を参照してください:
+https://github.com/naichilab/discord-bridge-server
+
+## 使い方
+
+Claude Code で以下のように話しかけてください:
+
+- 「Discord にテスト通知を送って」 - 通知テスト
+- 「離席する」 - 離席モード（Discord 経由で操作）

package/plugin/hooks/hooks.json

@@ -0,0 +1,27 @@
+{
+  "description": "Discord bridge hooks for forwarding notifications and stop events",
+  "hooks": {
+    "Notification": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/notify-discord.sh",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/stop-hook.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugin/hooks/scripts/notify-discord.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+set -euo pipefail
+
+# Read hook input from stdin
+HOOK_INPUT=$(cat)
+
+DISCORD_TOKEN="${DISCORD_TOKEN:-}"
+DISCORD_CHANNEL_ID="${DISCORD_CHANNEL_ID:-}"
+
+if [[ -z "$DISCORD_TOKEN" ]] || [[ -z "$DISCORD_CHANNEL_ID" ]]; then
+  exit 0
+fi
+
+# Extract notification message
+NOTIFICATION=$(echo "$HOOK_INPUT" | /usr/bin/python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    print(data.get('notification', data.get('message', 'Claude Code notification')))
+except:
+    print('Claude Code notification')
+" 2>/dev/null || echo "Claude Code notification")
+
+# Send via Discord REST API
+curl -s -X POST \
+  "https://discord.com/api/v10/channels/${DISCORD_CHANNEL_ID}/messages" \
+  -H "Authorization: Bot ${DISCORD_TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d "$(/usr/bin/python3 -c "
+import json, sys
+msg = sys.argv[1]
+print(json.dumps({'embeds': [{'title': 'Notification', 'description': msg, 'color': 3447003}]}))
+" "$NOTIFICATION")" \
+  > /dev/null 2>&1
+
+exit 0

package/plugin/hooks/scripts/stop-hook.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+set -euo pipefail
+
+HOOK_INPUT=$(cat)
+
+DISCORD_TOKEN="${DISCORD_TOKEN:-}"
+DISCORD_CHANNEL_ID="${DISCORD_CHANNEL_ID:-}"
+
+if [[ -z "$DISCORD_TOKEN" ]] || [[ -z "$DISCORD_CHANNEL_ID" ]]; then
+  exit 0
+fi
+
+# Extract stop reason
+REASON=$(echo "$HOOK_INPUT" | /usr/bin/python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    print(data.get('reason', data.get('stopReason', 'Task completed')))
+except:
+    print('Task completed')
+" 2>/dev/null || echo "Task completed")
+
+# Send stop notification
+curl -s -X POST \
+  "https://discord.com/api/v10/channels/${DISCORD_CHANNEL_ID}/messages" \
+  -H "Authorization: Bot ${DISCORD_TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d "$(/usr/bin/python3 -c "
+import json, sys
+msg = sys.argv[1]
+print(json.dumps({'embeds': [{'title': 'Claude Code Stopped', 'description': msg, 'color': 15158332}]}))
+" "$REASON")" \
+  > /dev/null 2>&1
+
+exit 0

package/plugin/skills/discord-comm/SKILL.md

@@ -0,0 +1,172 @@
+---
+name: discord-communication
+description: This skill should be used when the user asks to "communicate via Discord", "send a message to Discord", "check Discord for instructions", "ask a question on Discord", "notify on Discord", "share a file on Discord", "離席する", "離席モード", "Discord で待機して", "Discord待機", or when Claude Code needs to reach the user who is away from the terminal.
+version: 3.0.0
+---
+
+# Discord Communication Bridge
+
+Discord 専用チャンネルを通じてユーザーとやりとりするためのスキル。
+HTTP API サーバー (`localhost:13456`) 経由で Discord Bot と通信する。
+
+## 前提条件
+
+サーバーが別プロセスで起動済みであること。
+起動していない場合は `discord-bridge start` で起動を促す。
+
+## ヘルパースクリプト
+
+`$CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/` にラッパースクリプトを用意。
+Bash ツールで直接実行する。
+
+## 使用方法
+
+### ヘルスチェック
+
+```bash
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-status.sh
+```
+
+### 通知（一方向）
+
+```bash
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-notify.sh "ビルド完了しました" success
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-notify.sh "エラーが発生しました" error
+```
+
+レベル: `info`（既定）, `success`, `warning`, `error`
+
+### 質問（返答待ち）
+
+```bash
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-ask.sh "続行しますか？"
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-ask.sh "どの方法で進めますか？" 300 "方法A" "方法B" "方法C"
+```
+
+### メッセージ取得
+
+```bash
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-messages.sh
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-messages.sh 20 true
+```
+
+### メッセージ待機 (SSE)
+
+```bash
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-wait.sh
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-wait.sh 21600
+```
+
+デフォルトタイムアウト: 6時間 (21600秒)。SSE接続でメッセージをリアルタイム受信する。
+
+### ファイル送信
+
+```bash
+bash $CLAUDE_PLUGIN_ROOT/skills/discord-comm/scripts/discord-send-file.sh /path/to/file.png "スクリーンショット"
+```
+
+## パターン
+
+### 長時間タスク
+
+1. `discord-notify.sh` (info) で開始を通知
+2. 定期的に `discord-messages.sh` で指示変更を確認
+3. `discord-notify.sh` (success) で完了通知
+4. 判断が必要な場合は `discord-ask.sh`
+
+### エラー発生時
+
+1. `discord-notify.sh` (error) でエラー報告
+2. `discord-ask.sh` で対応方針を確認
+3. タイムアウト時は返答が来るまで再度 `discord-ask.sh` を呼んで待機する
+
+### 待機モード
+
+1. `discord-notify.sh` で状況をまとめて報告
+2. `discord-wait.sh` で次の指示を待つ
+3. 受信した指示を実行
+
+## 離席モード（Discord 待受ループ）
+
+ユーザーが「離席する」「Discord で待機して」等と言った場合、以下のループに入る。
+
+### 開始手順
+
+1. ヘルスチェックでサーバー接続を確認
+2. Discord に「離席モード開始」を通知
+3. ループ開始
+
+### ループ動作
+
+以下を繰り返す。**タイムアウトしても勝手に終了せず、再度待機する。**
+
+```
+loop:
+  1. discord-wait.sh (timeout: 21600) でメッセージを待つ（SSE接続、6時間）
+     ※ SSE接続時にサーバーが自動で「クライアント接続」をDebug通知する
+     レスポンス形式: {"status":"received","messages":[...]} （配列で複数件返る可能性あり）
+  2. タイムアウトした場合 → 1 に戻る
+  4. メッセージを受信した場合:
+     a. 全メッセージを確認し、最新のメッセージを指示として扱う
+     b. ただし「戻ったよ」「終了」「おわり」「bye」等の終了指示が含まれていれば → ループ終了
+     c. 「やめて」「中断」「ストップ」等のキャンセル指示が含まれていれば → その前の指示は無視
+     d. それ以外なら → 最新のメッセージを指示として処理を実行（下記「処理中の動作ルール」参照）
+  5. 処理完了後 → 1 に戻る
+```
+
+### 処理中の動作ルール
+
+離席モードではターミナルが見えないため、**すべての発言・思考・行動を Discord に送る。**
+
+#### 全出力転送
+
+通常ターミナルに表示するテキスト出力は、すべて `discord-notify.sh` で Discord にも送る。
+
+- ※ 指示の受信・伝達は中継サーバーが自動通知するため手動通知は不要
+- 指示の解釈と対応方針 → `"〇〇と解釈。△△で対応します"` (info) **← 必須**
+- 処理の各ステップ → `"〇〇を実行中..."` (info)
+- ツール実行結果の要約 → `"コンパイル結果: エラー0件"` (info)
+- 判断・方針の説明 → `"〇〇のため、△△の方法で進めます"` (info)
+- 処理完了 → 結果のまとめ (success) **← 必須**
+- エラー発生 → エラー内容 (error) → `discord-ask.sh` で対応を確認
+
+メッセージは簡潔にまとめつつ、何をしているか追えるレベルの粒度で送る。
+1つのツール実行ごとに1通知が目安。ただし連続する軽微な操作はまとめてよい。
+
+#### 中断チェック（割り込み検知）
+
+処理中、ユーザーが Discord で「止まって」「ストップ」「中断」等を送る可能性がある。
+**各ステップの合間に `discord-messages.sh` でキューをチェック**し、中断指示がないか確認する。
+
+```
+チェックタイミング:
+  - ツール実行の前（Bash, Edit, Write 等を呼ぶ直前）
+  - 長いループの各イテレーション
+  - 判断ポイント（次に何をするか考える時）
+```
+
+中断指示を検出した場合:
+1. 現在の処理を安全な状態で止める
+2. `discord-notify.sh` (warning) で「中断しました。現在の状態: 〇〇」を報告
+3. `discord-wait.sh` で次の指示を待つ
+
+中断と判定するキーワード: 「止まって」「ストップ」「stop」「中断」「待って」「やめて」
+
+#### ユーザー判断が必要な場合
+
+- `discord-ask.sh` で質問し、選択肢を提示する
+- 破壊的な操作（git push, ファイル削除等）は必ず確認を取る
+- 不明確な指示は処理を始める前に明確化する
+
+### 終了時
+
+1. 離席モード中に行った作業のまとめを作成する
+2. そのまとめを Discord に `discord-notify.sh` で送信する
+3. 同じまとめをターミナルにもテキスト出力する
+4. Discord に「離席モード終了。ターミナルに戻ります。」を通知し、通常のターミナル入力待ちに戻る。
+
+### 注意事項
+
+- 離席モード中もターミナルの作業ディレクトリは維持される
+- 1回の指示で処理が完結するよう心がける
+- Discord のメッセージ上限（2000文字）を超える場合は分割して送信する

package/plugin/skills/discord-comm/scripts/discord-ask.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+# Discord に質問を送信し返答を待つ
+# Usage: discord-ask.sh "質問" [timeout_seconds] [option1] [option2] ...
+QUESTION="${1:?Usage: discord-ask.sh QUESTION [TIMEOUT] [OPTIONS...]}"
+TIMEOUT="${2:-300}"
+shift 2 2>/dev/null || true
+PORT="${DISCORD_BRIDGE_PORT:-13456}"
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
+CHANNEL_ID=""
+if [ -n "$PROJECT_ROOT" ] && [ -f "$PROJECT_ROOT/.discord-bridge.json" ]; then
+  CHANNEL_ID=$(python3 -c "import json; print(json.load(open('$PROJECT_ROOT/.discord-bridge.json'))['channelId'])" 2>/dev/null)
+fi
+
+JSON=$(python3 -c "
+import json, sys
+d = {'question': sys.argv[1], 'timeout_seconds': int(sys.argv[2])}
+opts = sys.argv[4:]
+if opts:
+    d['options'] = opts
+if sys.argv[3]:
+    d['channelId'] = sys.argv[3]
+print(json.dumps(d, ensure_ascii=False))
+" "$QUESTION" "$TIMEOUT" "$CHANNEL_ID" "$@")
+
+curl -s -X POST "http://localhost:${PORT}/ask" \
+  -H "Content-Type: application/json" \
+  -d "$JSON" \
+  --max-time "$((TIMEOUT + 5))"

package/plugin/skills/discord-comm/scripts/discord-messages.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# キューに溜まった Discord メッセージを取得
+# Usage: discord-messages.sh [count] [include_history]
+COUNT="${1:-10}"
+HISTORY="${2:-false}"
+PORT="${DISCORD_BRIDGE_PORT:-13456}"
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
+CHANNEL_ID=""
+if [ -n "$PROJECT_ROOT" ] && [ -f "$PROJECT_ROOT/.discord-bridge.json" ]; then
+  CHANNEL_ID=$(python3 -c "import json; print(json.load(open('$PROJECT_ROOT/.discord-bridge.json'))['channelId'])" 2>/dev/null)
+fi
+
+QUERY="count=${COUNT}&include_history=${HISTORY}"
+if [ -n "$CHANNEL_ID" ]; then
+  QUERY="${QUERY}&channelId=${CHANNEL_ID}"
+fi
+
+curl -s "http://localhost:${PORT}/messages?${QUERY}"

package/plugin/skills/discord-comm/scripts/discord-notify.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Discord に通知を送信
+# Usage: discord-notify.sh "メッセージ" [info|success|warning|error] ["タイトル"]
+MESSAGE="${1:?Usage: discord-notify.sh MESSAGE [LEVEL] [TITLE]}"
+LEVEL="${2:-info}"
+TITLE="${3:-}"
+PORT="${DISCORD_BRIDGE_PORT:-13456}"
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
+CHANNEL_ID=""
+if [ -n "$PROJECT_ROOT" ] && [ -f "$PROJECT_ROOT/.discord-bridge.json" ]; then
+  CHANNEL_ID=$(python3 -c "import json; print(json.load(open('$PROJECT_ROOT/.discord-bridge.json'))['channelId'])" 2>/dev/null)
+fi
+
+JSON=$(python3 -c "
+import json, sys
+d = {'message': sys.argv[1], 'level': sys.argv[2]}
+if sys.argv[3]:
+    d['title'] = sys.argv[3]
+if sys.argv[4]:
+    d['channelId'] = sys.argv[4]
+print(json.dumps(d, ensure_ascii=False))
+" "$MESSAGE" "$LEVEL" "$TITLE" "$CHANNEL_ID")
+
+curl -s -X POST "http://localhost:${PORT}/notify" \
+  -H "Content-Type: application/json" \
+  -d "$JSON"

package/plugin/skills/discord-comm/scripts/discord-send-file.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# Discord にファイルを送信
+# Usage: discord-send-file.sh /path/to/file ["メッセージ"]
+FILE_PATH="${1:?Usage: discord-send-file.sh FILE_PATH [MESSAGE]}"
+MESSAGE="${2:-}"
+PORT="${DISCORD_BRIDGE_PORT:-13456}"
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
+CHANNEL_ID=""
+if [ -n "$PROJECT_ROOT" ] && [ -f "$PROJECT_ROOT/.discord-bridge.json" ]; then
+  CHANNEL_ID=$(python3 -c "import json; print(json.load(open('$PROJECT_ROOT/.discord-bridge.json'))['channelId'])" 2>/dev/null)
+fi
+
+JSON=$(python3 -c "
+import json, sys
+d = {'file_path': sys.argv[1]}
+if sys.argv[2]:
+    d['message'] = sys.argv[2]
+if sys.argv[3]:
+    d['channelId'] = sys.argv[3]
+print(json.dumps(d, ensure_ascii=False))
+" "$FILE_PATH" "$MESSAGE" "$CHANNEL_ID")
+
+curl -s -X POST "http://localhost:${PORT}/send-file" \
+  -H "Content-Type: application/json" \
+  -d "$JSON"

package/plugin/skills/discord-comm/scripts/discord-status.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+# Discord Bridge ヘルスチェック
+# Usage: discord-status.sh
+PORT="${DISCORD_BRIDGE_PORT:-13456}"
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
+CHANNEL_ID=""
+if [ -n "$PROJECT_ROOT" ] && [ -f "$PROJECT_ROOT/.discord-bridge.json" ]; then
+  CHANNEL_ID=$(python3 -c "import json; print(json.load(open('$PROJECT_ROOT/.discord-bridge.json'))['channelId'])" 2>/dev/null)
+fi
+
+if [ -n "$CHANNEL_ID" ]; then
+  curl -s "http://localhost:${PORT}/health?channelId=${CHANNEL_ID}"
+else
+  curl -s "http://localhost:${PORT}/health"
+fi

package/plugin/skills/discord-comm/scripts/discord-wait.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+# Discord で次のメッセージを待機 (SSE notification + queue fetch)
+# キューに複数メッセージがある場合は全件を返す
+# Usage: discord-wait.sh [timeout_seconds]
+TIMEOUT="${1:-21600}"
+PORT="${DISCORD_BRIDGE_PORT:-13456}"
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
+CHANNEL_ID=""
+if [ -n "$PROJECT_ROOT" ] && [ -f "$PROJECT_ROOT/.discord-bridge.json" ]; then
+  CHANNEL_ID=$(python3 -c "import json; print(json.load(open('$PROJECT_ROOT/.discord-bridge.json'))['channelId'])" 2>/dev/null)
+fi
+
+if [ -z "$CHANNEL_ID" ]; then
+  echo '{"status":"error","error":"channelId not found in .discord-bridge.json"}'
+  exit 1
+fi
+
+BASE_URL="http://localhost:${PORT}"
+
+# Health check — サーバーが起動していなければ即エラー終了
+HEALTH=$(curl -sf "${BASE_URL}/health?channelId=${CHANNEL_ID}" 2>/dev/null)
+if [ $? -ne 0 ]; then
+  echo '{"status":"error","error":"Discord bridge server is not running. Start it with: bash ~/projects/discord-bridge-server/start.sh"}'
+  exit 1
+fi
+
+# First check if there are already queued messages
+QUEUED=$(curl -s "${BASE_URL}/messages?channelId=${CHANNEL_ID}&count=50")
+RESULT=$(echo "$QUEUED" | python3 -c "
+import json, sys
+d = json.load(sys.stdin)
+if d.get('count', 0) > 0:
+    print(json.dumps({'status': 'received', 'messages': d['messages']}, ensure_ascii=False))
+" 2>/dev/null)
+
+if [ -n "$RESULT" ]; then
+  echo "$RESULT"
+  exit 0
+fi
+
+# No queued messages — connect to SSE and wait for notify event
+NOTIFIED=$(curl -s -N "${BASE_URL}/events?channelId=${CHANNEL_ID}" \
+  --max-time "$((TIMEOUT + 5))" 2>/dev/null \
+  | awk '/^event: notify$/ { print "1"; exit }')
+
+if [ "$NOTIFIED" = "1" ]; then
+  # Fetch all messages from queue (reliable delivery)
+  QUEUED=$(curl -s "${BASE_URL}/messages?channelId=${CHANNEL_ID}&count=50")
+  RESULT=$(echo "$QUEUED" | python3 -c "
+import json, sys
+d = json.load(sys.stdin)
+if d.get('count', 0) > 0:
+    print(json.dumps({'status': 'received', 'messages': d['messages']}, ensure_ascii=False))
+" 2>/dev/null)
+
+  if [ -n "$RESULT" ]; then
+    echo "$RESULT"
+  else
+    echo '{"status":"error","error":"Notification received but no message in queue"}'
+  fi
+else
+  echo "{\"status\":\"timeout\",\"error\":\"No reply received within ${TIMEOUT} seconds\"}"
+fi

package/server/index.js

@@ -0,0 +1,478 @@
+import express from "express";
+import {
+  Client,
+  GatewayIntentBits,
+  EmbedBuilder,
+  AttachmentBuilder,
+} from "discord.js";
+import { readFile, stat } from "fs/promises";
+import path from "path";
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const CONFIG = {
+  token: process.env.DISCORD_BRIDGE_TOKEN,
+  userId: process.env.DISCORD_BRIDGE_USER_ID,
+  host: "127.0.0.1",
+  port: parseInt(process.env.DISCORD_BRIDGE_PORT || "13456", 10),
+  defaultTimeout: 5 * 60 * 1000,
+  maxTimeout: 30 * 60 * 1000,
+  maxFileSize: 8 * 1024 * 1024,
+  maxMessageHistory: 50,
+  sseKeepAliveInterval: 30 * 1000,
+};
+
+function validateConfig() {
+  const missing = [];
+  if (!CONFIG.token) missing.push("DISCORD_BRIDGE_TOKEN");
+  if (!CONFIG.userId) missing.push("DISCORD_BRIDGE_USER_ID");
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required environment variables: ${missing.join(", ")}`
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Discord Bot
+// ---------------------------------------------------------------------------
+
+let discordClient = null;
+
+// Per-channel state
+const channelCache = new Map();
+const messageQueues = new Map();
+const pendingQuestions = new Map();
+const sseSubscribers = new Map();
+
+function getMessageQueue(channelId) {
+  if (!messageQueues.has(channelId)) {
+    messageQueues.set(channelId, []);
+  }
+  return messageQueues.get(channelId);
+}
+
+function getSseSubscribers(channelId) {
+  if (!sseSubscribers.has(channelId)) {
+    sseSubscribers.set(channelId, new Set());
+  }
+  return sseSubscribers.get(channelId);
+}
+
+function broadcastSseEvent(channelId, event, data) {
+  const subscribers = sseSubscribers.get(channelId);
+  if (!subscribers || subscribers.size === 0) return false;
+  const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+  for (const res of subscribers) {
+    res.write(payload);
+  }
+  return true;
+}
+
+async function fetchChannel(channelId) {
+  if (channelCache.has(channelId)) {
+    return channelCache.get(channelId);
+  }
+  const ch = await discordClient.channels.fetch(channelId);
+  if (!ch || !ch.isTextBased()) {
+    throw new Error(
+      `Channel ${channelId} not found or is not a text channel`
+    );
+  }
+  channelCache.set(channelId, ch);
+  return ch;
+}
+
+async function initDiscord() {
+  discordClient = new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+    ],
+  });
+
+  discordClient.on("messageCreate", (message) => {
+    if (message.author.id !== CONFIG.userId) return;
+    if (message.author.bot) return;
+
+    const chId = message.channel.id;
+
+    const parsed = {
+      content: message.content,
+      attachments: message.attachments.map((a) => ({
+        name: a.name,
+        url: a.url,
+        size: a.size,
+        contentType: a.contentType,
+      })),
+      timestamp: message.createdAt.toISOString(),
+      id: message.id,
+    };
+
+    // Priority: pendingQuestion (/ask) > queue + SSE notify
+    const pending = pendingQuestions.get(chId);
+    if (pending) {
+      clearTimeout(pending.timeoutId);
+      pendingQuestions.delete(chId);
+      pending.resolve(parsed);
+    } else {
+      // Always queue (SSE is unreliable for delivery confirmation)
+      const queue = getMessageQueue(chId);
+      queue.push(parsed);
+      if (queue.length > CONFIG.maxMessageHistory) {
+        queue.shift();
+      }
+
+      // Notify SSE subscribers that a new message is available
+      broadcastSseEvent(chId, "notify", {});
+
+      // Auto-ack: show queue depth
+      sendDebugMessage(message.channel, `受信: キュー${queue.length}`);
+    }
+  });
+
+  await discordClient.login(CONFIG.token);
+
+  await new Promise((resolve, reject) => {
+    if (discordClient.isReady()) {
+      resolve();
+      return;
+    }
+    discordClient.once("ready", resolve);
+    discordClient.once("error", reject);
+  });
+
+  console.log(`[discord-bridge] Bot connected as ${discordClient.user.tag}`);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createEmbed({ title, description, color = 0x7c3aed, fields = [] }) {
+  const embed = new EmbedBuilder()
+    .setTitle(title)
+    .setDescription(description)
+    .setColor(color);
+  for (const field of fields) {
+    embed.addFields(field);
+  }
+  return embed;
+}
+
+async function sendDebugMessage(channel, message) {
+  const embed = new EmbedBuilder()
+    .setDescription(`📡 ${message}`)
+    .setColor(0x95a5a6);
+  return channel.send({ embeds: [embed] }).catch(() => {});
+}
+
+async function sendMessage(channelId, content, embeds = [], files = []) {
+  const ch = await fetchChannel(channelId);
+  return ch.send({ content, embeds, files });
+}
+
+function waitForReply(channelId, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      pendingQuestions.delete(channelId);
+      reject(
+        new Error(`No reply received within ${timeoutMs / 1000} seconds`)
+      );
+    }, timeoutMs);
+    pendingQuestions.set(channelId, { resolve, reject, timeoutId });
+  });
+}
+
+function resolveChannelId(req) {
+  return req.body?.channelId || req.query?.channelId || null;
+}
+
+// ---------------------------------------------------------------------------
+// HTTP API
+// ---------------------------------------------------------------------------
+
+const app = express();
+app.use(express.json());
+
+// ---- GET /health ----
+app.get("/health", (_req, res) => {
+  const botReady = discordClient?.isReady() ?? false;
+  const channelId = _req.query.channelId;
+  const response = {
+    status: botReady ? "ok" : "disconnected",
+    bot: discordClient?.user?.tag ?? null,
+  };
+  if (channelId) {
+    response.channel = channelId;
+    response.queuedMessages = getMessageQueue(channelId).length;
+    response.sseSubscribers = getSseSubscribers(channelId).size;
+  }
+  res.json(response);
+});
+
+// ---- GET /events (SSE) ----
+app.get("/events", (req, res) => {
+  const channelId = req.query.channelId;
+  if (!channelId) {
+    return res.status(400).json({ status: "error", error: "channelId is required" });
+  }
+
+  // Set SSE headers
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  res.flushHeaders();
+
+  // Send connected event
+  res.write(`event: connected\ndata: ${JSON.stringify({ channelId })}\n\n`);
+
+  // Notify Discord that a client connected
+  fetchChannel(channelId).then((ch) => {
+    sendDebugMessage(ch, "待機中");
+  }).catch(() => {});
+
+  // If there are queued messages, notify immediately so client can fetch via /messages
+  const queue = getMessageQueue(channelId);
+  if (queue.length > 0) {
+    res.write(`event: notify\ndata: {}\n\n`);
+  }
+
+  // Register subscriber
+  const subscribers = getSseSubscribers(channelId);
+  subscribers.add(res);
+
+  // Keep-alive ping
+  const pingInterval = setInterval(() => {
+    res.write(`event: ping\ndata: ${JSON.stringify({ timestamp: new Date().toISOString() })}\n\n`);
+  }, CONFIG.sseKeepAliveInterval);
+
+  // Cleanup on disconnect
+  req.on("close", () => {
+    clearInterval(pingInterval);
+    subscribers.delete(res);
+    if (subscribers.size === 0) {
+      sseSubscribers.delete(channelId);
+    }
+  });
+});
+
+// ---- POST /ask ----
+app.post("/ask", async (req, res) => {
+  const { question, context, timeout_seconds = 300, options } = req.body;
+  const channelId = resolveChannelId(req);
+  if (!channelId) {
+    return res.status(400).json({ status: "error", error: "channelId is required" });
+  }
+  if (!question) {
+    return res.status(400).json({ status: "error", error: "question is required" });
+  }
+
+  const timeoutMs = Math.min(timeout_seconds * 1000, CONFIG.maxTimeout);
+  const fields = [];
+
+  if (context) {
+    fields.push({ name: "Context", value: context.slice(0, 1024) });
+  }
+  if (options && options.length > 0) {
+    fields.push({
+      name: "Suggested Replies",
+      value: options.map((opt, i) => `**${i + 1}.** ${opt}`).join("\n"),
+    });
+  }
+  fields.push({
+    name: "Timeout",
+    value: `${timeout_seconds}s`,
+    inline: true,
+  });
+  const embed = createEmbed({
+    title: "❓ Question",
+    description: question,
+    color: 0xe84393,
+    fields,
+  });
+
+  await sendMessage(channelId, `<@${CONFIG.userId}>`, [embed]);
+
+  try {
+    const reply = await waitForReply(channelId, timeoutMs);
+    res.json({
+      status: "replied",
+      reply: reply.content,
+      attachments: reply.attachments,
+      timestamp: reply.timestamp,
+    });
+  } catch (err) {
+    res.status(408).json({ status: "timeout", error: err.message });
+  }
+});
+
+// ---- POST /notify ----
+app.post("/notify", async (req, res) => {
+  const { message, level = "info", title } = req.body;
+  const channelId = resolveChannelId(req);
+  if (!channelId) {
+    return res.status(400).json({ status: "error", error: "channelId is required" });
+  }
+  if (!message) {
+    return res.status(400).json({ status: "error", error: "message is required" });
+  }
+
+  const colorMap = {
+    info: 0x3498db,
+    success: 0x2ecc71,
+    warning: 0xf39c12,
+    error: 0xe74c3c,
+    debug: 0x95a5a6,
+  };
+  const iconMap = {
+    info: "\u2139\ufe0f",
+    success: "\u2705",
+    warning: "\u26a0\ufe0f",
+    error: "\u274c",
+    debug: "\ud83d\udce1",
+  };
+
+  if (level === "info") {
+    await sendMessage(channelId, message);
+  } else if (level === "debug") {
+    const ch = await fetchChannel(channelId);
+    await sendDebugMessage(ch, message);
+  } else {
+    const defaultTitle = `${iconMap[level]} ${level.charAt(0).toUpperCase() + level.slice(1)}`;
+    const embed = createEmbed({
+      title: title || defaultTitle,
+      description: message,
+      color: colorMap[level] ?? colorMap.info,
+    });
+    await sendMessage(channelId, null, [embed]);
+  }
+  res.json({ status: "sent", level });
+});
+
+// ---- POST /send-file ----
+app.post("/send-file", async (req, res) => {
+  const { file_path, message } = req.body;
+  const channelId = resolveChannelId(req);
+  if (!channelId) {
+    return res.status(400).json({ status: "error", error: "channelId is required" });
+  }
+  if (!file_path) {
+    return res.status(400).json({ status: "error", error: "file_path is required" });
+  }
+
+  try {
+    const stats = await stat(file_path);
+    if (stats.size > CONFIG.maxFileSize) {
+      return res.status(413).json({
+        status: "error",
+        error: `File too large: ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds 8MB limit`,
+      });
+    }
+  } catch {
+    return res.status(404).json({
+      status: "error",
+      error: `File not found: ${file_path}`,
+    });
+  }
+
+  const fileBuffer = await readFile(file_path);
+  const fileName = path.basename(file_path);
+  const attachment = new AttachmentBuilder(fileBuffer, { name: fileName });
+
+  const embed = createEmbed({
+    title: "📎 File",
+    description: message || `\`${fileName}\``,
+    color: 0x9b59b6,
+  });
+
+  await sendMessage(channelId, null, [embed], [attachment]);
+  res.json({ status: "sent", fileName });
+});
+
+// ---- GET /messages ----
+app.get("/messages", async (req, res) => {
+  const channelId = resolveChannelId(req);
+  if (!channelId) {
+    return res.status(400).json({ status: "error", error: "channelId is required" });
+  }
+
+  const count = Math.min(
+    parseInt(req.query.count || "10", 10),
+    CONFIG.maxMessageHistory
+  );
+  const includeHistory = req.query.include_history === "true";
+  const messages = [];
+
+  const queue = getMessageQueue(channelId);
+  const queued = queue.splice(0, count);
+  messages.push(...queued.map((m) => ({ ...m, source: "queued" })));
+
+  // Notify Discord that messages were delivered to Claude Code (debug embed)
+  if (queued.length > 0) {
+    try {
+      const ch = await fetchChannel(channelId);
+      for (const msg of queued) {
+        const text = msg.content.replace(/\n/g, " ");
+        const preview = text.length > 5 ? text.slice(0, 5) + "......" : text;
+        sendDebugMessage(ch, `伝達: ${preview}`);
+      }
+    } catch { /* ignore */ }
+  }
+
+  if (includeHistory && messages.length < count) {
+    const remaining = count - messages.length;
+    const ch = await fetchChannel(channelId);
+    const fetched = await ch.messages.fetch({ limit: remaining });
+    const history = fetched
+      .filter((m) => m.author.id === CONFIG.userId && !m.author.bot)
+      .map((m) => ({
+        content: m.content,
+        attachments: m.attachments.map((a) => ({
+          name: a.name,
+          url: a.url,
+          size: a.size,
+          contentType: a.contentType,
+        })),
+        timestamp: m.createdAt.toISOString(),
+        id: m.id,
+        source: "history",
+      }));
+    messages.push(...history);
+  }
+
+  res.json({ status: "ok", count: messages.length, messages });
+});
+
+// ---------------------------------------------------------------------------
+// Lifecycle
+// ---------------------------------------------------------------------------
+
+async function main() {
+  validateConfig();
+  await initDiscord();
+
+  app.listen(CONFIG.port, CONFIG.host, () => {
+    console.log(
+      `[discord-bridge] HTTP server listening on http://${CONFIG.host}:${CONFIG.port}`
+    );
+  });
+}
+
+process.on("SIGINT", () => {
+  if (discordClient) discordClient.destroy();
+  process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+  if (discordClient) discordClient.destroy();
+  process.exit(0);
+});
+
+main().catch((err) => {
+  console.error(`[discord-bridge] Fatal: ${err.message}`);
+  process.exit(1);
+});