@zhijiewang/openharness 2.1.0 → 2.3.0

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

@@ -20,8 +20,8 @@ declare const inputSchema: z.ZodObject<{
     path?: string | undefined;
     type?: string | undefined;
     glob?: string | undefined;
-    context?: number | undefined;
     offset?: number | undefined;
+    context?: number | undefined;
     output_mode?: "content" | "files_with_matches" | "count" | undefined;
     head_limit?: number | undefined;
     multiline?: boolean | undefined;
@@ -35,8 +35,8 @@ declare const inputSchema: z.ZodObject<{
     path?: string | undefined;
     type?: string | undefined;
     glob?: string | undefined;
-    context?: number | undefined;
     offset?: number | undefined;
+    context?: number | undefined;
     output_mode?: "content" | "files_with_matches" | "count" | undefined;
     head_limit?: number | undefined;
     multiline?: boolean | undefined;

package/dist/tools/GrepTool/index.js

@@ -1,7 +1,7 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { walkDir, matchGlob } from "../../utils/fs.js";
+import { matchGlob, walkDir } from "../../utils/fs.js";
 const inputSchema = z.object({
     pattern: z.string(),
     path: z.string().optional(),
@@ -62,7 +62,7 @@ export const GrepTool = {
         const skipOffset = input.offset ?? 0;
         const caseInsensitive = input["-i"] ?? false;
         const showLineNumbers = input["-n"] !== false; // default true
-        const flags = "g" + (caseInsensitive ? "i" : "") + (input.multiline ? "ms" : "");
+        const flags = `g${caseInsensitive ? "i" : ""}${input.multiline ? "ms" : ""}`;
         let re;
         try {
             re = new RegExp(input.pattern, flags);
@@ -76,10 +76,10 @@ export const GrepTool = {
             const allFiles = await walkDir(baseDir);
             let files = allFiles;
             if (input.glob) {
-                files = files.filter(f => matchGlob(path.relative(baseDir, f), input.glob));
+                files = files.filter((f) => matchGlob(path.relative(baseDir, f), input.glob));
             }
             if (typeExts) {
-                files = files.filter(f => typeExts.some(ext => f.endsWith(ext)));
+                files = files.filter((f) => typeExts.some((ext) => f.endsWith(ext)));
             }
             // Multiline matching: match against entire file content
             if (input.multiline) {
@@ -116,10 +116,15 @@ export const GrepTool = {
                             }
                         }
                     }
-                    catch { /* skip */ }
+                    catch {
+                        /* skip */
+                    }
                 }
                 if (outputMode === "count") {
-                    return { output: fileCounts.map(fc => `${fc.file}:${fc.count}`).join("\n") || "No matches found.", isError: false };
+                    return {
+                        output: fileCounts.map((fc) => `${fc.file}:${fc.count}`).join("\n") || "No matches found.",
+                        isError: false,
+                    };
                 }
                 else if (outputMode === "files_with_matches") {
                     return { output: matchedFiles.join("\n") || "No matches found.", isError: false };
@@ -185,7 +190,7 @@ export const GrepTool = {
                 }
             }
             if (outputMode === "count") {
-                const output = fileCounts.map(fc => `${fc.file}:${fc.count}`).join("\n");
+                const output = fileCounts.map((fc) => `${fc.file}:${fc.count}`).join("\n");
                 return { output: output || "No matches found.", isError: false };
             }
             if (outputMode === "files_with_matches") {

package/dist/tools/ImageReadTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const SUPPORTED_TYPES = {
     ".png": "image/png",
     ".jpg": "image/jpeg",

package/dist/tools/KillProcessTool/index.js

@@ -9,25 +9,29 @@ export const KillProcessTool = {
     description: "Kill a running process by PID or name. Use for stopping background tasks or stuck processes.",
     inputSchema,
     riskLevel: "high",
-    isReadOnly() { return false; },
-    isConcurrencySafe() { return true; },
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call(input) {
         if (!input.pid && !input.name) {
             return { output: "Provide either pid or name.", isError: true };
         }
         try {
             if (input.pid) {
-                const signal = input.signal ?? 'SIGTERM';
+                const signal = input.signal ?? "SIGTERM";
                 process.kill(input.pid, signal);
                 return { output: `Sent ${signal} to PID ${input.pid}`, isError: false };
             }
             if (input.name) {
-                const { execSync } = await import('node:child_process');
-                const isWin = process.platform === 'win32';
+                const { execSync } = await import("node:child_process");
+                const isWin = process.platform === "win32";
                 const cmd = isWin
                     ? `taskkill /IM "${input.name}" /F`
-                    : `pkill ${input.signal ? `-${input.signal}` : ''} "${input.name}"`;
-                const result = execSync(cmd, { encoding: 'utf-8', timeout: 5000 });
+                    : `pkill ${input.signal ? `-${input.signal}` : ""} "${input.name}"`;
+                const result = execSync(cmd, { encoding: "utf-8", timeout: 5000 });
                 return { output: result || `Killed process: ${input.name}`, isError: false };
             }
         }

package/dist/tools/LSTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     path: z.string().optional(),
     depth: z.number().optional(),
@@ -22,7 +22,7 @@ async function listDir(dir, prefix, maxDepth, currentDepth) {
         if (entry.isDirectory()) {
             lines.push(`${prefix}${entry.name}/`);
             if (currentDepth + 1 < maxDepth) {
-                const subLines = await listDir(path.join(dir, entry.name), prefix + "  ", maxDepth, currentDepth + 1);
+                const subLines = await listDir(path.join(dir, entry.name), `${prefix}  `, maxDepth, currentDepth + 1);
                 lines.push(...subLines);
             }
         }

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

@@ -3,27 +3,27 @@ import type { Tool } from "../../Tool.js";
 declare const inputSchema: z.ZodObject<{
     action: z.ZodEnum<["save", "list", "search"]>;
     name: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodEnum<["convention", "preference", "project", "debugging"]>>;
+    type: z.ZodOptional<z.ZodEnum<["convention", "preference", "project", "debugging", "user", "feedback", "reference"]>>;
     description: z.ZodOptional<z.ZodString>;
     content: z.ZodOptional<z.ZodString>;
     query: z.ZodOptional<z.ZodString>;
     global: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    action: "search" | "save" | "list";
+    action: "search" | "list" | "save";
     content?: string | undefined;
-    type?: "convention" | "preference" | "project" | "debugging" | undefined;
-    global?: boolean | undefined;
-    name?: string | undefined;
-    description?: string | undefined;
+    type?: "user" | "convention" | "preference" | "project" | "debugging" | "feedback" | "reference" | undefined;
     query?: string | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    global?: boolean | undefined;
 }, {
-    action: "search" | "save" | "list";
+    action: "search" | "list" | "save";
     content?: string | undefined;
-    type?: "convention" | "preference" | "project" | "debugging" | undefined;
-    global?: boolean | undefined;
-    name?: string | undefined;
-    description?: string | undefined;
+    type?: "user" | "convention" | "preference" | "project" | "debugging" | "feedback" | "reference" | undefined;
     query?: string | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    global?: boolean | undefined;
 }>;
 export declare const MemoryTool: Tool<typeof inputSchema>;
 export {};

package/dist/tools/MemoryTool/index.js

@@ -1,9 +1,19 @@
 import { z } from "zod";
-import { saveMemory, loadActiveMemories, touchMemory } from "../../harness/memory.js";
+import { loadActiveMemories, saveMemory, touchMemory } from "../../harness/memory.js";
 const inputSchema = z.object({
     action: z.enum(["save", "list", "search"]),
     name: z.string().optional().describe("Memory name (for save)"),
-    type: z.enum(["convention", "preference", "project", "debugging"]).optional(),
+    type: z
+        .enum([
+        "convention",
+        "preference",
+        "project",
+        "debugging", // legacy
+        "user",
+        "feedback",
+        "reference", // Claude Code compatible
+    ])
+        .optional(),
     description: z.string().optional(),
     content: z.string().optional().describe("Memory content (for save)"),
     query: z.string().optional().describe("Search query (for search)"),
@@ -14,29 +24,33 @@ export const MemoryTool = {
     description: "Save, list, or search persistent memories that survive across sessions.",
     inputSchema,
     riskLevel: "low",
-    isReadOnly(input) { return input.action !== 'save'; },
-    isConcurrencySafe() { return true; },
+    isReadOnly(input) {
+        return input.action !== "save";
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call(input) {
-        if (input.action === 'save') {
+        if (input.action === "save") {
             if (!input.name || !input.content) {
                 return { output: "name and content required for save.", isError: true };
             }
-            const path = saveMemory(input.name, input.type ?? 'convention', input.description ?? input.name, input.content, input.global);
+            const path = saveMemory(input.name, (input.type ?? "user"), input.description ?? input.name, input.content, input.global);
             return { output: `Memory saved: ${path}`, isError: false };
         }
-        if (input.action === 'list') {
+        if (input.action === "list") {
             const memories = loadActiveMemories();
             if (memories.length === 0)
                 return { output: "No memories saved.", isError: false };
-            const lines = memories.map(m => `[${m.type}] ${m.name} (relevance: ${(m.relevance ?? 0.5).toFixed(1)}) — ${m.description}`);
-            return { output: lines.join('\n'), isError: false };
+            const lines = memories.map((m) => `[${m.type}] ${m.name} (relevance: ${(m.relevance ?? 0.5).toFixed(1)}) — ${m.description}`);
+            return { output: lines.join("\n"), isError: false };
         }
-        if (input.action === 'search') {
+        if (input.action === "search") {
             if (!input.query)
                 return { output: "query required for search.", isError: true };
             const memories = loadActiveMemories();
             const q = input.query.toLowerCase();
-            const matches = memories.filter(m => m.name.toLowerCase().includes(q) ||
+            const matches = memories.filter((m) => m.name.toLowerCase().includes(q) ||
                 m.content.toLowerCase().includes(q) ||
                 m.description.toLowerCase().includes(q));
             if (matches.length === 0)
@@ -44,13 +58,13 @@ export const MemoryTool = {
             // Touch accessed memories to boost relevance
             for (const m of matches)
                 touchMemory(m);
-            const lines = matches.map(m => `[${m.type}] ${m.name}: ${m.content.slice(0, 200)}`);
-            return { output: lines.join('\n\n'), isError: false };
+            const lines = matches.map((m) => `[${m.type}] ${m.name}: ${m.content.slice(0, 200)}`);
+            return { output: lines.join("\n\n"), isError: false };
         }
         return { output: "Unknown action.", isError: true };
     },
     prompt() {
-        return "Memory: Save/list/search persistent memories across sessions. Actions: save, list, search.";
+        return "Memory: Save/list/search persistent memories across sessions. Actions: save, list, search. Types: user (role/preferences), feedback (corrections/confirmations), project (goals/decisions), reference (external pointers). Legacy types also accepted: convention, preference, debugging.";
     },
 };
 //# sourceMappingURL=index.js.map

package/dist/tools/MonitorTool/index.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import { spawn } from "node:child_process";
+import { z } from "zod";
 const inputSchema = z.object({
     command: z.string().describe("Background command to watch"),
     pattern: z.string().optional().describe("Regex pattern to match output lines"),
@@ -11,8 +11,12 @@ export const MonitorTool = {
     description: "Watch a background process and collect output. Optionally filter by regex pattern.",
     inputSchema,
     riskLevel: "medium",
-    isReadOnly() { return true; },
-    isConcurrencySafe() { return true; },
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call(input, context) {
         const timeout = input.timeout ?? 60_000;
         const maxLines = input.maxLines ?? 100;
@@ -22,7 +26,7 @@ export const MonitorTool = {
             let settled = false;
             const proc = spawn(input.command, {
                 shell: true,
-                stdio: ['pipe', 'pipe', 'pipe'],
+                stdio: ["pipe", "pipe", "pipe"],
                 windowsHide: true,
             });
             const timer = setTimeout(() => {
@@ -31,7 +35,8 @@ export const MonitorTool = {
                     proc.kill();
                     resolve({
                         output: lines.length > 0
-                            ? lines.join('\n') + `\n\n[Monitor timed out after ${timeout / 1000}s — ${lines.length} lines collected]`
+                            ? 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,
                     });
@@ -45,35 +50,35 @@ export const MonitorTool = {
                 lines.push(line.trimEnd());
                 // Stream output chunk if callback available
                 if (context.onOutputChunk && context.callId) {
-                    context.onOutputChunk(context.callId, line + '\n');
+                    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]`,
+                        output: `${lines.join("\n")}\n\n[Collected ${maxLines} lines — stopped]`,
                         isError: false,
                     });
                 }
             };
-            let stdoutBuffer = '';
-            proc.stdout?.on('data', (chunk) => {
+            let stdoutBuffer = "";
+            proc.stdout?.on("data", (chunk) => {
                 stdoutBuffer += chunk.toString();
-                const parts = stdoutBuffer.split('\n');
-                stdoutBuffer = parts.pop() ?? '';
+                const parts = stdoutBuffer.split("\n");
+                stdoutBuffer = parts.pop() ?? "";
                 for (const line of parts)
                     handleLine(line);
             });
-            let stderrBuffer = '';
-            proc.stderr?.on('data', (chunk) => {
+            let stderrBuffer = "";
+            proc.stderr?.on("data", (chunk) => {
                 stderrBuffer += chunk.toString();
-                const parts = stderrBuffer.split('\n');
-                stderrBuffer = parts.pop() ?? '';
+                const parts = stderrBuffer.split("\n");
+                stderrBuffer = parts.pop() ?? "";
                 for (const line of parts)
                     handleLine(line);
             });
-            proc.on('exit', (code) => {
+            proc.on("exit", (code) => {
                 if (!settled) {
                     settled = true;
                     clearTimeout(timer);
@@ -84,13 +89,13 @@ export const MonitorTool = {
                         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]`,
+                            ? `${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) => {
+            proc.on("error", (err) => {
                 if (!settled) {
                     settled = true;
                     clearTimeout(timer);

package/dist/tools/MultiEditTool/index.js

@@ -1,5 +1,5 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { z } from "zod";
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
 const editSchema = z.object({
     file_path: z.string(),
     old_string: z.string(),
@@ -13,8 +13,12 @@ export const MultiEditTool = {
     description: "Apply multiple file edits atomically. All edits succeed or none do. Useful for coordinated changes across files.",
     inputSchema,
     riskLevel: "medium",
-    isReadOnly() { return false; },
-    isConcurrencySafe() { return false; },
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return false;
+    },
     async call(input) {
         // Phase 1: Validate all edits can be applied
         const originals = new Map();
@@ -24,7 +28,7 @@ export const MultiEditTool = {
                 return { output: `File not found: ${edit.file_path}`, isError: true };
             }
             if (!originals.has(edit.file_path)) {
-                originals.set(edit.file_path, readFileSync(edit.file_path, 'utf-8'));
+                originals.set(edit.file_path, readFileSync(edit.file_path, "utf-8"));
             }
             const current = modified.get(edit.file_path) ?? originals.get(edit.file_path);
             if (!current.includes(edit.old_string)) {
@@ -42,7 +46,7 @@ export const MultiEditTool = {
             results.push(path);
         }
         return {
-            output: `Applied ${input.edits.length} edit(s) across ${results.length} file(s): ${results.join(', ')}`,
+            output: `Applied ${input.edits.length} edit(s) across ${results.length} file(s): ${results.join(", ")}`,
             isError: false,
         };
     },

package/dist/tools/NotebookEditTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     notebook_path: z.string(),
     cell_index: z.number(),
@@ -36,7 +36,7 @@ export const NotebookEditTool = {
                 };
             }
             // Notebook cell source is an array of lines
-            const lines = input.new_source.split("\n").map((line, i, arr) => i < arr.length - 1 ? line + "\n" : line);
+            const lines = input.new_source.split("\n").map((line, i, arr) => (i < arr.length - 1 ? `${line}\n` : line));
             notebook.cells[input.cell_index].source = lines;
             await fs.writeFile(filePath, JSON.stringify(notebook, null, 1), "utf-8");
             return {

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

@@ -7,27 +7,27 @@ declare const inputSchema: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         blockedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
-        prompt: string;
         id: string;
+        prompt: string;
         description?: string | undefined;
         blockedBy?: string[] | undefined;
     }, {
-        prompt: string;
         id: string;
+        prompt: string;
         description?: string | undefined;
         blockedBy?: string[] | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     tasks: {
-        prompt: string;
         id: string;
+        prompt: string;
         description?: string | undefined;
         blockedBy?: string[] | undefined;
     }[];
 }, {
     tasks: {
-        prompt: string;
         id: string;
+        prompt: string;
         description?: string | undefined;
         blockedBy?: string[] | undefined;
     }[];

package/dist/tools/ParallelAgentTool/index.js

@@ -14,8 +14,12 @@ export const ParallelAgentTool = {
     description: "Dispatch multiple sub-agents in parallel with optional task dependencies.",
     inputSchema,
     riskLevel: "medium",
-    isReadOnly() { return false; },
-    isConcurrencySafe() { return false; },
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return false;
+    },
     async call(input, context) {
         if (!context.provider || !context.tools) {
             return { output: "Parallel agents unavailable: provider not in context.", isError: true };
@@ -24,12 +28,14 @@ export const ParallelAgentTool = {
         const dispatcher = new AgentDispatcher(context.provider, context.tools, systemPrompt, context.permissionMode ?? "trust", context.model, context.workingDir, context.abortSignal);
         dispatcher.addTasks(input.tasks);
         const results = await dispatcher.execute();
-        const output = results.map(r => {
-            const status = r.isError ? '✗' : '✓';
+        const output = results
+            .map((r) => {
+            const status = r.isError ? "✗" : "✓";
             const duration = (r.durationMs / 1000).toFixed(1);
             return `${status} [${r.id}] (${duration}s)\n${r.output}`;
-        }).join('\n\n---\n\n');
-        const hasErrors = results.some(r => r.isError);
+        })
+            .join("\n\n---\n\n");
+        const hasErrors = results.some((r) => r.isError);
         return { output, isError: hasErrors };
     },
     prompt() {

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

@@ -8,29 +8,29 @@ declare const inputSchema: z.ZodObject<{
         dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         tool: string;
-        args: Record<string, unknown>;
         id: string;
+        args: Record<string, unknown>;
         dependsOn?: string[] | undefined;
     }, {
         tool: string;
-        args: Record<string, unknown>;
         id: string;
+        args: Record<string, unknown>;
         dependsOn?: string[] | undefined;
     }>, "many">;
     description: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     steps: {
         tool: string;
-        args: Record<string, unknown>;
         id: string;
+        args: Record<string, unknown>;
         dependsOn?: string[] | undefined;
     }[];
     description?: string | undefined;
 }, {
     steps: {
         tool: string;
-        args: Record<string, unknown>;
         id: string;
+        args: Record<string, unknown>;
         dependsOn?: string[] | undefined;
     }[];
     description?: string | undefined;

package/dist/tools/PipelineTool/index.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { PipelineExecutor, formatPipelineResults } from "../../services/PipelineExecutor.js";
+import { formatPipelineResults, PipelineExecutor } from "../../services/PipelineExecutor.js";
 const stepSchema = z.object({
     id: z.string().describe("Unique step identifier"),
     tool: z.string().describe("Tool name to execute (Glob, Grep, Read, Bash, etc.)"),
@@ -15,7 +15,7 @@ export const PipelineTool = {
     description: "Execute a declarative multi-step tool pipeline. Steps run in dependency order with variable substitution.",
     inputSchema,
     riskLevel: "medium",
-    isReadOnly(input) {
+    isReadOnly(_input) {
         // Pipeline is read-only only if ALL steps use read-only tools
         // Conservative: assume not read-only
         return false;
@@ -30,7 +30,7 @@ export const PipelineTool = {
         const executor = new PipelineExecutor(context.tools, context);
         const results = await executor.execute(input.steps);
         const summary = formatPipelineResults(results);
-        const hasErrors = results.some(r => r.isError);
+        const hasErrors = results.some((r) => r.isError);
         return { output: summary, isError: hasErrors };
     },
     prompt() {

package/dist/tools/PowerShellTool/index.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import { execSync } from "node:child_process";
+import { z } from "zod";
 const inputSchema = z.object({
     command: z.string().describe("PowerShell command to execute"),
     timeout: z.number().optional().describe("Timeout in ms (default 120000)"),
@@ -9,19 +9,23 @@ export const PowerShellTool = {
     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; },
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return false;
+    },
     async call(input) {
-        if (process.platform !== 'win32') {
+        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 });
+            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');
+            const output = String(err.stdout ?? err.stderr ?? err.message ?? "PowerShell error");
             return { output: output.slice(0, 100_000), isError: true };
         }
     },

package/dist/tools/RemoteTriggerTool/index.js

@@ -10,13 +10,17 @@ export const RemoteTriggerTool = {
     description: "Trigger a remote webhook or API endpoint. Useful for CI/CD, deployments, and external integrations.",
     inputSchema,
     riskLevel: "high",
-    isReadOnly() { return false; },
-    isConcurrencySafe() { return true; },
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call(input) {
         try {
             const method = input.method ?? (input.body ? "POST" : "GET");
             const headers = {
-                'Content-Type': 'application/json',
+                "Content-Type": "application/json",
                 ...input.headers,
             };
             const res = await fetch(input.url, {
@@ -26,7 +30,7 @@ export const RemoteTriggerTool = {
                 signal: AbortSignal.timeout(30_000),
             });
             const text = await res.text();
-            const truncated = text.length > 5000 ? text.slice(0, 5000) + '\n[truncated]' : text;
+            const truncated = text.length > 5000 ? `${text.slice(0, 5000)}\n[truncated]` : text;
             return {
                 output: `${res.status} ${res.statusText}\n${truncated}`,
                 isError: res.status >= 400,