open-plan-annotator 0.2.15 → 0.2.17

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "open-plan-annotator",
       "source": "./",
       "description": "Interactive plan annotation UI: review, strikethrough, and comment on Claude's plans before approving. Fully local, no external services.",
-      "version": "0.2.15",
+      "version": "0.2.17",
       "author": {
         "name": "ndom91"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "open-plan-annotator",
   "description": "Interactive plan annotation UI: review, strikethrough, and comment on Claude's plans before approving. Fully local, no external services.",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "author": {
     "name": "ndom91"
   },

package/opencode/bridge.js

@@ -5,9 +5,12 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const PKG_ROOT = fileURLToPath(new URL("..", import.meta.url));
-const BINARY_PATH = join(PKG_ROOT, "bin", "open-plan-annotator-binary");
+const LOCAL_BINARY_PATH = join(PKG_ROOT, "bin", "open-plan-annotator-binary");
 const INSTALL_SCRIPT = join(PKG_ROOT, "install.cjs");
 
+/** Resolved path to the binary (may differ from LOCAL_BINARY_PATH if found on PATH). */
+let BINARY_PATH = LOCAL_BINARY_PATH;
+
 /**
  * @typedef {{
  *   hookSpecificOutput: {
@@ -99,9 +102,33 @@ function validateHookOutput(value) {
   throw new Error("unsupported decision payload");
 }
 
+/**
+ * Check if `open-plan-annotator` is available on PATH.
+ * The CLI wrapper handles binary discovery/download and stdin/stdout
+ * forwarding, so we can spawn it directly as a fallback when the local
+ * binary isn't available (e.g. OpenCode loads the plugin from its own
+ * node_modules but the binary only exists in a global pnpm install).
+ * @returns {string | undefined}
+ */
+function findWrapperOnPath() {
+  const cmd = process.platform === "win32" ? "where" : "which";
+  try {
+    const result = execFileSync(cmd, ["open-plan-annotator"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim().split("\n")[0];
+    return result || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 /** Ensure the compiled binary exists, downloading if necessary. */
 function ensureBinary() {
-  if (existsSync(BINARY_PATH)) return;
+  if (existsSync(LOCAL_BINARY_PATH)) {
+    BINARY_PATH = LOCAL_BINARY_PATH;
+    return;
+  }
 
   // Try to find node on PATH for running the install script
   try {
@@ -121,12 +148,23 @@ function ensureBinary() {
     }
   }
 
-  if (!existsSync(BINARY_PATH)) {
-    throw new Error(
-      `open-plan-annotator: binary not found at ${BINARY_PATH}. ` +
-        `Try running: node ${INSTALL_SCRIPT}`,
-    );
+  if (existsSync(LOCAL_BINARY_PATH)) {
+    BINARY_PATH = LOCAL_BINARY_PATH;
+    return;
+  }
+
+  // Fallback: use the CLI wrapper from PATH (e.g. global pnpm install).
+  // The wrapper handles binary discovery/download and stdio forwarding.
+  const wrapperPath = findWrapperOnPath();
+  if (wrapperPath) {
+    BINARY_PATH = wrapperPath;
+    return;
   }
+
+  throw new Error(
+    `open-plan-annotator: binary not found at ${LOCAL_BINARY_PATH}. ` +
+      `Try running: node ${INSTALL_SCRIPT}`,
+  );
 }
 
 /**
@@ -137,7 +175,7 @@ export async function runPlanReview(options) {
 
   const payload = buildHookPayload(options);
 
-  const result = await new Promise((resolve, reject) => {
+  const output = await new Promise((resolve, reject) => {
     let cwd = options.cwd ?? process.cwd();
 
     // Guard: ensure cwd is a directory, not a file
@@ -149,19 +187,39 @@ export async function runPlanReview(options) {
       cwd = PKG_ROOT;
     }
 
-    // Spawn the compiled binary directly (skip the Node wrapper).
-    // This avoids issues with bun vs node runtime differences.
+    // Spawn detached so the binary can outlive this call — it keeps its
+    // HTTP server alive for ~10s after emitting the JSON hook response.
     const child = spawn(BINARY_PATH, [], {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
       env: process.env,
+      detached: true,
     });
 
     let stdout = "";
     let stderr = "";
+    let resolved = false;
 
     child.stdout.on("data", (chunk) => {
       stdout += String(chunk);
+      if (resolved) return;
+
+      // Scan for a complete JSON hook-output line.  Once found, resolve
+      // immediately and let the binary keep running in the background.
+      const lines = stdout.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const parsed = validateHookOutput(JSON.parse(trimmed));
+          resolved = true;
+          child.unref();
+          resolve(parsed);
+          return;
+        } catch {
+          // Not valid hook JSON yet, keep buffering
+        }
+      }
     });
 
     child.stderr.on("data", (chunk) => {
@@ -169,40 +227,38 @@ export async function runPlanReview(options) {
     });
 
     child.on("error", (error) => {
-      reject(error);
+      if (!resolved) reject(error);
     });
 
     child.on("close", (code, signal) => {
-      resolve({ code, signal, stdout, stderr });
+      if (resolved) return;
+      // Binary exited without producing valid JSON
+      if (signal) {
+        reject(
+          new Error(
+            stderr.trim()
+              ? `open-plan-annotator was terminated by signal ${signal}: ${stderr.trim()}`
+              : `open-plan-annotator was terminated by signal ${signal}`,
+          ),
+        );
+      } else if (code !== 0) {
+        reject(
+          new Error(
+            stderr.trim()
+              ? `open-plan-annotator exited with code ${code}: ${stderr.trim()}`
+              : `open-plan-annotator exited with code ${code}`,
+          ),
+        );
+      } else {
+        reject(new Error("open-plan-annotator exited without producing hook output"));
+      }
     });
 
     child.stdin.write(`${JSON.stringify(payload)}\n`);
     child.stdin.end();
   });
 
-  const settled =
-    /** @type {{ code: number | null, signal: NodeJS.Signals | null, stdout: string, stderr: string }} */ (result);
-
-  if (settled.signal) {
-    const errorText = settled.stderr.trim();
-    throw new Error(
-      errorText
-        ? `open-plan-annotator was terminated by signal ${settled.signal}: ${errorText}`
-        : `open-plan-annotator was terminated by signal ${settled.signal}`,
-    );
-  }
-
-  if (settled.code !== 0) {
-    const errorText = settled.stderr.trim();
-    throw new Error(
-      errorText
-        ? `open-plan-annotator exited with code ${settled.code}: ${errorText}`
-        : `open-plan-annotator exited with code ${settled.code}`,
-    );
-  }
-
-  const output = parseHookOutput(settled.stdout, settled.stderr);
-  const decision = output.hookSpecificOutput.decision;
+  const decision = /** @type {HookOutput} */ (output).hookSpecificOutput.decision;
 
   if (decision.behavior === "allow") {
     return { approved: true };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-plan-annotator",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "type": "module",
   "description": "Fully local plugin for interactive plan annotation from your Agentic assistants",
   "author": "ndom91",