@zhijiewang/openharness 2.29.0 → 2.30.1

package/dist/services/StreamingToolExecutor.js

@@ -2,6 +2,8 @@
  * Tool execution during LLM streaming — concurrent tool execution
  * with permission checks and queue management.
  */
+import { getAffectedFiles } from "../harness/checkpoints.js";
+import { emitHook, emitHookWithOutcome } from "../harness/hooks.js";
 import { findToolByName } from "../Tool.js";
 import { checkPermission } from "../types/permissions.js";
 const MAX_CONCURRENCY = 10;
@@ -54,23 +56,69 @@ export class StreamingToolExecutor {
             tracked.status = "completed";
             return;
         }
+        const argsPreview = JSON.stringify(tracked.toolCall.arguments).slice(0, 1000);
         // Permission check
         const perm = checkPermission(this.permissionMode, tool.riskLevel, tool.isReadOnly(tracked.toolCall.arguments), tool.name, tracked.toolCall.arguments);
-        if (!perm.allowed && perm.reason === "needs-approval" && this.askUser) {
-            const { formatToolArgs } = await import("../utils/tool-summary.js");
-            const description = formatToolArgs(tool.name, tracked.toolCall.arguments);
-            const allowed = await this.askUser(tool.name, description, tool.riskLevel);
-            if (!allowed) {
-                tracked.result = { output: "Permission denied.", isError: true };
+        if (!perm.allowed) {
+            if (perm.reason === "needs-approval") {
+                // Hook: permissionRequest — give configured hooks first say. If they
+                // explicitly allow/deny, that wins; otherwise fall through to the
+                // interactive prompt or to a fail-closed deny in headless mode.
+                const hookOutcome = await emitHookWithOutcome("permissionRequest", {
+                    toolName: tool.name,
+                    toolArgs: argsPreview,
+                    toolInputJson: JSON.stringify(tracked.toolCall.arguments).slice(0, 1000),
+                    permissionMode: this.permissionMode,
+                    permissionAction: "ask",
+                });
+                const denyAndEmit = (source, reason, output) => {
+                    emitHook("permissionDenied", {
+                        toolName: tool.name,
+                        toolArgs: argsPreview,
+                        permissionMode: this.permissionMode,
+                        denySource: source,
+                        denyReason: reason,
+                    });
+                    tracked.result = { output, isError: true };
+                    tracked.status = "completed";
+                };
+                if (hookOutcome.permissionDecision === "allow") {
+                    // Hook granted — proceed.
+                }
+                else if (hookOutcome.permissionDecision === "deny" || !hookOutcome.allowed) {
+                    const reason = hookOutcome.reason ? `: ${hookOutcome.reason}` : "";
+                    denyAndEmit("hook", hookOutcome.reason ?? "hook denied", `Permission denied by hook${reason}`);
+                    return;
+                }
+                else if (this.askUser) {
+                    const { formatToolArgs } = await import("../utils/tool-summary.js");
+                    const description = formatToolArgs(tool.name, tracked.toolCall.arguments);
+                    const allowed = await this.askUser(tool.name, description, tool.riskLevel);
+                    if (!allowed) {
+                        denyAndEmit("user", "user declined", "Permission denied by user.");
+                        return;
+                    }
+                }
+                else {
+                    // Headless mode with no hook decision and no interactive prompt.
+                    denyAndEmit("headless", "no hook decision and no interactive prompt available", "Permission denied: needs-approval (no interactive prompt available; configure a permissionRequest hook to gate this tool)");
+                    return;
+                }
+            }
+            else {
+                // Auto-mode policy block (deny / acceptEdits / etc) — symmetric event.
+                emitHook("permissionDenied", {
+                    toolName: tool.name,
+                    toolArgs: argsPreview,
+                    permissionMode: this.permissionMode,
+                    denySource: "policy",
+                    denyReason: perm.reason,
+                });
+                tracked.result = { output: `Denied: ${perm.reason}`, isError: true };
                 tracked.status = "completed";
                 return;
             }
         }
-        else if (!perm.allowed) {
-            tracked.result = { output: `Denied: ${perm.reason}`, isError: true };
-            tracked.status = "completed";
-            return;
-        }
         // Validate input
         const parsed = tool.inputSchema.safeParse(tracked.toolCall.arguments);
         if (!parsed.success) {
@@ -84,6 +132,17 @@ export class StreamingToolExecutor {
             tracked.status = "completed";
             return;
         }
+        // Hook: preToolUse — last gate before execution. A hook that returns
+        // false (exit code 1 / { allowed: false }) blocks the call.
+        const preAllowed = emitHook("preToolUse", {
+            toolName: tool.name,
+            toolArgs: argsPreview,
+        });
+        if (!preAllowed) {
+            tracked.result = { output: "Blocked by preToolUse hook.", isError: true };
+            tracked.status = "completed";
+            return;
+        }
         // Execute with per-call context (streaming output chunks + abort signal)
         const callId = tracked.toolCall.id;
         const callContext = {
@@ -94,8 +153,11 @@ export class StreamingToolExecutor {
                 this.outputChunks.push({ callId: id, chunk });
             },
         };
+        const toolSpanId = callContext.tracer?.startSpan(`tool:${tool.name}`, { riskLevel: tool.riskLevel }, callContext.parentSpanId);
         try {
             tracked.result = await tool.call(parsed.data, callContext);
+            if (toolSpanId)
+                callContext.tracer?.endSpan(toolSpanId, tracked.result.isError ? "error" : "ok");
             // Verification loop: auto-run lint/typecheck after file-modifying tools
             if (tracked.result && !tracked.result.isError && ["Edit", "Write", "MultiEdit"].includes(tool.name)) {
                 try {
@@ -132,6 +194,35 @@ export class StreamingToolExecutor {
                 output: `Error: ${err instanceof Error ? err.message : String(err)}`,
                 isError: true,
             };
+            if (toolSpanId)
+                callContext.tracer?.endSpan(toolSpanId, "error", { error: tracked.result.output });
+        }
+        // Hook: postToolUse / postToolUseFailure (mutually exclusive — strict CC parity)
+        if (tracked.result) {
+            const outputPreview = tracked.result.output.slice(0, 1000);
+            if (tracked.result.isError) {
+                emitHook("postToolUseFailure", {
+                    toolName: tool.name,
+                    toolArgs: argsPreview,
+                    toolOutput: outputPreview,
+                    toolError: "ReportedError",
+                    errorMessage: outputPreview,
+                });
+            }
+            else {
+                emitHook("postToolUse", {
+                    toolName: tool.name,
+                    toolArgs: argsPreview,
+                    toolOutput: outputPreview,
+                });
+                // Emit fileChanged hook for file-modifying tools
+                if (["Edit", "Write", "MultiEdit"].includes(tool.name)) {
+                    const filePaths = getAffectedFiles(tool.name, parsed.data);
+                    for (const fp of filePaths) {
+                        emitHook("fileChanged", { filePath: fp, toolName: tool.name });
+                    }
+                }
+            }
         }
         tracked.status = "completed";
         this.processQueue(); // Process next queued tools

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

@@ -6,13 +6,13 @@ declare const createSchema: z.ZodObject<{
     schedule: z.ZodString;
     prompt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    action: "create";
     name: string;
+    action: "create";
     prompt: string;
     schedule: string;
 }, {
-    action: "create";
     name: string;
+    action: "create";
     prompt: string;
     schedule: string;
 }>;

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

@@ -6,8 +6,8 @@ declare const inputSchema: z.ZodObject<{
     line: z.ZodOptional<z.ZodNumber>;
     character: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    action: "diagnostics" | "definition" | "references" | "hover";
     file_path: string;
+    action: "diagnostics" | "definition" | "references" | "hover";
     line?: number | undefined;
     character?: number | undefined;
 }, {

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

@@ -17,9 +17,9 @@ declare const inputSchema: z.ZodObject<{
     "-n": z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     pattern: string;
+    path?: string | undefined;
     type?: string | undefined;
     "-i"?: boolean | undefined;
-    path?: string | undefined;
     context?: number | undefined;
     glob?: string | undefined;
     offset?: number | undefined;
@@ -32,9 +32,9 @@ declare const inputSchema: z.ZodObject<{
     "-n"?: boolean | undefined;
 }, {
     pattern: string;
+    path?: string | undefined;
     type?: string | undefined;
     "-i"?: boolean | undefined;
-    path?: string | undefined;
     context?: number | undefined;
     glob?: string | undefined;
     offset?: number | undefined;

package/dist/tools/PowerShellTool/index.js

@@ -1,4 +1,4 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { z } from "zod";
 const inputSchema = z.object({
     command: z.string().describe("PowerShell command to execute"),
@@ -21,7 +21,16 @@ export const PowerShellTool = {
         }
         const timeout = input.timeout ?? 120_000;
         try {
-            const output = execSync(`powershell.exe -NoProfile -NonInteractive -Command "${input.command.replace(/"/g, '\\"')}"`, { encoding: "utf-8", timeout, maxBuffer: 10 * 1024 * 1024, windowsHide: true });
+            // execFileSync(file, args[]) spawns powershell.exe directly without a
+            // cmd.exe wrapper, so cmd.exe metachars (& | < > ^ %VAR%) are inert.
+            // The user's command is passed as a single -Command arg; PowerShell
+            // parses it as PowerShell, not as a doubly-parsed shell string.
+            const output = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", input.command], {
+                encoding: "utf-8",
+                timeout,
+                maxBuffer: 10 * 1024 * 1024,
+                windowsHide: true,
+            });
             return { output: output.trim(), isError: false };
         }
         catch (err) {

package/package.json

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