@zhijiewang/openharness 1.2.0 → 1.4.0

package/dist/tools/MonitorTool/index.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { spawn } from "node:child_process";
+const inputSchema = z.object({
+    command: z.string().describe("Background command to watch"),
+    pattern: z.string().optional().describe("Regex pattern to match output lines"),
+    timeout: z.number().optional().describe("Max watch time in ms (default 60000)"),
+    maxLines: z.number().optional().describe("Max output lines to collect (default 100)"),
+});
+export const MonitorTool = {
+    name: "Monitor",
+    description: "Watch a background process and collect output. Optionally filter by regex pattern.",
+    inputSchema,
+    riskLevel: "medium",
+    isReadOnly() { return true; },
+    isConcurrencySafe() { return true; },
+    async call(input, context) {
+        const timeout = input.timeout ?? 60_000;
+        const maxLines = input.maxLines ?? 100;
+        const pattern = input.pattern ? new RegExp(input.pattern) : null;
+        return new Promise((resolve) => {
+            const lines = [];
+            let settled = false;
+            const proc = spawn(input.command, {
+                shell: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+            });
+            const timer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    proc.kill();
+                    resolve({
+                        output: lines.length > 0
+                            ? lines.join('\n') + `\n\n[Monitor timed out after ${timeout / 1000}s — ${lines.length} lines collected]`
+                            : `[Monitor timed out after ${timeout / 1000}s — no output]`,
+                        isError: false,
+                    });
+                }
+            }, timeout);
+            const handleLine = (line) => {
+                if (settled)
+                    return;
+                if (pattern && !pattern.test(line))
+                    return;
+                lines.push(line.trimEnd());
+                // Stream output chunk if callback available
+                if (context.onOutputChunk && context.callId) {
+                    context.onOutputChunk(context.callId, line + '\n');
+                }
+                if (lines.length >= maxLines) {
+                    settled = true;
+                    clearTimeout(timer);
+                    proc.kill();
+                    resolve({
+                        output: lines.join('\n') + `\n\n[Collected ${maxLines} lines — stopped]`,
+                        isError: false,
+                    });
+                }
+            };
+            let stdoutBuffer = '';
+            proc.stdout?.on('data', (chunk) => {
+                stdoutBuffer += chunk.toString();
+                const parts = stdoutBuffer.split('\n');
+                stdoutBuffer = parts.pop() ?? '';
+                for (const line of parts)
+                    handleLine(line);
+            });
+            let stderrBuffer = '';
+            proc.stderr?.on('data', (chunk) => {
+                stderrBuffer += chunk.toString();
+                const parts = stderrBuffer.split('\n');
+                stderrBuffer = parts.pop() ?? '';
+                for (const line of parts)
+                    handleLine(line);
+            });
+            proc.on('exit', (code) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    // Flush remaining buffers
+                    if (stdoutBuffer)
+                        handleLine(stdoutBuffer);
+                    if (stderrBuffer)
+                        handleLine(stderrBuffer);
+                    resolve({
+                        output: lines.length > 0
+                            ? lines.join('\n') + `\n\n[Process exited with code ${code ?? 'unknown'} — ${lines.length} lines]`
+                            : `[Process exited with code ${code ?? 'unknown'} — no output]`,
+                        isError: (code ?? 0) !== 0,
+                    });
+                }
+            });
+            proc.on('error', (err) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    resolve({
+                        output: `Monitor error: ${err.message}`,
+                        isError: true,
+                    });
+                }
+            });
+        });
+    },
+    prompt() {
+        return `Watch a background process and collect its output. Optionally filter lines by regex pattern.
+Parameters:
+- command (string, required): The command to run and watch
+- pattern (string, optional): Regex to filter output lines
+- timeout (number, optional): Max time in ms (default 60000)
+- maxLines (number, optional): Max lines to collect (default 100)`;
+    },
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    command: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    timeout?: number | undefined;
+}, {
+    command: string;
+    timeout?: number | undefined;
+}>;
+export declare const PowerShellTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/PowerShellTool/index.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { execSync } from "node:child_process";
+const inputSchema = z.object({
+    command: z.string().describe("PowerShell command to execute"),
+    timeout: z.number().optional().describe("Timeout in ms (default 120000)"),
+});
+export const PowerShellTool = {
+    name: "PowerShell",
+    description: "Execute PowerShell commands (Windows only). Use for Windows-specific tasks like registry access, COM objects, or .NET calls.",
+    inputSchema,
+    riskLevel: "high",
+    isReadOnly() { return false; },
+    isConcurrencySafe() { return false; },
+    async call(input) {
+        if (process.platform !== 'win32') {
+            return { output: "PowerShell is only available on Windows. Use Bash instead.", isError: true };
+        }
+        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 });
+            return { output: output.trim(), isError: false };
+        }
+        catch (err) {
+            const output = String(err.stdout ?? err.stderr ?? err.message ?? 'PowerShell error');
+            return { output: output.slice(0, 100_000), isError: true };
+        }
+    },
+    prompt() {
+        return "Execute PowerShell commands on Windows. Use for registry, COM, .NET, and Windows-specific operations.";
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/tools.js

@@ -42,6 +42,8 @@ import { KillProcessTool } from "./tools/KillProcessTool/index.js";
 import { RemoteTriggerTool } from "./tools/RemoteTriggerTool/index.js";
 import { MultiEditTool } from "./tools/MultiEditTool/index.js";
 import { PipelineTool } from "./tools/PipelineTool/index.js";
+import { PowerShellTool } from "./tools/PowerShellTool/index.js";
+import { MonitorTool } from "./tools/MonitorTool/index.js";
 /**
  * Returns all registered tools.
  *
@@ -96,6 +98,8 @@ export function getAllTools() {
         KillProcessTool,
         RemoteTriggerTool,
         MultiEditTool,
+        PowerShellTool,
+        MonitorTool,
     ];
     return [
         ...core,

package/dist/types/permissions.js

@@ -7,6 +7,13 @@ const EDIT_SAFE_TOOLS = new Set([
     "FileRead", "FileWrite", "FileEdit", "Glob", "Grep", "LS",
     "ImageRead", "NotebookEdit",
 ]);
+/** Parse a tool specifier like "Bash(npm run *)" into tool name + pattern */
+function parseToolSpecifier(specifier) {
+    const match = specifier.match(/^(\w+)\((.+)\)$/);
+    if (match)
+        return { toolName: match[1], argPattern: match[2] };
+    return { toolName: specifier };
+}
 /** Match a tool name against a pattern (supports trailing * for prefix matching) */
 function matchToolPattern(pattern, toolName) {
     if (pattern.endsWith("*")) {
@@ -14,14 +21,47 @@ function matchToolPattern(pattern, toolName) {
     }
     return pattern === toolName;
 }
+/**
+ * Match an argument pattern against a value using glob-style matching.
+ * Supports: * (any chars), ** (any path segments)
+ */
+function matchArgGlob(pattern, value) {
+    // Convert glob to regex: * → [^/]*, ** → .*, escape other regex chars
+    const regexStr = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex chars (except * and ?)
+        .replace(/\*\*/g, '{{DOUBLESTAR}}')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\{\{DOUBLESTAR\}\}/g, '.*');
+    try {
+        return new RegExp(`^${regexStr}$`).test(value);
+    }
+    catch {
+        return false;
+    }
+}
 /** Find the first matching tool permission rule */
 function findToolRule(rules, toolName, toolInput) {
     if (!rules || rules.length === 0)
         return undefined;
     return rules.find(r => {
-        if (!matchToolPattern(r.tool, toolName))
+        const { toolName: specToolName, argPattern } = parseToolSpecifier(r.tool);
+        // Check tool name match (with prefix * support)
+        if (!matchToolPattern(specToolName, toolName))
             return false;
-        // If rule has a pattern, match against Bash command content only
+        // If rule has an inline argument pattern (e.g., "Bash(npm run *)")
+        if (argPattern && toolInput) {
+            const input = toolInput;
+            // For Bash: match against command string
+            if (toolName === 'Bash' && typeof input.command === 'string') {
+                return matchArgGlob(argPattern, input.command);
+            }
+            // For file tools: match against file_path
+            if (['Edit', 'Write', 'Read'].includes(toolName) && typeof input.file_path === 'string') {
+                return matchArgGlob(argPattern, input.file_path);
+            }
+            return false; // Has pattern but no matching field
+        }
+        // Legacy: separate pattern field (regex) for Bash commands
         if (r.pattern && toolInput && toolName === "Bash") {
             const command = toolInput?.command;
             if (typeof command === "string") {

package/package.json

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