fix(plugin): reject bootstrap client reentry

Guard the plugin HTTP client so requests issued from a plugin's server()
hook while the instance's plugins are still loading return a 409 instead of
re-entering the still-initializing instance and deadlocking. The guard is
cleared once plugin loading and config-notify hooks complete.

Ported from anomalyco#31859 (adapted onto this fork's createPluginClient transport).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: randomvariable

packages/opencode/src/plugin/client.ts

@@ -39,10 +39,20 @@ function rewriteRequest(request: Request, serverUrl: URL) {
   return new Request(new URL(`${url.pathname}${url.search}`, serverUrl), request)
 }
 
+export function pluginClientReentryResponse(directory: string) {
+  return new Response(`Plugin client request cannot enter instance ${directory} while its plugins are still loading`, {
+    status: 409,
+    headers: {
+      "content-type": "text/plain; charset=utf-8",
+    },
+  })
+}
+
 export function createPluginClient(input: {
   directory: string
   getServerUrl: () => URL
   fallbackFetch: ClientFetch
+  isBootstrapping?: () => boolean
 }) {
   return createOpencodeClient({
     baseUrl: "http://localhost",
@@ -52,8 +62,14 @@ export function createPluginClient(input: {
   })
 }
 
-export function createPluginFetch(input: { getServerUrl: () => URL; fallbackFetch: ClientFetch }): ClientFetch {
+export function createPluginFetch(input: {
+  directory?: string
+  getServerUrl: () => URL
+  fallbackFetch: ClientFetch
+  isBootstrapping?: () => boolean
+}): ClientFetch {
   return async (request: Request) => {
+    if (input.isBootstrapping?.()) return pluginClientReentryResponse(input.directory ?? "")
     const serverUrl = input.getServerUrl()
     if (await useLiveServer(serverUrl)) {
       const key = normalizeServerUrl(serverUrl)

packages/opencode/src/plugin/index.ts

@@ -146,10 +146,12 @@ const layer = Layer.effect(
         const { Server } = yield* Effect.promise(() => import("../server/server"))
 
         const getServerUrl = () => Server.url ?? new URL("http://localhost:4096")
+        let bootstrapping = true
         const client = createPluginClient({
           directory: ctx.directory,
           getServerUrl,
           fallbackFetch: async (request) => Server.Default().app.fetch(request),
+          isBootstrapping: () => bootstrapping,
         })
         const cfg = yield* config.get()
         const input: PluginInput = {
@@ -250,6 +252,8 @@ const layer = Layer.effect(
           )
         }
 
+        bootstrapping = false
+
         const unsubscribe = yield* events.listen((event) => {
           if (event.location?.directory !== ctx.directory) return Effect.void
           return Effect.sync(() => {

packages/opencode/test/server/httpapi-listen.test.ts

@@ -167,6 +167,49 @@ async function openPtySocket(listener: Awaited<ReturnType<typeof startListener>>
 }
 
 describe("HttpApi Server.listen", () => {
+  test("rejects plugin client re-entry while plugins are loading", async () => {
+    await using tmp = await tmpdir({
+      config: { formatter: false, lsp: false, plugin: ["./server-plugin.js"] },
+      init: async (dir) => {
+        await Bun.write(
+          path.join(dir, "server-plugin.js"),
+          `export default {
+  id: "plugin-client-reentry-probe",
+  async server(input) {
+    try {
+      const result = await input.client.config.get();
+      await Bun.write(${JSON.stringify(path.join(dir, "plugin-client-result.json"))}, JSON.stringify({ ok: !result.error, error: result.error }));
+    } catch (error) {
+      await Bun.write(${JSON.stringify(path.join(dir, "plugin-client-result.json"))}, JSON.stringify({ ok: false, error: String(error) }));
+    }
+    return {};
+  },
+};
+`,
+        )
+      },
+    })
+    const listener = await startListener()
+    try {
+      const response = await withTimeout(
+        fetch(new URL("/config", listener.url), {
+          headers: { authorization: authorization(), "x-opencode-directory": tmp.path },
+        }),
+        5_000,
+        "timed out waiting for plugin re-entry guarded request",
+      )
+      expect(response.status).toBe(200)
+      const result = JSON.parse(await Bun.file(path.join(tmp.path, "plugin-client-result.json")).text()) as {
+        ok?: boolean
+        error?: unknown
+      }
+      expect(result.ok).toBe(false)
+      expect(JSON.stringify(result.error)).toContain("Plugin client request cannot enter instance")
+    } finally {
+      await stop(listener, "timed out cleaning up plugin re-entry listener").catch(() => undefined)
+    }
+  })
+
   testPty("serves HTTP routes and upgrades PTY websocket through Server.listen", async () => {
     await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
     const listener = await startListener()