Support OpenCode V1 and V2 from one package

.github/workflows/ci.yml

@@ -2,6 +2,7 @@ name: Build and Test
 
 on:
   pull_request:
+  workflow_dispatch:
   push:
     branches:
       - main
@@ -41,12 +42,63 @@ jobs:
       - name: Test
         run: npm test
 
-      - name: Build
-        run: npm run build
+      - name: Build dual-host package
+        run: npm run build:all
 
       - name: Verify package
         run: npm pack --dry-run
 
+      - name: Test packed package in OpenCode 2 with a deterministic provider
+        run: npm run test:v2:e2e
+
+  hosts:
+    name: Package-name install across OpenCode hosts
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v6
+        with:
+          node-version: "24"
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.9"
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Install the packed plugin by name in V1 and V2 hosts
+        run: npm run test:hosts:e2e
+
+  v2-live:
+    name: V2 live-model E2E
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v6
+        with:
+          node-version: "24"
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.9"
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Test packed package with a hosted free model
+        run: npm run test:v2:e2e:live
+
   verify-windows-agent-config:
     runs-on: windows-latest
     steps:

.github/workflows/release.yml

@@ -63,11 +63,20 @@ jobs:
       - name: Pack dry-run
         run: npm pack --dry-run
 
+      - name: Test packed package in OpenCode 2 with a deterministic provider
+        run: npm run test:v2:e2e
+
+      - name: Test packed package in OpenCode 2 with a hosted free model
+        run: npm run test:v2:e2e:live
+
+      - name: Install the packed plugin by name in V1 and V2 hosts
+        run: npm run test:hosts:e2e
+
   publish-npm:
     needs: verify
     runs-on: ubuntu-latest
     permissions:
-      contents: read
+      contents: write
       id-token: write
     steps:
       - name: Checkout
@@ -89,3 +98,13 @@ jobs:
 
       - name: Publish to npm
         run: npm publish --access public --provenance
+
+      - name: Create GitHub release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          if gh release view "$GITHUB_REF_NAME" >/dev/null 2>&1; then
+            echo "GitHub release already exists: $GITHUB_REF_NAME"
+          else
+            gh release create "$GITHUB_REF_NAME" --verify-tag --generate-notes --title "$GITHUB_REF_NAME"
+          fi

.github/workflows/v1-e2e.yml

@@ -23,7 +23,7 @@ jobs:
         run: bun install --frozen-lockfile
 
       - name: Install OpenCode V1
-        run: bun install --global opencode-ai@1.18.3
+        run: bun install --global opencode-ai@1.18.29
 
       - name: Run V1 headless E2E tests
         run: npm run test:v1:e2e

README.md

@@ -210,6 +210,8 @@ Add to your `opencode.json`:
 }
 ```
 
+This works unchanged on OpenCode 1.x and OpenCode 2 (which also accepts `"plugins"`). On OpenCode 2, hooks cannot show toasts yet; everything else works the same.
+
 ## Configuration
 
 ### Config Locations
@@ -415,7 +417,7 @@ Tool-arg matching is exact. This example runs only when the tool arg `path` equa
     },
     {
       "id": "session-idle",
-      "when": { "event": "session.idle" },
+      "when": { "event": "session.idle", "excludeSubagentWait": true },
       "run": ["notify-user.sh 'Waiting for input'"],
     },
   ],
@@ -448,6 +450,12 @@ background work remains or that OpenCode is specifically waiting for user input.
 If session lookup fails, hooks run without root filtering rather than being
 silently dropped.
 
+`excludeSubagentWait` is opt-in. When true, that `session.idle` hook also waits
+until all active `task` subagent calls for the root session have completed. Other
+idle hooks still run while the parent is waiting on a subagent. This is separate
+from `rootSessionOnly`: one filters child-session events, while the other filters
+parent idle events during active subagent calls.
+
 ---
 
 ## Template Placeholders

index.js

@@ -0,0 +1 @@
+export { default } from "./dist/entry.js"

package.json

@@ -3,21 +3,31 @@
   "version": "0.7.1",
   "description": "OpenCode plugin for declaratively attaching shell commands to tool, subagent, and session events",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/entry.js",
+  "types": "dist/entry.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/entry.d.ts",
+      "import": "./dist/entry.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
     }
   },
   "files": [
     "dist",
+    "index.js",
+    "server.js",
     "types"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build:all": "npm run build",
     "test": "bun test",
+    "test:v2": "bun test tests/v2.plugin.test.ts tests/v2.package.test.ts",
+    "test:v2:e2e": "OPENCODE2_E2E=1 bun test tests/e2e.v2.test.ts",
+    "test:v2:e2e:live": "OPENCODE2_E2E=1 OPENCODE2_E2E_LIVE=1 bun test tests/e2e.v2.test.ts",
     "lint": "eslint src tests --ext .ts",
     "typecheck": "tsc --noEmit",
     "ci:check": "npm run lint && npm run typecheck && npm test",
@@ -26,7 +36,8 @@
     "typecheck:bun-run": "bun run src/index.ts",
     "test:v1:e2e": "npm run build && OPENCODE_E2E=1 bun test tests/e2e.v1-headless.test.ts",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test:hosts:e2e": "OPENCODE_HOSTS_E2E=1 bun test tests/e2e.hosts.test.ts"
   },
   "keywords": [
     "opencode",

server.js

@@ -0,0 +1 @@
+export { default } from "./dist/server.js"

src/config/global.ts

@@ -15,7 +15,8 @@ import { mergeConfigs } from "./merge.js";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { stat } from "fs/promises";
-import JsoncParser, { type ParseError } from "jsonc-parser";
+import * as JsoncParser from "jsonc-parser";
+import type { ParseError } from "jsonc-parser";
 import { logger } from "../logging.js";
 
 /**

src/entry.ts

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { CommandHooksPlugin } from "./index.js"
+import plugin from "./server.js"
+
+/**
+ * Package root for OpenCode V1 before 1.3.4, which ignores the `./server`
+ * export and calls every root export as a plugin function. Current hosts
+ * resolve `./server` first, so they never load this module.
+ */
+const legacyPlugin = Object.assign((input: PluginInput) => CommandHooksPlugin(input), plugin)
+
+export default legacyPlugin

src/executor.ts

@@ -15,7 +15,6 @@
  * Errors are logged and optionally injected into the session, but never thrown.
  */
 
-import type { OpencodeClient } from "@opencode-ai/sdk"
 import { open, mkdtemp, rm } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
@@ -32,6 +31,19 @@ import { interpolateTemplate } from "./execution/template.js"
 import { logger } from "./logging.js"
 import { compileToolArgGlob, compileToolArgRegex } from "./matcher.js"
 
+export interface HookToast {
+  title?: string
+  message: string
+  variant?: "info" | "success" | "warning" | "error"
+  duration?: number
+}
+
+export interface HookHost {
+  cwd: string
+  inject: (sessionId: string, message: string, hookId: string) => Promise<void>
+  toast: (toast: HookToast) => Promise<void>
+}
+
 /**
  * Check if a value matches a pattern (string, array of strings, or wildcard)
  */
@@ -76,7 +88,7 @@ const matchesToolArg = (
  */
 export const filterSessionHooks = (
   hooks: SessionHook[],
-  criteria: { event: string; agent: string | undefined }
+  criteria: { event: string; agent: string | undefined; hasActiveSubagents?: boolean }
 ): SessionHook[] => {
   return hooks.filter((hook) => {
     // Normalize session.start to session.created
@@ -86,6 +98,11 @@ export const filterSessionHooks = (
     }
 
     if (normalizedEvent !== criteria.event) return false
+    if (
+      normalizedEvent === "session.idle" &&
+      hook.when.excludeSubagentWait &&
+      criteria.hasActiveSubagents
+    ) return false
 
     if (hook.when.agent && !criteria.agent) {
       logger.debug(
@@ -223,7 +240,7 @@ const createHookArgsFile = async (
  * @returns Promise that resolves when toast is shown
  */
 const showToast = async (
-    client: OpencodeClient,
+    host: HookHost,
     title: string | undefined,
     message: string,
     variant: "info" | "success" | "warning" | "error" = "info",
@@ -233,14 +250,7 @@ const showToast = async (
         const finalTitle = title || "OpenCode Command Hook"
         logger.debug(`Showing toast: title="${finalTitle}", message="${message.substring(0, 50)}...", variant="${variant}", duration=${duration}`)
 
-        await client.tui.showToast({
-            body: {
-                title: finalTitle,
-                message,
-                variant,
-                duration,
-            },
-        })
+         await host.toast({ title: finalTitle, message, variant, duration })
 
         logger.info(`[toast] ${finalTitle}: ${message}`)
     } catch (error) {
@@ -263,19 +273,15 @@ const showToast = async (
  * @returns Promise that resolves when message is injected
  */
 const injectMessage = async (
-   client: OpencodeClient,
+   host: HookHost,
    sessionId: string,
-   message: string
+   message: string,
+   hookId: string,
 ): Promise<void> => {
     try {
        logger.debug(`Injecting message into session ${sessionId}`)
 
-     await client.session.promptAsync({
-       path: { id: sessionId },
-       body: {
-         parts: [{ type: "text", text: message }],
-       },
-     })
+     await host.inject(sessionId, message, hookId)
 
        logger.info(`[inject] Message injected into session ${sessionId}: ${message.substring(0, 100)}${message.length > 100 ? '...' : ''}`)
      } catch (error) {
@@ -302,7 +308,7 @@ const injectMessage = async (
  const executeHook = async (
    hook: ToolHook | SessionHook,
    context: HookExecutionContext,
-   client: OpencodeClient,
+    host: HookHost,
    truncationLimit?: number
 ): Promise<void> => {
    const hookType = isToolHook(hook) ? "tool" : "session"
@@ -327,10 +333,8 @@ const injectMessage = async (
             hook.id,
             {
               truncateOutput: truncationLimit,
-              cwd: context.directory,
-              env: {
-                OPENCODE_HOOK_ARGS_FILE: argsFile.path,
-              },
+              cwd: host.cwd,
+              env: { OPENCODE_HOOK_ARGS_FILE: argsFile.path },
             },
           )
         } finally {
@@ -346,7 +350,7 @@ const injectMessage = async (
       } else if (hook.run) {
         results = await executeCommands(hook.run, hook.id, {
           truncateOutput: truncationLimit,
-          cwd: context.directory,
+          cwd: host.cwd,
         })
       }
 
@@ -370,7 +374,7 @@ const injectMessage = async (
       // If inject is configured, prepare and inject the message
       if (hook.inject) {
         const message = interpolateTemplate(hook.inject, templateContext)
-        await injectMessage(client, context.sessionId, message)
+         await injectMessage(host, context.sessionId, message, hook.id)
       }
 
       // If toast is configured, interpolate and show toast notification
@@ -379,7 +383,7 @@ const injectMessage = async (
         const toastMessage = interpolateTemplate(hook.toast.message, templateContext)
 
        await showToast(
-         client,
+          host,
          toastTitle,
          toastMessage,
          hook.toast.variant || "info",
@@ -391,7 +395,7 @@ const injectMessage = async (
      logger.error(errorMessage)
 
      try {
-       await injectMessage(client, context.sessionId, errorMessage)
+        await injectMessage(host, context.sessionId, errorMessage, hook.id)
      } catch (injectionError) {
        const injectionErrorMsg =
          injectionError instanceof Error
@@ -452,7 +456,7 @@ const isToolHook = (hook: ToolHook | SessionHook): hook is ToolHook => {
 export async function executeHooks(
    hooks: (ToolHook | SessionHook)[],
    context: HookExecutionContext,
-   client: OpencodeClient,
+    host: HookHost,
    truncationLimit?: number
 ): Promise<void> {
      try {
@@ -463,7 +467,7 @@ export async function executeHooks(
        // Execute each hook
        for (const hook of hooks) {
          try {
-           await executeHook(hook, context, client, truncationLimit)
+            await executeHook(hook, context, host, truncationLimit)
         } catch (error) {
           // Catch errors from individual hook execution and continue
           // (errors are already logged and injected by the hook execution functions)