fix: Display an error toast upon loading a bad plugins (TUI warnings only)

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -25,6 +25,7 @@ import { createSimpleContext } from "./helper"
 import type { Snapshot } from "@/snapshot"
 import { useExit } from "./exit"
 import { useArgs } from "./args"
+import { useToast } from "../ui/toast"
 import { batch, onMount } from "solid-js"
 import { Log } from "@/util/log"
 import type { Path } from "@opencode-ai/sdk"
@@ -345,6 +346,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
 
     const exit = useExit()
     const args = useArgs()
+    const toast = useToast()
 
     async function bootstrap() {
       console.log("bootstrapping")
@@ -413,6 +415,16 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
             sdk.client.provider.auth().then((x) => setStore("provider_auth", reconcile(x.data ?? {}))),
             sdk.client.vcs.get().then((x) => setStore("vcs", reconcile(x.data))),
             sdk.client.path.get().then((x) => setStore("path", reconcile(x.data!))),
+            sdk.client.config.startupErrors().then((x) => {
+              const errors = x.data ?? []
+              if (errors.length === 0) return
+              toast.show({
+                variant: "error",
+                title: `Plugin Error${errors.length > 1 ? "s" : ""}`,
+                message: errors.join("\n\n"),
+                duration: errors.length === 1 ? 10000 : 15000,
+              })
+            }),
           ]).then(() => {
             setStore("status", "complete")
           })

packages/opencode/src/plugin/index.ts

@@ -13,6 +13,53 @@ import { NamedError } from "@opencode-ai/util/error"
 import { CopilotAuthPlugin } from "./copilot"
 import { gitlabAuthPlugin as GitlabAuthPlugin } from "@gitlab/opencode-gitlab-auth"
 
+interface BuildMessage {
+  message: string
+  position?: {
+    file?: string
+    line?: number
+    column?: number
+    lineText?: string
+  }
+}
+
+interface ResolveMessage {
+  name: string
+  message: string
+  code: string
+  specifier: string
+  referrer?: string
+}
+
+function isResolveMessage(e: unknown): e is ResolveMessage {
+  return (
+    typeof e === "object" &&
+    e !== null &&
+    "name" in e &&
+    (e as { name: string }).name === "ResolveMessage" &&
+    "specifier" in e
+  )
+}
+
+function formatPluginBuildError(e: unknown, plugin: string): string {
+  if (isResolveMessage(e)) {
+    const path = e.specifier.replace("file://", "")
+    return `File not found: ${path}`
+  }
+  if (e instanceof AggregateError && e.errors?.length) {
+    const buildError = e.errors.find((err): err is BuildMessage => err && typeof err === "object" && "message" in err)
+    if (buildError) {
+      const pos = buildError.position
+      const file = pos?.file ? pos.file.replace(plugin, "").replace(/^\/+/, "") : undefined
+      const line = pos?.line
+      const details = file ? `${file}:${line ?? "?"}` : line ? `line ${line}` : undefined
+      return details ? `${buildError.message} (${details})` : buildError.message
+    }
+  }
+  if (e instanceof Error) return e.message
+  return String(e)
+}
+
 export namespace Plugin {
   const log = Log.create({ service: "plugin" })
 
@@ -21,6 +68,24 @@ export namespace Plugin {
   // Built-in plugins that are directly imported (not installed from npm)
   const INTERNAL_PLUGINS: PluginInstance[] = [CodexAuthPlugin, CopilotAuthPlugin, GitlabAuthPlugin]
 
+  const startupErrors: string[] = []
+
+  function recordError(message: string) {
+    startupErrors.push(message)
+    log.error("plugin error", { message })
+    Bus.publish(Session.Event.Error, {
+      error: new NamedError.Unknown({ message }).toObject(),
+    })
+  }
+
+  export function getStartupErrors(): string[] {
+    return [...startupErrors]
+  }
+
+  export function clearStartupErrors() {
+    startupErrors.length = 0
+  }
+
   const state = Instance.state(async () => {
     const client = createOpencodeClient({
       baseUrl: "http://localhost:4096",
@@ -64,37 +129,30 @@ export namespace Plugin {
         plugin = await BunProc.install(pkg, version).catch((err) => {
           const cause = err instanceof Error ? err.cause : err
           const detail = cause instanceof Error ? cause.message : String(cause ?? err)
-          log.error("failed to install plugin", { pkg, version, error: detail })
-          Bus.publish(Session.Event.Error, {
-            error: new NamedError.Unknown({
-              message: `Failed to install plugin ${pkg}@${version}: ${detail}`,
-            }).toObject(),
-          })
+          recordError(`Failed to install plugin ${pkg}@${version}: ${detail}`)
           return ""
         })
         if (!plugin) continue
       }
       // Prevent duplicate initialization when plugins export the same function
       // as both a named export and default export (e.g., `export const X` and `export default X`).
       // Object.entries(mod) would return both entries pointing to the same function reference.
-      await import(plugin)
-        .then(async (mod) => {
-          const seen = new Set<PluginInstance>()
-          for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
-            if (seen.has(fn)) continue
-            seen.add(fn)
-            hooks.push(await fn(input))
-          }
-        })
-        .catch((err) => {
-          const message = err instanceof Error ? err.message : String(err)
-          log.error("failed to load plugin", { path: plugin, error: message })
-          Bus.publish(Session.Event.Error, {
-            error: new NamedError.Unknown({
-              message: `Failed to load plugin ${plugin}: ${message}`,
-            }).toObject(),
-          })
-        })
+      let mod: Record<string, PluginInstance>
+      try {
+        mod = await import(plugin)
+      } catch (e) {
+        const name = Config.getPluginName(plugin)
+        const message = formatPluginBuildError(e, plugin)
+        recordError(`Failed to load plugin "${name}": ${message}`)
+        continue
+      }
+      const seen = new Set<PluginInstance>()
+      for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
+        if (seen.has(fn)) continue
+        seen.add(fn)
+        const init = await fn(input)
+        hooks.push(init)
+      }
     }
 
     return {

packages/opencode/src/server/routes/config.ts

@@ -7,6 +7,7 @@ import { mapValues } from "remeda"
 import { errors } from "../error"
 import { Log } from "../../util/log"
 import { lazy } from "../../util/lazy"
+import { Plugin } from "../../plugin"
 
 const log = Log.create({ service: "server" })
 
@@ -88,5 +89,28 @@ export const ConfigRoutes = lazy(() =>
           default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),
         })
       },
+    )
+    .get(
+      "/startup-errors",
+      describeRoute({
+        summary: "Get startup errors",
+        description: "Retrieve any errors that occurred during plugin loading at startup.",
+        operationId: "config.startupErrors",
+        responses: {
+          200: {
+            description: "List of startup errors",
+            content: {
+              "application/json": {
+                schema: resolver(z.array(z.string())),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        const errors = Plugin.getStartupErrors()
+        Plugin.clearStartupErrors()
+        return c.json(errors)
+      },
     ),
 )

packages/sdk/js/src/v2/gen/sdk.gen.ts

@@ -17,6 +17,7 @@ import type {
   Config as Config3,
   ConfigGetResponses,
   ConfigProvidersResponses,
+  ConfigStartupErrorsResponses,
   ConfigUpdateErrors,
   ConfigUpdateResponses,
   EventSubscribeResponses,
@@ -720,6 +721,25 @@ export class Config2 extends HeyApiClient {
       ...params,
     })
   }
+
+  /**
+   * Get startup errors
+   *
+   * Retrieve any errors that occurred during plugin loading at startup.
+   */
+  public startupErrors<ThrowOnError extends boolean = false>(
+    parameters?: {
+      directory?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "directory" }] }])
+    return (options?.client ?? this.client).get<ConfigStartupErrorsResponses, unknown, ThrowOnError>({
+      url: "/config/startup-errors",
+      ...options,
+      ...params,
+    })
+  }
 }
 
 export class Tool extends HeyApiClient {

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -2345,6 +2345,24 @@ export type ConfigProvidersResponses = {
 
 export type ConfigProvidersResponse = ConfigProvidersResponses[keyof ConfigProvidersResponses]
 
+export type ConfigStartupErrorsData = {
+  body?: never
+  path?: never
+  query?: {
+    directory?: string
+  }
+  url: "/config/startup-errors"
+}
+
+export type ConfigStartupErrorsResponses = {
+  /**
+   * List of startup errors
+   */
+  200: Array<string>
+}
+
+export type ConfigStartupErrorsResponse = ConfigStartupErrorsResponses[keyof ConfigStartupErrorsResponses]
+
 export type ToolIdsData = {
   body?: never
   path?: never