opencode-rgbify-plugin 0.1.3

package/bridge/install.ps1

@@ -0,0 +1,68 @@
+# Self-sufficient Windows installer for the RGBify bridge. Installs EVERYTHING
+# the bridge depends on, user-level, no admin:
+#   uv          — Python/venv manager (installed into ~\.local\bin if missing)
+#   Python      — uv-managed interpreter
+#   bleak       — BLE connection to the projector (required)
+#   miniaudio   — host auralizer (bundles its own native lib; cross-platform)
+#
+# Idempotent: re-running is a cheap no-op (each step skips if already done).
+#
+# Optional: pass a target plugin root as $1 to build the venv elsewhere (e.g.
+# after the plugin is copied into ~/.config/opencode). Defaults to this repo.
+param([string]$PluginRoot)
+
+$ErrorActionPreference = "Stop"
+
+if (-not $PluginRoot) {
+    $PluginRoot = Join-Path $PSScriptRoot ".."
+}
+$PluginRoot = (Resolve-Path $PluginRoot).Path
+$VenvDir = Join-Path $PluginRoot ".venv"
+$VenvPy = Join-Path $VenvDir "Scripts\python.exe"
+
+function Say($msg) { Write-Host "== $msg" }
+
+# ── 1 — uv (installs Python + manages the venv, no admin needed) ──
+if (Get-Command uv -ErrorAction SilentlyContinue) {
+    Say "uv already installed: $(uv --version)"
+} else {
+    Say "Installing uv (user-level)..."
+    irm https://astral.sh/uv/install.ps1 | iex
+    # uv installs into ~\.local\bin; add to this process's PATH
+    $env:PATH = "$env:USERPROFILE\.local\bin;$env:PATH"
+    if (-not (Get-Command uv -ErrorAction SilentlyContinue)) {
+        throw "uv install failed"
+    }
+    Say "uv installed: $(uv --version)"
+}
+
+# ── 2 — Python (uv-managed, user-level, no admin) ──
+$PyVer = if ($env:RGBIFY_PYTHON) { $env:RGBIFY_PYTHON } else { "3.12" }
+if (Test-Path $VenvPy) {
+    Say "venv already present: $VenvDir"
+} else {
+    Say "Ensuring Python $PyVer via uv..."
+    uv python install $PyVer | Out-Null
+    Say "Creating venv with uv at $VenvDir"
+    uv venv --python $PyVer $VenvDir
+}
+
+# ── 3 — Install deps ──
+Say "Installing bridge deps into venv..."
+uv pip install --python $VenvPy bleak miniaudio
+
+# ── 4 — Verify imports (-B: no bytecode cache, keeps the tree clean) ──
+& $VenvPy -B -c "import bleak" 2>$null
+if ($LASTEXITCODE -eq 0) {
+    Say "bleak OK"
+} else {
+    throw "bleak failed to import"
+}
+& $VenvPy -B -c "import miniaudio" 2>$null
+if ($LASTEXITCODE -eq 0) {
+    Say "miniaudio OK"
+} else {
+    Write-Host "WARN: miniaudio unavailable - host auralizer disabled, projector still works"
+}
+
+Say "Done. Bridge venv ready at $VenvDir"

package/bridge/install.sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+# Self-sufficient installer for the RGBify bridge. Installs EVERYTHING the
+# bridge depends on, user-level, no root:
+#   uv          — Python/venv manager (installed into ~/.local/bin if missing)
+#   Python      — uv-managed interpreter (into ~/.local/share/uv/python)
+#   bleak       — BLE connection to the projector (required)
+#   miniaudio   — host auralizer (bundles its own native lib; cross-platform)
+#
+# Idempotent: re-running is a cheap no-op (each step skips if already done).
+#
+# Optional: pass a target plugin root as $1 to build the venv elsewhere (e.g.
+# after the plugin is copied into ~/.config/opencode). Defaults to this repo.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PLUGIN_ROOT="${1:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+VENV_DIR="$PLUGIN_ROOT/.venv"
+VENV_PY="$VENV_DIR/bin/python"
+
+# UV is installed to ~/.local/bin; make sure it's on PATH for this shell even
+# if it was just installed by this script.
+export PATH="$HOME/.local/bin:$PATH"
+
+say() { echo "== $*"; }
+
+# ── 1 — uv (installs Python + manages the venv, no root needed) ──
+if command -v uv >/dev/null 2>&1; then
+    say "uv already installed: $(uv --version)"
+else
+    say "Installing uv (user-level)..."
+    curl -LsSf https://astral.sh/uv/install.sh | sh
+    command -v uv >/dev/null 2>&1 || {
+        echo "ERROR: uv install failed" >&2
+        exit 1
+    }
+    say "uv installed: $(uv --version)"
+fi
+
+# ── 2 — Python (uv-managed, into ~/.local/share/uv/python, no root) ──
+PYVER="${RGBIFY_PYTHON:-3.12}"
+if "$VENV_PY" -c 'import sys; sys.exit(0)' >/dev/null 2>&1; then
+    say "venv already present: $VENV_DIR"
+else
+    say "Ensuring Python $PYVER via uv..."
+    uv python install "$PYVER" || true   # no-op if uv already has it
+    say "Creating venv with uv at $VENV_DIR"
+    uv venv --python "$PYVER" "$VENV_DIR"
+fi
+
+# ── 3 — Install deps ──
+say "Installing bridge deps into venv..."
+uv pip install --python "$VENV_PY" bleak miniaudio
+
+# ── 4 — Verify imports (-B: no bytecode cache, keeps the tree clean) ──
+if "$VENV_PY" -B -c 'import bleak' 2>/dev/null; then
+    say "bleak OK"
+else
+    echo "ERROR: bleak failed to import — check the install above" >&2
+    exit 1
+fi
+if "$VENV_PY" -B -c 'import miniaudio' 2>/dev/null; then
+    say "miniaudio OK"
+else
+    echo "WARN: miniaudio unavailable — host auralizer disabled, projector still works" >&2
+fi
+
+say "Done. Bridge venv ready at $VENV_DIR"

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const RGBifyProjectorPlugin: Plugin;

package/dist/index.js

@@ -0,0 +1,231 @@
+import { spawn } from "bun";
+import { existsSync, appendFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+const here = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = path.join(here, "..");
+const BRIDGE = path.join(here, "..", "bridge", "ble_bridge.py");
+// Cross-platform bootstrap: uv lays out the venv differently on Windows
+// (.venv\Scripts\python.exe vs .venv/bin/python) and there is no bash by
+// default, so both the interpreter path and the installer script are chosen
+// by platform.
+const IS_WINDOWS = process.platform === "win32";
+const BRIDGE_INSTALL = IS_WINDOWS
+    ? path.join(here, "..", "bridge", "install.ps1")
+    : path.join(here, "..", "bridge", "install.sh");
+const VENV_PYTHON = IS_WINDOWS
+    ? path.join(here, "..", ".venv", "Scripts", "python.exe")
+    : path.join(here, "..", ".venv", "bin", "python");
+const DEBUG_LOG = process.env.RGBIFY_DEBUG_LOG;
+function debug(line) {
+    if (!DEBUG_LOG)
+        return;
+    try {
+        appendFileSync(DEBUG_LOG, `${Date.now()} ${line}\n`);
+    }
+    catch { }
+}
+// Self-bootstrap: on first use, if the bridge venv doesn't exist, run the
+// platform installer to install EVERYTHING (uv, Python, bleak, miniaudio) as
+// the user, no root/admin. A shared promise guards against concurrent send()s
+// triggering a duplicate install. Re-running the installer is idempotent.
+let bootstrapPromise = null;
+async function bootstrapPython() {
+    if (existsSync(VENV_PYTHON))
+        return VENV_PYTHON;
+    if (bootstrapPromise)
+        return bootstrapPromise;
+    bootstrapPromise = (async () => {
+        debug("bootstrap: bridge venv missing, running installer");
+        try {
+            // On Windows there's no bash by default; run the .ps1 via powershell.
+            const args = IS_WINDOWS
+                ? ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", BRIDGE_INSTALL, PLUGIN_ROOT]
+                : ["bash", BRIDGE_INSTALL, PLUGIN_ROOT];
+            const proc = spawn(args, {
+                stdin: "pipe",
+                stdout: "pipe",
+                stderr: "pipe",
+            });
+            void proc.stdout?.pipeTo(new WritableStream({ write() { } }));
+            void proc.stderr?.pipeTo(new WritableStream({ write() { } }));
+            const exitCode = await proc.exited;
+            debug(`bootstrap: installer exited ${exitCode}`);
+            return existsSync(VENV_PYTHON) ? VENV_PYTHON : null;
+        }
+        catch (err) {
+            debug(`bootstrap: installer failed: ${err}`);
+            return null;
+        }
+    })();
+    return bootstrapPromise;
+}
+function isEnabled() {
+    return process.env.RGBIFY_DISABLE !== "1" && process.env.RGBIFY_DISABLE !== "true";
+}
+// NO sanitization — raw delta text goes straight to the bridge. Both auralizers
+// tolerate any byte (out-of-range chars play as rests), so nothing can crash or
+// wedge. History: sanitize() existed for the scrolling-display era, where tags
+// in the text would scroll across the 8x8 matrix; the firmware now blits one
+// char at a time, so tags are harmless. Worse, the old tag-swallowing state
+// machine could stick on an unbalanced `<` and silently discard entire streams
+// for minutes — the long-standing "both auralizers go silent" bug. Raw is both
+// simpler and poison-proof.
+export const RGBifyProjectorPlugin = async ({ client }) => {
+    if (!isEnabled())
+        return {};
+    let procPromise = null;
+    const seenEventTypes = new Set();
+    function startBridge() {
+        if (procPromise)
+            return procPromise;
+        procPromise = (async () => {
+            const python = await bootstrapPython();
+            if (!python)
+                throw new Error("bridge deps not installed (install.sh failed)");
+            const proc = spawn([python, BRIDGE], {
+                stdin: "pipe",
+                stdout: "pipe",
+                stderr: "pipe",
+                // Skip BLE discovery (a ~5s scan) on every connect: default to the
+                // projector's fixed address unless the user overrides it.
+                env: {
+                    ...process.env,
+                    RGBIFY_PROJECTOR_ADDR: process.env.RGBIFY_PROJECTOR_ADDR || "40:91:51:AB:50:CE",
+                },
+            });
+            void proc.stdout?.pipeTo(new WritableStream({ write() { } }));
+            void proc.stderr?.pipeTo(new WritableStream({ write() { } }));
+            // proc.exited RESOLVES (with the exit code) on exit — it does NOT reject,
+            // so a `.catch` would never fire and the bridge would never respawn. Use
+            // `.finally` so a dead bridge is replaced by the next send().
+            void proc.exited.finally(() => {
+                procPromise = null;
+            });
+            return proc;
+        })();
+        return procPromise;
+    }
+    // Delivery: raw delta text is COALESCED into full-length messages. opencode
+    // emits deltas in bursts of tiny fragments (avg ~4 chars); per-delta sends
+    // produced 140ms notes separated by 600-800ms holes. Instead, accumulate
+    // text and emit a full TAIL_CHARS message whenever the buffer fills — or
+    // after FLUSH_MS of quiet, so tails aren't lost and sound stops promptly
+    // when printing stops. The bridge chains whatever is queued straight after
+    // each ACK, so during continuous printing the notes play back-to-back.
+    const TAIL_CHARS = 8;
+    const FLUSH_MS = 150;
+    let buf = "";
+    let flushTimer = null;
+    function flushBuf() {
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+        }
+        const line = buf.slice(-TAIL_CHARS);
+        buf = "";
+        if (line)
+            writeLine(line);
+    }
+    function writeLine(line) {
+        debug(`send len=${line.length}`);
+        startBridge()
+            .then((proc) => {
+            // We always spawn the bridge with stdin: "pipe", so it's a FileSink.
+            const stdin = proc.stdin;
+            stdin.write(line + "\n");
+            // Bun's FileSink buffers writes; without flush() the bridge receives
+            // them in delayed bursts, desyncing the projector/host from opencode.
+            const r = stdin.flush();
+            if (r && typeof r.then === "function") {
+                ;
+                r.catch(() => { });
+            }
+        })
+            .catch(async (err) => {
+            await client.app.log({
+                body: { service: "rgbify", level: "warn", message: `bridge unavailable: ${err}` },
+            });
+        });
+    }
+    function send(text) {
+        // Raw text, coalesced — no sanitization (see the note above).
+        buf += text;
+        if (buf.length >= TAIL_CHARS) {
+            flushBuf();
+            return;
+        }
+        if (!flushTimer)
+            flushTimer = setTimeout(flushBuf, FLUSH_MS);
+    }
+    startBridge().catch(async (err) => {
+        await client.app.log({
+            body: { service: "rgbify", level: "warn", message: `bridge unavailable: ${err}` },
+        });
+    });
+    return {
+        event: async ({ event }) => {
+            // The installed @opencode-ai/plugin types (v1.17.0) don't yet declare the
+            // token-level delta events we consume, so treat the event loosely here.
+            const t = event.type;
+            if (!seenEventTypes.has(t)) {
+                seenEventTypes.add(t);
+                debug(`event type=${t}`);
+            }
+            // Token-level streaming deltas — fire per-token as the LLM streams,
+            // before opencode renders the accumulated part. Small, so the projector
+            // keeps up and stays in sync with the session.
+            if (t === "message.part.delta") {
+                const p = event.properties;
+                // Only stream text/reasoning deltas. Tool-part deltas carry opencode
+                // internal tool-call JSON (messageID/callID/...) that would render as
+                // garbage on the projector; tool lifecycle is signalled separately.
+                if (p?.field === "text" || p?.field === "reasoning") {
+                    if (typeof p.delta === "string" && p.delta) {
+                        send(p.delta);
+                    }
+                }
+                return;
+            }
+            if (t === "session.next.text.delta" || t === "session.next.reasoning.delta") {
+                const p = event.properties;
+                if (typeof p?.delta === "string" && p.delta) {
+                    send(p.delta);
+                }
+                return;
+            }
+        },
+        "chat.message": async (_input, output) => {
+            for (const part of output.parts) {
+                if (part.type !== "text")
+                    continue;
+                send(part.text);
+            }
+        },
+        "tool.execute.before": async (input) => {
+            send("tool IN");
+        },
+        "tool.execute.after": async () => {
+            send("tool out");
+        },
+        // When opencode shuts down, kill the bridge so it doesn't linger as an
+        // orphan holding the projector connection. Closing its stdin would also do
+        // it (the bridge exits on EOF), but kill is immediate and explicit.
+        dispose: async () => {
+            // Drop any pending coalesced text — the session is over.
+            if (flushTimer) {
+                clearTimeout(flushTimer);
+                flushTimer = null;
+            }
+            buf = "";
+            if (procPromise) {
+                try {
+                    const proc = await procPromise;
+                    proc.kill();
+                }
+                catch { }
+                procPromise = null;
+            }
+        },
+    };
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "opencode-rgbify-plugin",
+  "version": "0.1.3",
+  "description": "opencode plugin: stream chat text deltas to an RGBify 8x8 projector over BLE",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bridge",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.17.0",
+    "@types/bun": "^1.4.0",
+    "@types/node": "^26.3.0",
+    "typescript": "^5.9.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,241 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import { spawn } from "bun"
+import { existsSync, appendFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import path from "node:path"
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const PLUGIN_ROOT = path.join(here, "..")
+const BRIDGE = path.join(here, "..", "bridge", "ble_bridge.py")
+// Cross-platform bootstrap: uv lays out the venv differently on Windows
+// (.venv\Scripts\python.exe vs .venv/bin/python) and there is no bash by
+// default, so both the interpreter path and the installer script are chosen
+// by platform.
+const IS_WINDOWS = process.platform === "win32"
+const BRIDGE_INSTALL = IS_WINDOWS
+  ? path.join(here, "..", "bridge", "install.ps1")
+  : path.join(here, "..", "bridge", "install.sh")
+const VENV_PYTHON = IS_WINDOWS
+  ? path.join(here, "..", ".venv", "Scripts", "python.exe")
+  : path.join(here, "..", ".venv", "bin", "python")
+const DEBUG_LOG = process.env.RGBIFY_DEBUG_LOG
+
+function debug(line: string) {
+  if (!DEBUG_LOG) return
+  try {
+    appendFileSync(DEBUG_LOG, `${Date.now()} ${line}\n`)
+  } catch {}
+}
+
+// Self-bootstrap: on first use, if the bridge venv doesn't exist, run the
+// platform installer to install EVERYTHING (uv, Python, bleak, miniaudio) as
+// the user, no root/admin. A shared promise guards against concurrent send()s
+// triggering a duplicate install. Re-running the installer is idempotent.
+let bootstrapPromise: Promise<string | null> | null = null
+
+async function bootstrapPython(): Promise<string | null> {
+  if (existsSync(VENV_PYTHON)) return VENV_PYTHON
+  if (bootstrapPromise) return bootstrapPromise
+  bootstrapPromise = (async () => {
+    debug("bootstrap: bridge venv missing, running installer")
+    try {
+      // On Windows there's no bash by default; run the .ps1 via powershell.
+      const args = IS_WINDOWS
+        ? ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", BRIDGE_INSTALL, PLUGIN_ROOT]
+        : ["bash", BRIDGE_INSTALL, PLUGIN_ROOT]
+      const proc = spawn(args, {
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+      })
+      void proc.stdout?.pipeTo(new WritableStream({ write() {} }))
+      void proc.stderr?.pipeTo(new WritableStream({ write() {} }))
+      const exitCode = await proc.exited
+      debug(`bootstrap: installer exited ${exitCode}`)
+      return existsSync(VENV_PYTHON) ? VENV_PYTHON : null
+    } catch (err) {
+      debug(`bootstrap: installer failed: ${err}`)
+      return null
+    }
+  })()
+  return bootstrapPromise
+}
+
+function isEnabled(): boolean {
+  return process.env.RGBIFY_DISABLE !== "1" && process.env.RGBIFY_DISABLE !== "true"
+}
+
+// NO sanitization — raw delta text goes straight to the bridge. Both auralizers
+// tolerate any byte (out-of-range chars play as rests), so nothing can crash or
+// wedge. History: sanitize() existed for the scrolling-display era, where tags
+// in the text would scroll across the 8x8 matrix; the firmware now blits one
+// char at a time, so tags are harmless. Worse, the old tag-swallowing state
+// machine could stick on an unbalanced `<` and silently discard entire streams
+// for minutes — the long-standing "both auralizers go silent" bug. Raw is both
+// simpler and poison-proof.
+
+export const RGBifyProjectorPlugin: Plugin = async ({ client }) => {
+  if (!isEnabled()) return {}
+
+  let procPromise: Promise<ReturnType<typeof spawn>> | null = null
+  const seenEventTypes = new Set<string>()
+
+  function startBridge(): Promise<ReturnType<typeof spawn>> {
+    if (procPromise) return procPromise
+    procPromise = (async () => {
+      const python = await bootstrapPython()
+      if (!python) throw new Error("bridge deps not installed (install.sh failed)")
+      const proc = spawn([python, BRIDGE], {
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        // Skip BLE discovery (a ~5s scan) on every connect: default to the
+        // projector's fixed address unless the user overrides it.
+        env: {
+          ...process.env,
+          RGBIFY_PROJECTOR_ADDR:
+            process.env.RGBIFY_PROJECTOR_ADDR || "40:91:51:AB:50:CE",
+        },
+      })
+      void proc.stdout?.pipeTo(new WritableStream({ write() {} }))
+      void proc.stderr?.pipeTo(
+        new WritableStream({ write() {} }),
+      )
+      // proc.exited RESOLVES (with the exit code) on exit — it does NOT reject,
+      // so a `.catch` would never fire and the bridge would never respawn. Use
+      // `.finally` so a dead bridge is replaced by the next send().
+      void proc.exited.finally(() => {
+        procPromise = null
+      })
+      return proc
+    })()
+    return procPromise
+  }
+
+  // Delivery: raw delta text is COALESCED into full-length messages. opencode
+  // emits deltas in bursts of tiny fragments (avg ~4 chars); per-delta sends
+  // produced 140ms notes separated by 600-800ms holes. Instead, accumulate
+  // text and emit a full TAIL_CHARS message whenever the buffer fills — or
+  // after FLUSH_MS of quiet, so tails aren't lost and sound stops promptly
+  // when printing stops. The bridge chains whatever is queued straight after
+  // each ACK, so during continuous printing the notes play back-to-back.
+  const TAIL_CHARS = 8
+  const FLUSH_MS = 150
+  let buf = ""
+  let flushTimer: ReturnType<typeof setTimeout> | null = null
+
+  function flushBuf() {
+    if (flushTimer) {
+      clearTimeout(flushTimer)
+      flushTimer = null
+    }
+    const line = buf.slice(-TAIL_CHARS)
+    buf = ""
+    if (line) writeLine(line)
+  }
+
+  function writeLine(line: string) {
+    debug(`send len=${line.length}`)
+    startBridge()
+      .then((proc) => {
+        // We always spawn the bridge with stdin: "pipe", so it's a FileSink.
+        const stdin = proc.stdin as unknown as {
+          write(s: string): void
+          flush(): number | Promise<number>
+        }
+        stdin.write(line + "\n")
+        // Bun's FileSink buffers writes; without flush() the bridge receives
+        // them in delayed bursts, desyncing the projector/host from opencode.
+        const r = stdin.flush()
+        if (r && typeof (r as Promise<number>).then === "function") {
+          ;(r as Promise<number>).catch(() => {})
+        }
+      })
+      .catch(async (err) => {
+        await client.app.log({
+          body: { service: "rgbify", level: "warn", message: `bridge unavailable: ${err}` },
+        })
+      })
+  }
+
+  function send(text: string) {
+    // Raw text, coalesced — no sanitization (see the note above).
+    buf += text
+    if (buf.length >= TAIL_CHARS) {
+      flushBuf()
+      return
+    }
+    if (!flushTimer) flushTimer = setTimeout(flushBuf, FLUSH_MS)
+  }
+
+  startBridge().catch(async (err) => {
+    await client.app.log({
+      body: { service: "rgbify", level: "warn", message: `bridge unavailable: ${err}` },
+    })
+  })
+
+  return {
+    event: async ({ event }) => {
+      // The installed @opencode-ai/plugin types (v1.17.0) don't yet declare the
+      // token-level delta events we consume, so treat the event loosely here.
+      const t = (event as { type: string }).type
+      if (!seenEventTypes.has(t)) {
+        seenEventTypes.add(t)
+        debug(`event type=${t}`)
+      }
+
+      // Token-level streaming deltas — fire per-token as the LLM streams,
+      // before opencode renders the accumulated part. Small, so the projector
+      // keeps up and stays in sync with the session.
+      if (t === "message.part.delta") {
+        const p = (event as { properties?: { field?: string; delta?: string } }).properties
+        // Only stream text/reasoning deltas. Tool-part deltas carry opencode
+        // internal tool-call JSON (messageID/callID/...) that would render as
+        // garbage on the projector; tool lifecycle is signalled separately.
+        if (p?.field === "text" || p?.field === "reasoning") {
+          if (typeof p.delta === "string" && p.delta) {
+            send(p.delta)
+          }
+        }
+        return
+      }
+      if (t === "session.next.text.delta" || t === "session.next.reasoning.delta") {
+        const p = (event as { properties?: { delta?: string } }).properties
+        if (typeof p?.delta === "string" && p.delta) {
+          send(p.delta)
+        }
+        return
+      }
+    },
+    "chat.message": async (_input, output) => {
+      for (const part of output.parts) {
+        if (part.type !== "text") continue
+        send(part.text)
+      }
+    },
+    "tool.execute.before": async (input) => {
+      send("tool IN")
+    },
+    "tool.execute.after": async () => {
+      send("tool out")
+    },
+    // When opencode shuts down, kill the bridge so it doesn't linger as an
+    // orphan holding the projector connection. Closing its stdin would also do
+    // it (the bridge exits on EOF), but kill is immediate and explicit.
+    dispose: async () => {
+      // Drop any pending coalesced text — the session is over.
+      if (flushTimer) {
+        clearTimeout(flushTimer)
+        flushTimer = null
+      }
+      buf = ""
+      if (procPromise) {
+        try {
+          const proc = await procPromise
+          proc.kill()
+        } catch {}
+        procPromise = null
+      }
+    },
+  }
+}