@within-7/minto 0.3.10 → 0.4.1

package/dist/services/hookExecutor.js

@@ -1,10 +1,12 @@
 import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
 import { EventEmitter } from "events";
 import {
   HookEvent
 } from "../types/hooks.js";
 import { getCwd } from "../utils/state.js";
 import { logError } from "../utils/log.js";
+import { emitReminderEvent } from "./systemReminder.js";
 const logInfo = (msg) => {
   if (process.env.DEBUG) console.log(`[INFO] ${msg}`);
 };
@@ -12,132 +14,326 @@ const logDebug = (msg, ...args) => {
   if (process.env.DEBUG) console.log(`[DEBUG] ${msg}`, ...args);
 };
 const hookStatusEmitter = new EventEmitter();
+const executedOnceHooks = /* @__PURE__ */ new Set();
+function resetOnceHooks() {
+  executedOnceHooks.clear();
+}
 function formatHookStatusMessage(event, toolName, hookName, success, errorMessage) {
   const eventPart = toolName ? `${event}:${toolName}` : event;
   const statusPart = success ? "succeeded" : "failed";
   const detailPart = success ? "Success" : errorMessage || "Error";
   return `${eventPart} hook ${statusPart}: ${detailPart}`;
 }
+function emitStatusEvent(event, toolName, hookName, success, errorMessage) {
+  hookStatusEmitter.emit("status", {
+    event,
+    toolName,
+    success,
+    message: formatHookStatusMessage(
+      event,
+      toolName,
+      hookName,
+      success,
+      errorMessage
+    ),
+    timestamp: Date.now(),
+    hookName
+  });
+}
+function substituteArguments(command, input) {
+  if (!command.includes("$ARGUMENTS")) {
+    return command;
+  }
+  const inputJson = JSON.stringify(input);
+  const escaped = inputJson.replace(/'/g, "'\\''");
+  return command.replace(/\$ARGUMENTS/g, `'${escaped}'`);
+}
 async function executeHook(hook, input, options) {
-  if (hook.config.type !== "command" || !hook.config.command) {
-    return {
-      success: false,
-      error: `Hook type "${hook.config.type}" not yet implemented`
-    };
+  const hookType = hook.config.type || "command";
+  if (hook.config.once) {
+    const hookKey = `${hook.pluginName}:${hook.name}:${hook.event}`;
+    if (executedOnceHooks.has(hookKey)) {
+      logDebug(`Skipping once-hook (already executed): ${hookKey}`);
+      return { success: true };
+    }
+    executedOnceHooks.add(hookKey);
   }
-  const timeout = hook.config.timeout || options.timeout || 3e4;
   const toolName = "tool_name" in input ? input.tool_name : void 0;
+  if (hook.config.async) {
+    executeHookAsync(hook, input, options, hookType, toolName).catch((err) => {
+      logDebug(`Async hook ${hook.name} error: ${err}`);
+    });
+    return { success: true };
+  }
+  switch (hookType) {
+    case "command":
+      return executeCommandHook(hook, input, options, toolName);
+    case "prompt":
+      return executePromptHook(hook, input, options, toolName);
+    case "agent":
+      return executeAgentHook(hook, input, options, toolName);
+    default:
+      return {
+        success: false,
+        error: `Unknown hook type: ${hookType}`
+      };
+  }
+}
+async function executeHookAsync(hook, input, options, hookType, toolName) {
+  try {
+    let result;
+    switch (hookType) {
+      case "command":
+        result = await executeCommandHook(hook, input, options, toolName);
+        break;
+      case "prompt":
+        result = await executePromptHook(hook, input, options, toolName);
+        break;
+      case "agent":
+        result = await executeAgentHook(hook, input, options, toolName);
+        break;
+      default:
+        return;
+    }
+    if (result.output?.systemMessage) {
+      hookStatusEmitter.emit("asyncResult", {
+        hookName: hook.name,
+        systemMessage: result.output.systemMessage
+      });
+    }
+  } catch {
+  }
+}
+async function executeCommandHook(hook, input, options, toolName) {
+  if (!hook.config.command) {
+    return { success: false, error: "Command hook missing command field" };
+  }
+  const timeout = (hook.config.timeout ? hook.config.timeout * 1e3 : void 0) || options.timeout || 3e4;
   try {
     logDebug(`Executing hook: ${hook.name}`);
-    logDebug(`Command: ${hook.config.command}`);
-    const result = await executeBashCommand(hook.config.command, input, {
+    const command = substituteArguments(hook.config.command, input);
+    logDebug(`Command: ${command}`);
+    const result = await executeBashCommand(command, input, {
       ...options,
       timeout,
       pluginRoot: options.pluginRoot
     });
     if (result.timedOut) {
-      logError(`Hook ${hook.name} timed out after ${timeout}ms`);
       const errorMsg = `Hook execution timed out after ${timeout}ms`;
-      hookStatusEmitter.emit("status", {
-        event: hook.event,
-        toolName,
-        success: false,
-        message: formatHookStatusMessage(
-          hook.event,
-          toolName,
-          hook.name,
-          false,
-          errorMsg
-        ),
-        timestamp: Date.now(),
-        hookName: hook.name
-      });
-      return {
-        success: false,
-        timedOut: true,
-        error: errorMsg
-      };
+      logError(`Hook ${hook.name} timed out after ${timeout}ms`);
+      emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
+      return { success: false, timedOut: true, error: errorMsg };
     }
-    if (result.error) {
-      logError(`Hook ${hook.name} failed: ${result.error}`);
-      hookStatusEmitter.emit("status", {
-        event: hook.event,
-        toolName,
-        success: false,
-        message: formatHookStatusMessage(
-          hook.event,
-          toolName,
-          hook.name,
-          false,
-          result.error
-        ),
-        timestamp: Date.now(),
-        hookName: hook.name
-      });
+    if (result.exitCode === 2) {
+      const reason = result.stderr.trim() || "Blocked by hook";
+      logDebug(`Hook ${hook.name} exit code 2 (block): ${reason}`);
+      emitStatusEvent(hook.event, toolName, hook.name, true);
       return {
-        success: false,
-        error: result.error
+        success: true,
+        decision: "block",
+        blockedByExitCode2: true,
+        blockReason: reason,
+        output: {
+          decision: "block",
+          reason,
+          systemMessage: reason
+        }
       };
     }
-    const output = parseHookOutput(result.stdout);
+    if (result.exitCode !== 0 && result.exitCode !== null) {
+      const errorMsg = `Command exited with code ${result.exitCode}: ${result.stderr}`;
+      logError(`Hook ${hook.name} failed: ${errorMsg}`);
+      emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
+      return { success: false, error: errorMsg };
+    }
+    const output = parseHookOutput(result.stdout, input.hook_event_name);
     if (!output) {
-      hookStatusEmitter.emit("status", {
-        event: hook.event,
-        toolName,
-        success: true,
-        message: formatHookStatusMessage(hook.event, toolName, hook.name, true),
-        timestamp: Date.now(),
-        hookName: hook.name
-      });
-      return {
-        success: true
-      };
+      emitStatusEvent(hook.event, toolName, hook.name, true);
+      return { success: true };
     }
     logDebug(`Hook ${hook.name} output:`, output);
-    hookStatusEmitter.emit("status", {
-      event: hook.event,
-      toolName,
-      success: true,
-      message: formatHookStatusMessage(hook.event, toolName, hook.name, true),
-      timestamp: Date.now(),
-      hookName: hook.name
-    });
-    return {
-      success: true,
-      decision: output.decision,
-      output
-    };
+    emitStatusEvent(hook.event, toolName, hook.name, true);
+    const decision = resolveDecision(output);
+    return { success: true, decision, output };
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
     logError(`Hook ${hook.name} execution error: ${errorMsg}`);
-    hookStatusEmitter.emit("status", {
-      event: hook.event,
-      toolName,
-      success: false,
-      message: formatHookStatusMessage(
-        hook.event,
-        toolName,
-        hook.name,
-        false,
-        errorMsg
-      ),
-      timestamp: Date.now(),
-      hookName: hook.name
-    });
-    return {
-      success: false,
-      error: errorMsg
-    };
+    emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
+    return { success: false, error: errorMsg };
+  }
+}
+async function executePromptHook(hook, input, options, toolName) {
+  if (!hook.config.prompt) {
+    return { success: false, error: "Prompt hook missing prompt field" };
+  }
+  const timeout = (hook.config.timeout ? hook.config.timeout * 1e3 : void 0) || 3e4;
+  try {
+    const inputJson = JSON.stringify(input);
+    const prompt = hook.config.prompt.replace(/\$ARGUMENTS/g, inputJson);
+    logDebug(`Executing prompt hook: ${hook.name}`);
+    const { queryQuick } = await import("./claude.js");
+    const abortController = new AbortController();
+    const timer = setTimeout(() => abortController.abort(), timeout);
+    try {
+      const result = await queryQuick({
+        systemPrompt: [
+          'You are a hook evaluator. Respond ONLY with JSON: { "ok": boolean, "reason": string }.',
+          "ok=true means allow the action, ok=false means block it."
+        ],
+        userPrompt: prompt,
+        signal: abortController.signal
+      });
+      clearTimeout(timer);
+      const text = result.message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        const decision = parsed.ok ? "approve" : "block";
+        emitStatusEvent(hook.event, toolName, hook.name, true);
+        return {
+          success: true,
+          decision,
+          output: { decision, reason: parsed.reason }
+        };
+      }
+    } catch {
+      clearTimeout(timer);
+    }
+    logDebug(`Prompt hook ${hook.name}: parse failed, defaulting to allow`);
+    emitStatusEvent(hook.event, toolName, hook.name, true);
+    return { success: true, decision: "approve" };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logError(`Prompt hook ${hook.name} error: ${errorMsg}`);
+    emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
+    return { success: true, decision: "approve" };
   }
 }
+async function executeAgentHook(hook, input, options, toolName) {
+  if (!hook.config.prompt) {
+    return { success: false, error: "Agent hook missing prompt field" };
+  }
+  const timeout = (hook.config.timeout ? hook.config.timeout * 1e3 : void 0) || 6e4;
+  try {
+    const inputJson = JSON.stringify(input);
+    const prompt = hook.config.prompt.replace(/\$ARGUMENTS/g, inputJson);
+    logDebug(`Executing agent hook: ${hook.name}`);
+    const { queryQuick } = await import("./claude.js");
+    const abortController = new AbortController();
+    const timer = setTimeout(() => abortController.abort(), timeout);
+    try {
+      const result = await queryQuick({
+        systemPrompt: [
+          "You are a hook agent evaluator. You have read-only access to the codebase.",
+          'Evaluate the request and respond ONLY with JSON: { "ok": boolean, "reason": string }.',
+          "ok=true means allow the action, ok=false means block it."
+        ],
+        userPrompt: prompt,
+        signal: abortController.signal
+      });
+      clearTimeout(timer);
+      const text = result.message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        const decision = parsed.ok ? "approve" : "block";
+        emitStatusEvent(hook.event, toolName, hook.name, true);
+        return {
+          success: true,
+          decision,
+          output: { decision, reason: parsed.reason }
+        };
+      }
+    } catch {
+      clearTimeout(timer);
+    }
+    logDebug(`Agent hook ${hook.name}: parse failed, defaulting to allow`);
+    emitStatusEvent(hook.event, toolName, hook.name, true);
+    return { success: true, decision: "approve" };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logError(`Agent hook ${hook.name} error: ${errorMsg}`);
+    emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
+    return { success: true, decision: "approve" };
+  }
+}
+function resolveDecision(output) {
+  if (output.hookSpecificOutput) {
+    const specific = output.hookSpecificOutput;
+    if (specific.permissionDecision) {
+      const mapping = {
+        allow: "approve",
+        deny: "block",
+        ask: "ask",
+        approve: "approve",
+        block: "block"
+      };
+      return mapping[specific.permissionDecision] ?? output.decision;
+    }
+  }
+  return output.decision;
+}
+let claudeEnvFilePath;
+function loadEnvFile() {
+  const envFile = claudeEnvFilePath || process.env.CLAUDE_ENV_FILE;
+  if (!envFile || !existsSync(envFile)) return {};
+  try {
+    const content = readFileSync(envFile, "utf-8");
+    const vars = {};
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx <= 0) continue;
+      const key = trimmed.slice(0, eqIdx).trim();
+      let value = trimmed.slice(eqIdx + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      vars[key] = value;
+    }
+    return vars;
+  } catch {
+    return {};
+  }
+}
+function extractFilePathsFromInput(toolInput) {
+  if (!toolInput) return "";
+  const paths = [];
+  if (typeof toolInput.file_path === "string") paths.push(toolInput.file_path);
+  if (typeof toolInput.path === "string") paths.push(toolInput.path);
+  if (typeof toolInput.notebook_path === "string")
+    paths.push(toolInput.notebook_path);
+  return paths.join(":");
+}
 async function executeBashCommand(command, input, options) {
   return new Promise((resolve) => {
+    const envFileVars = loadEnvFile();
+    const toolName = "tool_name" in input ? input.tool_name : void 0;
+    const toolInput = "tool_input" in input ? input.tool_input : void 0;
+    const toolInputJson = toolInput ? JSON.stringify(toolInput) : "";
+    const filePaths = extractFilePathsFromInput(toolInput);
+    const shellCommand = toolName === "Bash" && toolInput?.command ? String(toolInput.command) : "";
+    const projectDir = getCwd();
     const env = {
       ...process.env,
+      ...envFileVars,
+      // CC-compatible env vars
       CLAUDE_PLUGIN_ROOT: options.pluginRoot,
       CLAUDE_SESSION_ID: options.sessionId,
-      CLAUDE_CWD: getCwd(),
-      CLAUDE_TRANSCRIPT_PATH: options.transcriptPath || ""
+      CLAUDE_CWD: projectDir,
+      CLAUDE_TRANSCRIPT_PATH: options.transcriptPath || "",
+      CLAUDE_PROJECT_DIR: projectDir,
+      CLAUDE_WORKSPACE_DIR: projectDir,
+      CLAUDE_TOOL_INPUT: toolInputJson,
+      CLAUDE_FILE_PATHS: filePaths,
+      CLAUDE_SHELL_COMMAND: shellCommand,
+      // Minto-prefixed duplicates
+      MINTO_PROJECT_DIR: projectDir,
+      MINTO_WORKSPACE_DIR: projectDir,
+      MINTO_TOOL_INPUT: toolInputJson,
+      MINTO_FILE_PATHS: filePaths,
+      MINTO_SHELL_COMMAND: shellCommand
     };
     const child = spawn("bash", ["-c", command], {
       env,
@@ -164,32 +360,17 @@ async function executeBashCommand(command, input, options) {
     child.on("close", (code) => {
       clearTimeout(timer);
       if (timedOut) {
-        resolve({
-          stdout: "",
-          stderr: "",
-          timedOut: true
-        });
-        return;
-      }
-      if (code !== 0 && code !== null) {
-        resolve({
-          stdout,
-          stderr,
-          error: `Command exited with code ${code}: ${stderr}`
-        });
+        resolve({ stdout: "", stderr: "", exitCode: null, timedOut: true });
         return;
       }
-      resolve({
-        stdout,
-        stderr
-      });
+      resolve({ stdout, stderr, exitCode: code });
     });
     child.on("error", (error) => {
       clearTimeout(timer);
       resolve({
         stdout: "",
-        stderr: "",
-        error: `Failed to spawn process: ${error.message}`
+        stderr: error.message,
+        exitCode: 1
       });
     });
     try {
@@ -202,13 +383,13 @@ async function executeBashCommand(command, input, options) {
       child.kill();
       resolve({
         stdout: "",
-        stderr: "",
-        error: `Failed to write to stdin: ${error instanceof Error ? error.message : String(error)}`
+        stderr: `Failed to write to stdin: ${error instanceof Error ? error.message : String(error)}`,
+        exitCode: 1
       });
     }
   });
 }
-function parseHookOutput(stdout) {
+function parseHookOutput(stdout, eventName) {
   if (!stdout.trim()) {
     return null;
   }
@@ -218,11 +399,45 @@ function parseHookOutput(stdout) {
       logDebug("No JSON found in hook output");
       return null;
     }
-    const output = JSON.parse(jsonMatch[0]);
-    if (output.decision) {
-      if (!["approve", "block", "ask"].includes(output.decision)) {
-        logError(`Invalid hook decision: ${output.decision}`);
-        return null;
+    const raw = JSON.parse(jsonMatch[0]);
+    const output = {};
+    if (raw.continue !== void 0) output.continue = raw.continue;
+    if (raw.stopReason) output.stopReason = raw.stopReason;
+    if (raw.suppressOutput !== void 0)
+      output.suppressOutput = raw.suppressOutput;
+    if (raw.systemMessage) output.systemMessage = raw.systemMessage;
+    if (raw.decision) {
+      if (["approve", "block", "ask"].includes(raw.decision)) {
+        output.decision = raw.decision;
+      }
+    }
+    if (raw.reason) output.reason = raw.reason;
+    const specific = raw.hookSpecificOutput || raw;
+    if (eventName === HookEvent.PreToolUse) {
+      if (specific.permissionDecision || specific.updatedInput || specific.permissionDecisionReason) {
+        output.hookSpecificOutput = {
+          hookEventName: HookEvent.PreToolUse,
+          permissionDecision: specific.permissionDecision,
+          permissionDecisionReason: specific.permissionDecisionReason,
+          updatedInput: specific.updatedInput
+        };
+      }
+    } else if (eventName === HookEvent.PostToolUse || eventName === HookEvent.UserPromptSubmit || eventName === HookEvent.SessionStart) {
+      if (specific.additionalContext) {
+        output.hookSpecificOutput = {
+          hookEventName: eventName,
+          additionalContext: specific.additionalContext
+        };
+      }
+      if (eventName === HookEvent.SessionStart && specific.envFile) {
+        claudeEnvFilePath = specific.envFile;
+        process.env.CLAUDE_ENV_FILE = specific.envFile;
+      }
+    }
+    if (eventName === HookEvent.Notification) {
+      if (raw.suppressNotification !== void 0) {
+        ;
+        output.suppressNotification = raw.suppressNotification;
       }
     }
     return output;
@@ -239,18 +454,37 @@ async function executeHooksForEvent(event, hooks, input, options) {
     return [];
   }
   logInfo(`Executing ${matchingHooks.length} hook(s) for event: ${event}`);
-  const results = await Promise.all(
+  const results = await Promise.allSettled(
     matchingHooks.map((hook) => executeHook(hook, input, options))
   );
-  return results;
+  return results.map(
+    (r) => r.status === "fulfilled" ? r.value : { success: false, error: String(r.reason) }
+  );
 }
 function processHookDecisions(results) {
-  const blockedResult = results.find((r) => r.success && r.decision === "block");
+  let additionalContext;
+  let updatedInput;
+  for (const r of results) {
+    if (!r.success || !r.output) continue;
+    const specific = r.output.hookSpecificOutput;
+    if (specific?.additionalContext) {
+      additionalContext = additionalContext ? `${additionalContext}
+${specific.additionalContext}` : specific.additionalContext;
+    }
+    if (specific?.updatedInput) {
+      updatedInput = { ...updatedInput || {}, ...specific.updatedInput };
+    }
+  }
+  const blockedResult = results.find(
+    (r) => r.success && r.decision === "block" || r.blockedByExitCode2
+  );
   if (blockedResult) {
+    const reason = blockedResult.blockReason || blockedResult.output?.reason || "Blocked by hook";
+    emitReminderEvent("hook:blocking_error", { hookName: "hook", reason });
     return {
       shouldContinue: false,
       shouldAskUser: false,
-      reason: blockedResult.output?.reason || "Blocked by hook"
+      reason
     };
   }
   const askResult = results.find((r) => r.success && r.decision === "ask");
@@ -263,15 +497,25 @@ function processHookDecisions(results) {
   }
   const failedResult = results.find((r) => !r.success);
   if (failedResult) {
+    const reason = `Hook execution failed: ${failedResult.error}`;
+    emitReminderEvent("hook:stopped_continuation", { hookName: "hook", reason });
     return {
       shouldContinue: false,
       shouldAskUser: true,
-      reason: `Hook execution failed: ${failedResult.error}`
+      reason
     };
   }
+  if (additionalContext) {
+    emitReminderEvent("hook:additional_context", {
+      hookName: "hook",
+      content: additionalContext
+    });
+  }
   return {
     shouldContinue: true,
-    shouldAskUser: false
+    shouldAskUser: false,
+    updatedInput,
+    additionalContext
   };
 }
 function createPreToolUseInput(sessionId, transcriptPath, toolName, toolInput) {
@@ -387,14 +631,16 @@ function createSubagentStopInput(sessionId, transcriptPath, agentType, agentId,
     stop_hook_active: stopHookActive ?? false
   };
 }
-function createNotificationInput(sessionId, transcriptPath, message) {
+function createNotificationInput(sessionId, transcriptPath, message, title, type) {
   return {
     hook_event_name: HookEvent.Notification,
     session_id: sessionId,
     transcript_path: transcriptPath,
     cwd: getCwd(),
     permission_mode: "default",
-    message
+    message,
+    ...title ? { title } : {},
+    ...type ? { notification_type: type } : {}
   };
 }
 function createPreCompactInput(sessionId, transcriptPath, trigger, customInstructions) {
@@ -422,7 +668,42 @@ function createPostCompactInput(sessionId, transcriptPath, trigger, summary, com
     compressed_tokens: compressedTokens
   };
 }
+function createConfigChangeInput(sessionId, transcriptPath, source, filePath) {
+  return {
+    hook_event_name: HookEvent.ConfigChange,
+    session_id: sessionId,
+    transcript_path: transcriptPath,
+    cwd: getCwd(),
+    permission_mode: "default",
+    source,
+    file_path: filePath
+  };
+}
+function createTaskCompletedInput(sessionId, transcriptPath, taskId, subject, description) {
+  return {
+    hook_event_name: HookEvent.TaskCompleted,
+    session_id: sessionId,
+    transcript_path: transcriptPath,
+    cwd: getCwd(),
+    permission_mode: "default",
+    task_id: taskId,
+    subject,
+    description
+  };
+}
+function createTeammateIdleInput(sessionId, transcriptPath, teammateName, teamName) {
+  return {
+    hook_event_name: HookEvent.TeammateIdle,
+    session_id: sessionId,
+    transcript_path: transcriptPath,
+    cwd: getCwd(),
+    permission_mode: "default",
+    teammate_name: teammateName,
+    team_name: teamName
+  };
+}
 export {
+  createConfigChangeInput,
   createNotificationInput,
   createPermissionRequestInput,
   createPostCompactInput,
@@ -435,10 +716,13 @@ export {
   createStopInput,
   createSubagentStartInput,
   createSubagentStopInput,
+  createTaskCompletedInput,
+  createTeammateIdleInput,
   createUserPromptSubmitInput,
   executeHook,
   executeHooksForEvent,
   hookStatusEmitter,
-  processHookDecisions
+  processHookDecisions,
+  resetOnceHooks
 };
 //# sourceMappingURL=hookExecutor.js.map