@zhijiewang/openharness 2.9.0 → 2.10.0

package/dist/harness/config.d.ts

@@ -16,6 +16,19 @@ export type HookDef = {
     prompt?: string;
     match?: string;
     timeout?: number;
+    /**
+     * When true (and this hook has a `command`), OH sends a JSON envelope
+     * `{event, ...context}` on stdin and parses a JSON response from stdout.
+     * Response shape (Claude Code compatible):
+     *   { "decision": "allow" | "deny",
+     *     "reason"?: string,
+     *     "hookSpecificOutput"?: {...} }
+     *
+     * When false (default), OH passes context via `OH_EVENT` / `OH_TOOL_NAME`
+     * env vars and gates on the command's exit code (0 = allow). The env-var
+     * mode remains the default for backward compatibility.
+     */
+    jsonIO?: boolean;
 };
 export type HooksConfig = {
     sessionStart?: HookDef[];

package/dist/harness/hooks.js

@@ -141,6 +141,86 @@ function runCommandHookAsync(command, env, timeoutMs = 10_000) {
         });
     });
 }
+/**
+ * Run a JSON-mode command hook (Claude Code convention).
+ *
+ * Sends `{event, ...context}` as JSON on stdin. Parses stdout as JSON
+ * `{ decision: "allow" | "deny", reason?: string, hookSpecificOutput?: any }`.
+ *
+ * Gating logic:
+ *   - `decision: "deny"` → blocks (returns false).
+ *   - `decision: "allow"` or omitted decision → allow (returns true).
+ *   - Non-zero exit code → block.
+ *   - Invalid/empty JSON on stdout → fall back to exit code (0 = allow).
+ *   - Timeout or spawn error → block.
+ */
+function runJsonIoHookAsync(command, env, event, ctx, timeoutMs = 10_000) {
+    return new Promise((resolve) => {
+        const proc = spawn(command, {
+            shell: true,
+            timeout: timeoutMs,
+            stdio: ["pipe", "pipe", "pipe"],
+            env,
+        });
+        let settled = false;
+        let stdoutBuf = "";
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                proc.kill();
+                resolve(false);
+            }
+        }, timeoutMs);
+        proc.stdout?.on("data", (chunk) => {
+            stdoutBuf += chunk.toString();
+        });
+        // Write the event + context JSON envelope to stdin then close it so the
+        // hook knows there's no more input coming.
+        try {
+            const payload = JSON.stringify({ event, ...ctx });
+            proc.stdin?.end(payload);
+        }
+        catch {
+            /* stdin already closed — ignore */
+        }
+        proc.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            // Non-zero exit is always a block, regardless of stdout.
+            if ((code ?? 1) !== 0) {
+                resolve(false);
+                return;
+            }
+            // Empty stdout → treat exit code as the signal (allow for exit 0).
+            if (!stdoutBuf.trim()) {
+                resolve(true);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(stdoutBuf);
+                if (parsed.decision === "deny") {
+                    resolve(false);
+                }
+                else {
+                    resolve(true); // "allow" or omitted → allow
+                }
+            }
+            catch {
+                // Malformed JSON with a zero exit — fail closed conservatively.
+                resolve(false);
+            }
+        });
+        proc.on("error", () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve(false);
+            }
+        });
+    });
+}
 /** Run an HTTP hook. POSTs context as JSON, expects { allowed: true/false }. */
 async function runHttpHook(url, event, ctx, timeoutMs = 10_000) {
     try {
@@ -161,15 +241,63 @@ async function runHttpHook(url, event, ctx, timeoutMs = 10_000) {
     }
 }
 /**
- * Run a prompt hook. Uses LLM to make a yes/no decision.
+ * Run a prompt hook. Uses an LLM to make a yes/no allow/deny decision.
+ *
+ * The hook's `prompt:` field is the question posed to the model along with
+ * the event context. The response is parsed case-insensitively: responses
+ * starting with YES / ALLOW / TRUE / PASS / APPROVE allow; anything else
+ * (including explicit NO, DENY, errors, timeouts, empty) blocks.
  *
- * Currently a stub — prompt hooks always allow because the hook system
- * runs outside the query loop and has no access to a Provider instance.
- * Full implementation requires passing a Provider via HookContext so the
- * hook can call provider.complete() with the prompt text.
+ * Fail-closed semantics: if the provider isn't reachable or the response
+ * can't be parsed, the hook denies. This matches command hooks (non-zero
+ * exit = deny) and HTTP hooks (network error = deny).
+ *
+ * Provider selection: reads `.oh/config.yaml` to get the configured provider
+ * and model. A separate provider instance is created per call — no caching,
+ * since hooks are rare and cold-start cost is negligible compared to the
+ * LLM call itself.
  */
-async function runPromptHook(_promptText, _ctx) {
-    return true;
+async function runPromptHook(promptText, ctx, timeoutMs = 10_000) {
+    try {
+        const cfg = readOhConfig();
+        if (!cfg)
+            return false; // no config → no provider → fail closed
+        const { createProvider } = (await import("../providers/index.js"));
+        const modelArg = cfg.model ? `${cfg.provider}/${cfg.model}` : cfg.provider;
+        const overrides = {};
+        if (cfg.apiKey)
+            overrides.apiKey = cfg.apiKey;
+        if (cfg.baseUrl)
+            overrides.baseUrl = cfg.baseUrl;
+        const { provider, model } = await createProvider(modelArg, overrides);
+        const systemPrompt = "You are a policy gate. Read the question and the event context. Answer with a single word: YES to allow, NO to deny. Do not explain unless asked.";
+        const userContent = [
+            `Question: ${promptText}`,
+            "",
+            "Event context:",
+            JSON.stringify({ event: ctx }, null, 2),
+            "",
+            "Answer (YES or NO):",
+        ].join("\n");
+        const { createUserMessage } = (await import("../types/message.js"));
+        const messages = [createUserMessage(userContent)];
+        // Race the completion against a hard timeout so a hung provider doesn't
+        // block the agent loop indefinitely.
+        const completion = await Promise.race([
+            provider.complete(messages, systemPrompt, undefined, model),
+            new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs)),
+        ]);
+        if (!completion)
+            return false; // timeout → deny
+        const text = (completion.content ?? "").trim().toUpperCase();
+        if (!text)
+            return false;
+        // Accept multiple allow synonyms; default to deny on anything else.
+        return /^(YES|ALLOW|TRUE|PASS|APPROVE)\b/.test(text);
+    }
+    catch {
+        return false; // any error path → deny
+    }
 }
 // ── Hook Execution ──
 /** Execute a single hook definition. Returns true if allowed. */
@@ -177,6 +305,12 @@ async function executeHookDef(def, event, ctx) {
     const timeout = def.timeout ?? 10_000;
     if (def.command) {
         const env = buildEnv(event, ctx);
+        // JSON-mode (Claude Code convention): send `{event, ...ctx}` on stdin,
+        // parse `{decision}` from stdout. Env-var mode (legacy default): gate on
+        // exit code.
+        if (def.jsonIO) {
+            return runJsonIoHookAsync(def.command, env, event, ctx, timeout);
+        }
         const code = await runCommandHookAsync(def.command, env, timeout);
         return code === 0;
     }
@@ -206,14 +340,31 @@ export function emitHook(event, ctx = {}) {
             if (!matchesHook(def, ctx))
                 continue;
             if (def.command) {
+                const input = def.jsonIO ? JSON.stringify({ event, ...ctx }) : undefined;
                 const result = spawnSync(def.command, {
                     shell: true,
                     timeout: def.timeout ?? 10_000,
                     stdio: "pipe",
                     env,
+                    input,
                 });
                 if (result.status !== 0 || result.error)
                     return false;
+                // JSON mode: parse stdout for {decision: "deny"} → block. Allow on empty
+                // stdout (exit-code already gated above). Malformed JSON fails closed.
+                if (def.jsonIO) {
+                    const out = result.stdout?.toString() ?? "";
+                    if (out.trim()) {
+                        try {
+                            const parsed = JSON.parse(out);
+                            if (parsed.decision === "deny")
+                                return false;
+                        }
+                        catch {
+                            return false;
+                        }
+                    }
+                }
             }
             // HTTP and prompt hooks for preToolUse are handled in emitHookAsync
         }

package/dist/tools/MemoryTool/index.d.ts

@@ -12,16 +12,16 @@ declare const inputSchema: z.ZodObject<{
     action: "search" | "save" | "list";
     content?: string | undefined;
     type?: "user" | "convention" | "preference" | "project" | "debugging" | "feedback" | "reference" | undefined;
-    description?: string | undefined;
     name?: string | undefined;
+    description?: string | undefined;
     global?: boolean | undefined;
     query?: string | undefined;
 }, {
     action: "search" | "save" | "list";
     content?: string | undefined;
     type?: "user" | "convention" | "preference" | "project" | "debugging" | "feedback" | "reference" | undefined;
-    description?: string | undefined;
     name?: string | undefined;
+    description?: string | undefined;
     global?: boolean | undefined;
     query?: string | undefined;
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {