@mrcarb0n/opencode-mcp-watchdog 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MrCarb0n
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# opencode-mcp-watchdog
+
+Opencode plugin: on every startup it checks all configured MCP servers via
+opencode's own API, reconnects the failed ones, and shows a TUI toast summary.
+No sidecar processes — opencode core keeps owning MCP lifecycles.
+
+## Install
+
+Local (works today):
+
+```bash
+cp index.js ~/.config/opencode/plugins/mcp-watchdog.js
+```
+
+Restart opencode. ~8s after launch you get a toast like:
+
+```
+MCP watchdog (startup) — 14/15 connected · disabled: git
+```
+
+Via config (npm, live at https://www.npmjs.com/package/@mrcarb0n/opencode-mcp-watchdog):
+
+```json
+{ "plugin": ["@mrcarb0n/opencode-mcp-watchdog"] }
+```
+
+## Tool
+
+`mcp_watchdog` with one arg:
+
+- `status` — list every server with state (`✓ connected`, `✗ failed`, `○ disabled`, `⚠ needs_auth`)
+- `reconnect` — reconnect failed servers now, report what recovered
+
+## Triggers
+
+| Trigger | Behavior |
+|---|---|
+| Startup (+8s) | check + heal + toast |
+| `server.connected` | check + heal + toast (15s dedup guard) |
+| `session.error` | silent heal, toasts only if something recovered/failed |
+
+Servers reporting `needs_auth` / `needs_client_registration` are listed, never
+retried. Outside the TUI (`serve`/`web`/headless) the toast is skipped and the
+tool keeps working.

package/index.js

@@ -0,0 +1,123 @@
+import { tool } from "@opencode-ai/plugin"
+
+// Opencode core owns MCP processes. This plugin only status-checks via the
+// core API, reconnects failures, and toasts a summary. No sidecars.
+
+const STARTUP_DELAY_MS = 8000
+const DEDUP_WINDOW_MS = 15000
+const TOAST_DURATION_MS = 5000
+
+let lastRun = 0
+
+async function getStatuses(client) {
+  const { data, error } = await client.mcp.status()
+  if (error) throw new Error(`mcp.status failed: ${JSON.stringify(error)}`)
+  return data ?? {}
+}
+
+async function showToast(client, body) {
+  try {
+    await client.tui.showToast({ body })
+  } catch {
+    // No TUI attached (serve/web/headless) — status tool still works.
+  }
+}
+
+function summarize(healed, after) {
+  const names = Object.keys(after)
+  const ok = names.filter((n) => after[n]?.status === "connected").length
+  const failed = names.filter((n) => after[n]?.status === "failed")
+  const needsAuth = names.filter(
+    (n) => after[n]?.status === "needs_auth" || after[n]?.status === "needs_client_registration",
+  )
+  const disabled = names.filter((n) => after[n]?.status === "disabled")
+  const recovered = healed.filter((n) => after[n]?.status === "connected")
+  return { total: names.length, ok, failed, needsAuth, disabled, recovered }
+}
+
+async function checkAndHeal(client, reason, { quiet = false } = {}) {
+  if (Date.now() - lastRun < DEDUP_WINDOW_MS) return null
+  lastRun = Date.now()
+
+  const before = await getStatuses(client)
+  const healed = []
+  for (const [name, s] of Object.entries(before)) {
+    if (s?.status !== "failed") continue
+    try {
+      const { data } = await client.mcp.connect({ path: { name } })
+      if (data) healed.push(name)
+    } catch {
+      // Still down — reported below.
+    }
+  }
+  const after = await getStatuses(client).catch(() => before)
+  const sum = summarize(healed, after)
+
+  const bits = [`${sum.ok}/${sum.total} connected`]
+  if (sum.recovered.length) bits.push(`reconnected: ${sum.recovered.join(", ")}`)
+  if (sum.failed.length) bits.push(`failed: ${sum.failed.join(", ")}`)
+  if (sum.needsAuth.length) bits.push(`needs auth: ${sum.needsAuth.join(", ")}`)
+  if (sum.disabled.length) bits.push(`disabled: ${sum.disabled.join(", ")}`)
+  const variant = sum.failed.length ? "error" : sum.needsAuth.length ? "warning" : "success"
+
+  if (!quiet || sum.recovered.length || sum.failed.length) {
+    await showToast(client, {
+      title: `MCP watchdog (${reason})`,
+      message: bits.join(" · "),
+      variant,
+      duration: TOAST_DURATION_MS,
+    })
+  }
+  return sum
+}
+
+function formatStatus(statuses) {
+  return Object.entries(statuses)
+    .map(([name, s]) => {
+      const icon =
+        s.status === "connected" ? "✓" : s.status === "disabled" ? "○" : s.status === "failed" ? "✗" : "⚠"
+      const extra = s.error ? ` — ${s.error}` : ""
+      return `  ${icon} ${name} - ${s.status}${extra}`
+    })
+    .join("\n")
+}
+
+export const McpWatchdog = async ({ client }) => {
+  // Opencode itself triggers this on every startup.
+  setTimeout(() => {
+    checkAndHeal(client, "startup").catch((e) => console.log(`[mcp-watchdog] startup check failed: ${e.message}`))
+  }, STARTUP_DELAY_MS)
+
+  return {
+    event: async ({ event }) => {
+      if (event.type === "server.connected") {
+        await checkAndHeal(client, "server.connected").catch((e) =>
+          console.log(`[mcp-watchdog] check failed: ${e.message}`),
+        )
+      }
+      if (event.type === "session.error") {
+        await checkAndHeal(client, "session.error", { quiet: true }).catch(() => {})
+      }
+    },
+    tool: {
+      mcp_watchdog: tool({
+        description: "Show MCP server statuses, reconnect failed servers",
+        args: {
+          action: tool.schema
+            .enum(["status", "reconnect"])
+            .describe("status lists servers, reconnect reconnects failed ones"),
+        },
+        async execute(args) {
+          if (args.action === "status") return formatStatus(await getStatuses(client))
+          const r = await checkAndHeal(client, "manual")
+          if (!r) return "Check ran recently — see toast for status."
+          return (
+            `Reconnected: ${r.recovered.join(", ") || "none"}\n` +
+            `Still failing: ${r.failed.join(", ") || "none"}\n` +
+            `Needs auth: ${r.needsAuth.join(", ") || "none"}`
+          )
+        },
+      }),
+    },
+  }
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@mrcarb0n/opencode-mcp-watchdog",
+  "version": "1.0.0",
+  "description": "Opencode plugin: auto-check and reconnect failed MCP servers, with TUI toast status",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.17.13"
+  },
+  "license": "MIT",
+  "author": "MrCarb0n",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MrCarb0n/opencode-mcp-watchdog.git"
+  }
+}