feat: Add OpenCode plugin support

CLAUDE.md

@@ -4,20 +4,24 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-This is a Claude Code plugin that provides file and directory protection using `.block` configuration files. When installed, the plugin intercepts file modification operations (Edit, Write, NotebookEdit, Bash) and blocks them based on protection rules.
+This plugin provides file and directory protection using `.block` configuration files. It supports both **Claude Code** and **OpenCode**. When installed, the plugin intercepts file modification operations and blocks them based on protection rules.
 
 ## Architecture
 
-The plugin uses Claude Code's hook system:
-- **PreToolUse hook**: Runs `protect_directories.py` to check if the target file is protected before allowing Edit, Write, NotebookEdit, or Bash operations
+The core protection logic lives in `hooks/protect_directories.py` (Python, no external dependencies). Both Claude Code and OpenCode integrations call this script.
 
-Key files:
-- `hooks/hooks.json` - Hook configuration that triggers protection checks
-- `hooks/protect_directories.py` - Main protection logic (Python, no external dependencies)
+### Claude Code integration
+- **PreToolUse hook**: Runs `protect_directories.py` to check if the target file is protected before allowing Edit, Write, NotebookEdit, or Bash operations
+- `hooks/hooks.json` - Hook configuration
 - `hooks/run-hook.cmd` - Cross-platform entry point (polyglot script)
 - `commands/create.md` - Interactive command for creating `.block` files
 - `.claude-plugin/plugin.json` - Plugin metadata
 
+### OpenCode integration
+- **tool.execute.before hook**: TypeScript plugin that calls `protect_directories.py` before edit, write, bash, or patch operations
+- `opencode/index.ts` - Plugin entry point
+- `opencode/package.json` - npm package metadata
+
 ## Dependencies
 
 - **Python 3.8+** - Required for the protection hook (no external packages needed)

README.md

@@ -1,8 +1,8 @@
 # Block
 
-**A Claude Code plugin to protect files from unwanted modifications.**
+**Protect files from unwanted AI modifications in [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and [OpenCode](https://opencode.ai).**
 
-Drop a `.block` file in any directory to control what Claude can and cannot edit. Protect configs, lock files, migrations, or entire directories with simple pattern rules.
+Drop a `.block` file in any directory to control what AI agents can and cannot edit. Protect configs, lock files, migrations, or entire directories with simple pattern rules.
 
 ## Why use this?
 
@@ -17,6 +17,8 @@ Drop a `.block` file in any directory to control what Claude can and cannot edit
 
 ## Installation
 
+### Claude Code
+
 1. Register the marketplace:
 
 ```
@@ -29,6 +31,26 @@ Drop a `.block` file in any directory to control what Claude can and cannot edit
 /plugin install block@block-marketplace
 ```
 
+### OpenCode
+
+Add the plugin to your `opencode.json` config:
+
+```json
+{
+  "plugins": ["opencode-block"]
+}
+```
+
+Or for local development, clone this repo and reference the plugin directly:
+
+```json
+{
+  "plugins": ["file:///path/to/block/opencode/index.ts"]
+}
+```
+
+You can also copy `opencode/index.ts` into your project's `.opencode/plugin/` directory along with the `hooks/` folder.
+
 ## Usage
 
 Use the `/block:create` command to interactively create a `.block` file:
@@ -144,7 +166,10 @@ When both files exist in the same directory:
 
 ## How It Works
 
-The plugin hooks into Claude's file operations. When Claude tries to modify a file, it checks for `.block` files in the target directory and all parent directories, then combines their rules.
+The plugin hooks into file operations from Claude Code and OpenCode. When the AI agent tries to modify a file, the plugin checks for `.block` files in the target directory and all parent directories, then combines their rules.
+
+- **Claude Code**: Uses a PreToolUse hook to intercept Edit, Write, NotebookEdit, and Bash tools
+- **OpenCode**: Uses a `tool.execute.before` hook to intercept edit, write, bash, and patch tools
 
 - `.block` files themselves are always protected
 - Protection cascades to all subdirectories
@@ -194,8 +219,11 @@ pytest tests/ -v --cov=hooks --cov-report=term-missing
 ```
 block/
 ├── hooks/
-│   ├── protect_directories.py   # Main protection logic
-│   └── run-hook.cmd             # Cross-platform entry point
+│   ├── protect_directories.py   # Main protection logic (Python)
+│   └── run-hook.cmd             # Cross-platform entry point (Claude Code)
+├── opencode/
+│   ├── index.ts                 # OpenCode plugin entry point
+│   └── package.json             # npm package metadata
 ├── tests/
 │   ├── conftest.py              # Shared fixtures
 │   ├── test_basic_protection.py
@@ -210,9 +238,9 @@ block/
 │   ├── test_wildcards.py
 │   └── test_edge_cases.py
 ├── commands/
-│   └── create.md                # Interactive command
+│   └── create.md                # Interactive command (Claude Code)
 ├── .claude-plugin/
-│   └── plugin.json              # Plugin metadata
+│   └── plugin.json              # Plugin metadata (Claude Code)
 └── pyproject.toml               # Python project config
 ```
 

opencode/index.ts

@@ -0,0 +1,105 @@
+/**
+ * Block plugin for OpenCode
+ *
+ * Provides file and directory protection using .block configuration files.
+ * Intercepts file modification tools (edit, write, bash, patch) and blocks
+ * them based on protection rules defined in .block files.
+ *
+ * This is the OpenCode equivalent of the Claude Code PreToolUse hook.
+ */
+import type { Plugin } from "opencode/plugin";
+import { resolve, dirname } from "path";
+
+/** Tools that modify files and should be checked against .block rules. */
+const PROTECTED_TOOLS = new Set(["edit", "write", "bash", "patch"]);
+
+/**
+ * Maps OpenCode tool names to the names expected by protect_directories.py.
+ * The Python script was originally written for Claude Code's tool naming.
+ */
+const TOOL_NAME_MAP: Record<string, string> = {
+  edit: "Edit",
+  write: "Write",
+  bash: "Bash",
+  patch: "Write",
+};
+
+/**
+ * Build the JSON input that protect_directories.py expects on stdin.
+ *
+ * Claude Code hook input format:
+ *   { "tool_name": "Edit", "tool_input": { "file_path": "..." } }
+ *   { "tool_name": "Bash", "tool_input": { "command": "..." } }
+ */
+function buildHookInput(
+  tool: string,
+  args: Record<string, unknown>,
+): string | null {
+  const toolName = TOOL_NAME_MAP[tool];
+  if (!toolName) return null;
+
+  const toolInput: Record<string, unknown> = {};
+
+  if (tool === "bash") {
+    const command = args.command ?? args.cmd;
+    if (!command) return null;
+    toolInput.command = command;
+  } else {
+    // edit, write, patch all use filePath
+    const filePath = args.filePath ?? args.file_path ?? args.file;
+    if (!filePath) return null;
+    toolInput.file_path = filePath;
+  }
+
+  return JSON.stringify({ tool_name: toolName, tool_input: toolInput });
+}
+
+/**
+ * Locate protect_directories.py relative to this plugin file.
+ * When installed via npm the layout is:
+ *   node_modules/opencode-block/opencode/index.ts
+ *   node_modules/opencode-block/hooks/protect_directories.py
+ *
+ * When used from the repo directly:
+ *   opencode/index.ts
+ *   hooks/protect_directories.py
+ */
+function findScript(): string {
+  const pluginDir = import.meta.dir;
+  return resolve(pluginDir, "..", "hooks", "protect_directories.py");
+}
+
+export const BlockPlugin: Plugin = async ({ $ }) => {
+  const scriptPath = findScript();
+
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (!PROTECTED_TOOLS.has(input.tool)) return;
+
+      const hookInput = buildHookInput(
+        input.tool,
+        output.args as Record<string, unknown>,
+      );
+      if (!hookInput) return;
+
+      try {
+        const result =
+          await $`echo ${hookInput} | python3 ${scriptPath}`.quiet();
+        const stdout = result.stdout.toString().trim();
+        if (!stdout) return;
+
+        const decision = JSON.parse(stdout);
+        if (decision.decision === "block") {
+          throw new Error(decision.reason);
+        }
+      } catch (err: unknown) {
+        if (err instanceof SyntaxError) {
+          // Python output wasn't JSON — not a block, ignore
+          return;
+        }
+        // Re-throw block errors and unexpected failures
+        throw err;
+      }
+    },
+  };
+};

opencode/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "opencode-block",
+  "version": "1.1.14",
+  "description": "File and directory protection for OpenCode using .block marker files with pattern matching",
+  "main": "index.ts",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "protection",
+    "security",
+    "file-blocking",
+    "directory-lock"
+  ],
+  "author": "Iiro Rahkonen",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kodroi/block"
+  },
+  "files": [
+    "index.ts",
+    "../hooks/protect_directories.py"
+  ]
+}

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "block"
 version = "1.1.6"
-description = "File and directory protection for Claude Code"
+description = "File and directory protection for Claude Code and OpenCode"
 readme = "README.md"
 license = "MIT"
 authors = [