diff --git a/.roo/hooks/example.yaml b/.roo/hooks/example.yaml new file mode 100644 index 00000000000..ad6bb9a17b7 --- /dev/null +++ b/.roo/hooks/example.yaml @@ -0,0 +1,8 @@ +version: "1" +hooks: + PreToolUse: + - id: edit-verification + matcher: "edit" + enabled: true + command: 'echo "Edit verification triggered for $ROO_TOOL_NAME"' + timeout: 5 diff --git a/packages/types/src/global-settings.ts b/packages/types/src/global-settings.ts index 9a17834ced7..7f33757837c 100644 --- a/packages/types/src/global-settings.ts +++ b/packages/types/src/global-settings.ts @@ -176,6 +176,7 @@ export const globalSettingsSchema = z.object({ mcpEnabled: z.boolean().optional(), enableMcpServerCreation: z.boolean().optional(), + hooksEnabled: z.boolean().optional(), mode: z.string().optional(), modeApiConfigs: z.record(z.string(), z.string()).optional(), diff --git a/packages/types/src/message.ts b/packages/types/src/message.ts index 109cd842bac..e2371c91829 100644 --- a/packages/types/src/message.ts +++ b/packages/types/src/message.ts @@ -149,6 +149,7 @@ export function isNonBlockingAsk(ask: ClineAsk): ask is NonBlockingAsk { * - `condense_context`: Context condensation/summarization has started * - `condense_context_error`: Error occurred during context condensation * - `codebase_search_result`: Results from searching the codebase + * - `hook_triggered`: Notification that a hook has been executed */ export const clineSays = [ "error", @@ -179,6 +180,7 @@ export const clineSays = [ "condense_context_error", "sliding_window_truncation", "codebase_search_result", + "hook_triggered", "user_edit_todos", ] as const diff --git a/packages/types/src/vscode-extension-host.ts b/packages/types/src/vscode-extension-host.ts index f3116141f04..004f978fba5 100644 --- a/packages/types/src/vscode-extension-host.ts +++ b/packages/types/src/vscode-extension-host.ts @@ -95,6 +95,7 @@ export interface ExtensionMessage { | "customToolsResult" | "modes" | "taskWithAggregatedCosts" + | "hookExecutionStatus" text?: string payload?: any // eslint-disable-line @typescript-eslint/no-explicit-any checkpointWarning?: { @@ -190,6 +191,98 @@ export interface ExtensionMessage { childrenCost: number } historyItem?: HistoryItem + hookExecutionStatus?: HookExecutionStatusPayload +} + +/** + * HookExecutionStatusPayload + * Sent when hook execution starts, completes, or fails. + */ +export interface HookExecutionStatusPayload { + /** Status of the hook execution */ + status: "running" | "completed" | "failed" | "blocked" + /** Event type that triggered the hook */ + event: string + /** Tool name if this is a tool-related event */ + toolName?: string + /** Hook ID being executed */ + hookId?: string + /** Duration in milliseconds (only for completed/failed) */ + duration?: number + /** Error message if failed */ + error?: string + /** Block message if hook blocked the operation */ + blockMessage?: string + /** Whether tool input was modified */ + modified?: boolean +} + +/** + * Serializable hook information for webview display. + * This is a subset of ResolvedHook that can be safely serialized to JSON. + */ +export interface HookInfo { + /** Unique identifier for this hook */ + id: string + /** File path where this hook was defined (if known) */ + filePath?: string + /** The event type this hook is registered for */ + event: string + /** Tool name filter (regex/glob pattern) */ + matcher?: string + /** Preview of the command (truncated for display) */ + commandPreview: string + /** Whether this hook is enabled */ + enabled: boolean + /** Source of this hook configuration */ + source: "project" | "mode" | "global" + /** Timeout in seconds */ + timeout: number + /** Override shell if specified */ + shell?: string + /** Human-readable description */ + description?: string +} + +/** + * Serializable hook execution record for webview display. + */ +export interface HookExecutionRecord { + /** When the hook was executed (ISO string) */ + timestamp: string + /** The hook ID that was executed */ + hookId: string + /** The event that triggered execution */ + event: string + /** Tool name if this was a tool-related event */ + toolName?: string + /** Exit code from the process */ + exitCode: number | null + /** Execution duration in milliseconds */ + duration: number + /** Whether the hook timed out */ + timedOut: boolean + /** Whether the hook blocked execution */ + blocked: boolean + /** Error message if the hook failed */ + error?: string + /** Block message if the hook blocked */ + blockMessage?: string +} + +/** + * Hooks state for webview display. + * Contains all information needed to render the Hooks settings tab. + */ +export interface HooksState { + /** Array of resolved hooks with display information */ + enabledHooks: HookInfo[] + /** Recent execution history (last N records) */ + executionHistory: HookExecutionRecord[] + /** Whether project-level hooks are present (for security warnings) */ + hasProjectHooks: boolean + /** When the config snapshot was last loaded (ISO string) */ + snapshotTimestamp?: string } export type ExtensionState = Pick< @@ -289,6 +382,7 @@ export type ExtensionState = Pick< mcpEnabled: boolean enableMcpServerCreation: boolean + hooksEnabled: boolean mode: string customModes: ModeConfig[] @@ -335,6 +429,9 @@ export type ExtensionState = Pick< claudeCodeIsAuthenticated?: boolean openAiCodexIsAuthenticated?: boolean debug?: boolean + + /** Hooks configuration and execution state for the Hooks settings tab */ + hooks?: HooksState } export interface Command { @@ -521,6 +618,14 @@ export interface WebviewMessage { | "requestModes" | "switchMode" | "debugSetting" + | "hooksReloadConfig" + | "hooksSetEnabled" + | "hooksSetAllEnabled" + | "hooksOpenConfigFolder" + | "hooksDeleteHook" + | "hooksOpenHookFile" + | "hooksCreateNew" + | "hooksUpdateHook" text?: string editedMessageContent?: string tab?: "settings" | "history" | "mcp" | "modes" | "chat" | "marketplace" | "cloud" @@ -576,6 +681,16 @@ export interface WebviewMessage { list?: string[] // For dismissedUpsells response organizationId?: string | null // For organization switching useProviderSignup?: boolean // For rooCloudSignIn to use provider signup flow + hookId?: string // For hooksSetEnabled, hooksDeleteHook + hookEnabled?: boolean // For hooksSetEnabled + hooksEnabled?: boolean // For hooksSetAllEnabled + hooksSource?: "global" | "project" | "mode" // For hooksOpenConfigFolder, hooksDeleteHook + hookUpdates?: { + events?: string[] + matcher?: string + timeout?: number + } // For hooksUpdateHook + filePath?: string // For hooksOpenHookFile codeIndexSettings?: { // Global state settings codebaseIndexEnabled: boolean diff --git a/plans/hooks-ui-enhancement-prd.md b/plans/hooks-ui-enhancement-prd.md new file mode 100644 index 00000000000..17deeca4a63 --- /dev/null +++ b/plans/hooks-ui-enhancement-prd.md @@ -0,0 +1,373 @@ +# Hooks UI Enhancement PRD + +## Overview + +Enhance the "Config" tab in the Hook details view to provide a richer, more interactive configuration experience using VSCode-style UI components (checkboxes, dropdowns) instead of raw text display. + +## Problem Statement + +Currently, the Hooks UI Config tab displays configuration values as read-only text/code blocks, requiring users to manually edit YAML files for any changes. This is inconsistent with the rest of the settings UI and reduces usability. + +## Goals + +1. Replace text input/display for **Event**, **Matcher**, and **Timeout** with appropriate VSCode UI components +2. Enable immediate configuration updates that modify the underlying YAML file +3. Support multiple event selection (a conceptual hook can trigger on multiple events) +4. Provide intuitive tool group selection via checkboxes +5. Offer preset timeout options via dropdown + +--- + +## Requirements + +### 1. Event Configuration + +**Current Behavior:** + +- Displays as a single text label: `{hook.event}` + +**Desired Behavior:** + +- Replace with a set of checkboxes for event selection +- Available events (from `HookEventType`): + - `PreToolUse` + - `PostToolUse` + - `PostToolUseFailure` + - `PermissionRequest` + - `UserPromptSubmit` + - `Stop` + - `SubagentStop` + - `SubagentStart` + - `SessionStart` + - `SessionEnd` + - `Notification` + - `PreCompact` + +**Technical Approach for YAML Updates:** + +Since hooks are currently structured under event keys in YAML: + +```yaml +hooks: + PreToolUse: + - id: example-hook + ... +``` + +The UI will treat a "hook" as a **conceptual entity** that may have multiple YAML entries (one per event). + +**Update Logic:** + +- **When adding an event**: Copy the hook definition to the new event key in YAML +- **When removing an event**: Remove the hook definition from that event key in YAML +- **When changing events**: Combination of remove from old + add to new +- **Validation**: A hook must have at least one event selected at all times + +**Edge Case - Multiple Entries with Same ID:** +If the same hook ID exists under multiple event keys (which can happen with manual editing), the UI should: + +1. Load all entries as separate instances in the list +2. Allow editing each independently OR merge them into a "multi-event" view +3. **Recommendation**: Show as separate expandable items, but allow bulk event changes via a context menu + +### 2. Matcher Configuration + +**Current Behavior:** + +- Displays as a bulleted list of matcher patterns +- No edit capability in UI + +**Desired Behavior:** + +- Replace with a set of checkboxes for tool groups +- Available groups (from `TOOL_GROUPS`): + + - `read` - read_file, fetch_instructions, search_files, list_files, codebase_search + - `edit` - apply_diff, write_to_file, generate_image (plus customTools) + - `browser` - browser_action + - `command` - execute_command + - `mcp` - use_mcp_tool, access_mcp_resource + - `modes` - switch_mode, new_task + +- Additional "Custom" option that reveals a text input for regex patterns +- Checkboxes represent the `matcher` field, joined with `|` (e.g., `read|edit`) + +**UI Layout:** + +``` +[ ] read [ ] edit [ ] browser +[ ] command [ ] mcp [ ] modes +[ ] Custom matcher: + ┌─────────────────────────┐ + │ file.*\.ts │ + └─────────────────────────┘ +``` + +**Update Logic:** + +- Selected checkboxes → join with `|` → `matcher: "read|edit"` +- If custom input has value → append to the joined string +- Pattern: `[group1]|[group2]|[customPattern]` + +**Handling Mixed Matchers:** + +- If user has `matcher: "read|file.*\.ts"`: + - `read` checkbox: checked + - `file.*\.ts` shown in custom input (with label indicating it's not a standard group) + +### 3. Timeout Configuration + +**Current Behavior:** + +- Displays as plain text: `{hook.timeout}s` + +**Desired Behavior:** + +- Replace with a dropdown menu with preset options +- Options: + - 15 seconds + - 30 seconds + - 1 minute + - 5 minutes + - 10 minutes + - 15 minutes + - 30 minutes + - 60 minutes + +**UI Component:** + +``` +Timeout: [ 30 seconds ▼ ] +``` + +**Update Logic:** + +- Convert selected dropdown value to seconds for YAML storage +- Store as `timeout: 30` (seconds) in YAML + +--- + +## Technical Design + +### Data Model Updates + +Extend `ResolvedHook` or create a new `HookConfigUIState` for the enhanced UI: + +```typescript +interface HookConfigUIState { + id: string + filePath: string + source: "project" | "mode" | "global" + enabled: boolean + + // New fields for enhanced UI + events: HookEventType[] // Multiple events this hook responds to + matcher: string // Raw matcher string (for editing) + matcherGroups: ToolGroup[] // Parsed group names from matcher + timeout: number // in seconds + command: string + shell?: string + description?: string + commandPreview: string +} +``` + +### Backend Message Protocol + +Add new message type for updating hook configuration: + +```typescript +// Webview -> Extension +interface HooksUpdateHookMessage { + type: "hooksUpdateHook" + hookId: string + filePath: string // Source file to modify + updates: { + events?: HookEventType[] // New set of events + matcher?: string // New matcher string + timeout?: number // New timeout in seconds + } +} + +// Extension -> Webview (response) +interface HooksUpdateHookResult { + success: boolean + error?: string +} +``` + +### YAML Update Algorithm + +```typescript +async function updateHookConfig(filePath: string, hookId: string, updates: HookUpdates): Promise { + const content = await fs.readFile(filePath, "utf-8") + const parsed = parseYAML(content) + + // Get existing hook definition + const existingHook = findHookById(parsed.hooks, hookId) + + // For events update: + if (updates.events) { + const currentEvents = getEventsForHook(parsed.hooks, hookId) + const newEvents = updates.events + + // Remove from events no longer selected + for (const event of currentEvents) { + if (!newEvents.includes(event)) { + removeHookFromEvent(parsed.hooks, event, hookId) + } + } + + // Add to newly selected events + for (const event of newEvents) { + if (!currentEvents.includes(event)) { + addHookToEvent(parsed.hooks, event, existingHook) + } + } + } + + // For matcher update: + if (updates.matcher !== undefined) { + updateHookMatcher(parsed.hooks, hookId, updates.matcher) + } + + // For timeout update: + if (updates.timeout !== undefined) { + updateHookTimeout(parsed.hooks, hookId, updates.timeout) + } + + await fs.writeFile(filePath, stringifyYAML(parsed)) +} +``` + +### UI Component Architecture + +``` +HookConfigPanel +├── EventSelector +│ └── CheckboxGroup (12 events) +├── MatcherSelector +│ ├── CheckboxGroup (6 tool groups) +│ └── CustomMatcherInput (optional text field) +└── TimeoutSelector + └── VSCodeDropdown (8 preset options) +``` + +--- + +## Implementation Phases + +### Phase 1: Basic UI Components + +- Create `EventCheckboxGroup` component +- Create `MatcherCheckboxGroup` component +- Create `TimeoutDropdown` component +- Add to `HooksSettings.tsx` in the Config panel + +**Testable Outcome:** UI displays checkboxes/dropdown, but changes don't persist yet. + +### Phase 2: Backend Protocol + +- Add `hooksUpdateHook` message handler in `webviewMessageHandler.ts` +- Implement YAML update logic in a new `HookConfigWriter` service +- Connect UI components to send messages on change + +**Testable Outcome:** Changes to event/matcher/timeout update the YAML file. + +### Phase 3: Event Multi-Selection Logic + +- Handle adding/removing hook definitions across event keys +- Add validation (at least one event must be selected) +- Handle "delete hook" across all event keys + +**Testable Outcome:** A hook can respond to multiple events, with proper YAML structure. + +### Phase 4: UX Refinements + +- Add "Unsaved changes" indicator +- Add "Reload required" notification after edits +- Add inline validation errors +- Add tooltips explaining each event/matcher's purpose + +--- + +## Files to Modify + +### Backend (src/) + +| File | Changes | +| --------------------------------------- | ------------------------------ | +| `core/webview/webviewMessageHandler.ts` | Add `hooksUpdateHook` case | +| `services/hooks/HookConfigWriter.ts` | New file - YAML writing logic | +| `services/hooks/index.ts` | Export new service | +| `services/hooks/types.ts` | Add `HookUpdateData` interface | + +### Frontend (webview-ui/) + +| File | Changes | +| --------------------------------------------- | ---------------------------------------- | +| `components/settings/HooksSettings.tsx` | Replace text display with new components | +| `components/settings/HookEventSelector.tsx` | New component | +| `components/settings/HookMatcherSelector.tsx` | New component | +| `components/settings/HookTimeoutSelector.tsx` | New component | +| `i18n/locales/en/settings.json` | Add new translation strings | +| `types.ts` | Add `HookUpdateMessage` type | + +--- + +## Risk Assessment + +### High Risk + +1. **YAML Structure Changes**: Moving hooks between event keys could corrupt files if not handled carefully + + - Mitigation: Always read-modify-write with validation + - Backup original file before first write (optional) + +2. **Concurrent Edits**: User editing file while UI modifies it + - Mitigation: Warn on "Reload" if local changes detected + - Consider file watching for external changes + +### Medium Risk + +3. **Multiple Hook Entries**: Same ID in multiple event keys + + - Mitigation: Detect and handle gracefully in UI + - Show warning in UI when detected + +4. **Custom Matcher Parsing**: Extracting groups from arbitrary regex + - Mitigation: Use simple substring matching for known groups + - Fall back to "Custom" when pattern doesn't match known groups + +### Low Risk + +5. **Dropdown Localization**: Time display in user locale + - Store internally as seconds, display as localized string + - Use standard i18n approach + +--- + +## Open Questions + +1. **Should matcher groups be editable?** The prompt implies read-only checkboxes, but users might want to add custom patterns. Should we allow adding new groups? + + - **Recommendation**: No, keep groups fixed to documented tool categories for simplicity. + +2. **Should event selection support "all events" or "all blocking events"?** + + - **Recommendation**: No, explicit selection is clearer. Power users can edit YAML directly. + +3. **How to handle hooks in JSON format vs YAML?** + - **Recommendation**: Both formats should be supported. Use `parseYAML` which handles JSON too. + +--- + +## Success Criteria + +1. ✅ Event selector shows 12 checkboxes, allows multi-selection +2. ✅ Matcher selector shows 6 tool group checkboxes + custom input +3. ✅ Timeout selector shows dropdown with 8 preset options +4. ✅ Changes to any field update the underlying YAML file +5. ✅ Hook can respond to multiple events (multiple YAML entries) +6. ✅ UI shows "Reload required" after configuration changes +7. ✅ All existing functionality (delete, toggle, view logs) still works diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 177d0b3e5ab..51a9fb1f095 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -1194,8 +1194,8 @@ importers: specifier: ^11.1.0 version: 11.1.0 lucide-react: - specifier: ^0.518.0 - version: 0.518.0(react@18.3.1) + specifier: ^0.562.0 + version: 0.562.0(react@18.3.1) mermaid: specifier: ^11.4.1 version: 11.10.0 @@ -1602,6 +1602,10 @@ packages: resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==} engines: {node: '>=6.9.0'} + '@babel/code-frame@7.28.6': + resolution: {integrity: sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==} + engines: {node: '>=6.9.0'} + '@babel/compat-data@7.27.2': resolution: {integrity: sha512-TUtMJYRPyUb/9aU8f3K0mjmjf6M9N5Woshn2CS6nqJSeJtTtQcpLUXjGt9vbF8ZGff0El99sWkLgzwW3VXnxZQ==} engines: {node: '>=6.9.0'} @@ -1640,6 +1644,10 @@ packages: resolution: {integrity: sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==} engines: {node: '>=6.9.0'} + '@babel/helper-validator-identifier@7.28.5': + resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==} + engines: {node: '>=6.9.0'} + '@babel/helper-validator-option@7.27.1': resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==} engines: {node: '>=6.9.0'} @@ -1681,6 +1689,10 @@ packages: resolution: {integrity: sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==} engines: {node: '>=6.9.0'} + '@babel/runtime@7.28.6': + resolution: {integrity: sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==} + engines: {node: '>=6.9.0'} + '@babel/template@7.27.2': resolution: {integrity: sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==} engines: {node: '>=6.9.0'} @@ -4273,6 +4285,9 @@ packages: '@types/node@20.17.57': resolution: {integrity: sha512-f3T4y6VU4fVQDKVqJV4Uppy8c1p/sVvS3peyqxyWnzkqXFJLRU7Y1Bl7rMS1Qe9z0v4M6McY0Fp9yBsgHJUsWQ==} + '@types/node@20.19.30': + resolution: {integrity: sha512-WJtwWJu7UdlvzEAUm484QNg5eAoq5QR08KDNx7g45Usrs2NtOPiX8ugDqmKdXkyL03rBqU5dYNYVQetEpBHq2g==} + '@types/node@24.2.1': resolution: {integrity: sha512-DRh5K+ka5eJic8CjH7td8QpYEV6Zo10gfRkjHCO3weqZHWDtAaSTFtl4+VMqOJ4N5jcuhZ9/l+yy8rVgw7BQeQ==} @@ -7685,6 +7700,11 @@ packages: peerDependencies: react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0 + lucide-react@0.562.0: + resolution: {integrity: sha512-82hOAu7y0dbVuFfmO4bYF1XEwYk/mEbM5E+b1jgci/udUBEE/R7LF5Ip0CCEmXe8AybRM8L+04eP+LGZeDvkiw==} + peerDependencies: + react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0 + lz-string@1.5.0: resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==} hasBin: true @@ -9995,6 +10015,9 @@ packages: undici-types@6.19.8: resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==} + undici-types@6.21.0: + resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==} + undici-types@7.10.0: resolution: {integrity: sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==} @@ -10520,6 +10543,18 @@ packages: utf-8-validate: optional: true + ws@8.19.0: + resolution: {integrity: sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + xml-name-validator@5.0.0: resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==} engines: {node: '>=18'} @@ -11355,6 +11390,12 @@ snapshots: js-tokens: 4.0.0 picocolors: 1.1.1 + '@babel/code-frame@7.28.6': + dependencies: + '@babel/helper-validator-identifier': 7.28.5 + js-tokens: 4.0.0 + picocolors: 1.1.1 + '@babel/compat-data@7.27.2': {} '@babel/core@7.27.1': @@ -11415,6 +11456,8 @@ snapshots: '@babel/helper-validator-identifier@7.27.1': {} + '@babel/helper-validator-identifier@7.28.5': {} + '@babel/helper-validator-option@7.27.1': {} '@babel/helpers@7.27.1': @@ -11444,6 +11487,8 @@ snapshots: '@babel/runtime@7.28.4': {} + '@babel/runtime@7.28.6': {} + '@babel/template@7.27.2': dependencies: '@babel/code-frame': 7.27.1 @@ -12110,7 +12155,7 @@ snapshots: '@libsql/isomorphic-ws@0.1.5': dependencies: '@types/ws': 8.18.1 - ws: 8.18.3 + ws: 8.19.0 transitivePeerDependencies: - bufferutil - utf-8-validate @@ -13910,8 +13955,8 @@ snapshots: '@testing-library/dom@10.4.0': dependencies: - '@babel/code-frame': 7.27.1 - '@babel/runtime': 7.28.4 + '@babel/code-frame': 7.28.6 + '@babel/runtime': 7.28.6 '@types/aria-query': 5.0.4 aria-query: 5.3.0 chalk: 4.1.2 @@ -14212,6 +14257,11 @@ snapshots: dependencies: undici-types: 6.19.8 + '@types/node@20.19.30': + dependencies: + undici-types: 6.21.0 + optional: true + '@types/node@24.2.1': dependencies: undici-types: 7.10.0 @@ -14285,7 +14335,7 @@ snapshots: '@types/ws@8.18.1': dependencies: - '@types/node': 24.2.1 + '@types/node': 20.19.30 optional: true '@types/yargs-parser@21.0.3': {} @@ -14464,7 +14514,7 @@ snapshots: sirv: 3.0.1 tinyglobby: 0.2.14 tinyrainbow: 2.0.0 - vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.2.1)(@vitest/ui@3.2.4)(jiti@2.4.2)(jsdom@26.1.0)(lightningcss@1.30.1)(tsx@4.19.4)(yaml@2.8.0) + vitest: 3.2.4(@types/debug@4.1.12)(@types/node@20.17.57)(@vitest/ui@3.2.4)(jiti@2.4.2)(jsdom@26.1.0)(lightningcss@1.30.1)(tsx@4.19.4)(yaml@2.8.0) '@vitest/utils@3.2.4': dependencies: @@ -18007,6 +18057,10 @@ snapshots: dependencies: react: 18.3.1 + lucide-react@0.562.0(react@18.3.1): + dependencies: + react: 18.3.1 + lz-string@1.5.0: {} macos-release@3.3.0: {} @@ -20861,6 +20915,9 @@ snapshots: undici-types@6.19.8: {} + undici-types@6.21.0: + optional: true + undici-types@7.10.0: {} undici@6.21.3: {} @@ -21576,6 +21633,9 @@ snapshots: ws@8.18.3: {} + ws@8.19.0: + optional: true + xml-name-validator@5.0.0: {} xml2js@0.5.0: diff --git a/src/core/assistant-message/__tests__/presentAssistantMessage-custom-tool.spec.ts b/src/core/assistant-message/__tests__/presentAssistantMessage-custom-tool.spec.ts index e90646fd9a4..df45532096c 100644 --- a/src/core/assistant-message/__tests__/presentAssistantMessage-custom-tool.spec.ts +++ b/src/core/assistant-message/__tests__/presentAssistantMessage-custom-tool.spec.ts @@ -52,6 +52,7 @@ describe("presentAssistantMessage - Custom Tool Recording", () => { diffEnabled: false, consecutiveMistakeCount: 0, clineMessages: [], + cwd: "/mock/project/path", api: { getModel: () => ({ id: "test-model", info: {} }), }, @@ -63,6 +64,26 @@ describe("presentAssistantMessage - Custom Tool Recording", () => { toolRepetitionDetector: { check: vi.fn().mockReturnValue({ allowExecution: true }), }, + toolExecutionHooks: { + executePreToolUse: vi.fn().mockResolvedValue({ + proceed: true, + hookResult: { + results: [], + blocked: false, + totalDuration: 0, + }, + }), + executePostToolUse: vi.fn().mockResolvedValue({ + results: [], + blocked: false, + totalDuration: 0, + }), + executePostToolUseFailure: vi.fn().mockResolvedValue({ + results: [], + blocked: false, + totalDuration: 0, + }), + }, providerRef: { deref: () => ({ getState: vi.fn().mockResolvedValue({ diff --git a/src/core/assistant-message/__tests__/presentAssistantMessage-hooks.spec.ts b/src/core/assistant-message/__tests__/presentAssistantMessage-hooks.spec.ts new file mode 100644 index 00000000000..dad5259c79f --- /dev/null +++ b/src/core/assistant-message/__tests__/presentAssistantMessage-hooks.spec.ts @@ -0,0 +1,257 @@ +// npx vitest src/core/assistant-message/__tests__/presentAssistantMessage-hooks.spec.ts + +import { describe, it, expect, beforeEach, vi } from "vitest" + +// Mock dependencies that are noisy / unrelated to these tests +vi.mock("../../task/Task") +vi.mock("../../tools/validateToolUse", () => ({ + validateToolUse: vi.fn(), +})) +vi.mock("@roo-code/telemetry", () => ({ + TelemetryService: { + instance: { + captureToolUsage: vi.fn(), + captureConsecutiveMistakeError: vi.fn(), + captureException: vi.fn(), + }, + }, +})) + +// Mock a tool that uses askApproval so we can exercise the PermissionRequest integration. +vi.mock("../../tools/ListFilesTool", () => ({ + listFilesTool: { + handle: vi.fn(async (_task: any, block: any, callbacks: any) => { + // Allow tests to trigger a failure path without real side effects. + if (block?.params?.path === "FAIL") { + await callbacks.handleError("listing files", new Error("boom")) + return + } + + const didApprove = await callbacks.askApproval("tool", `list_files:${String(block?.params?.path ?? "")}`) + if (!didApprove) { + return + } + callbacks.pushToolResult("ok") + }), + }, +})) + +let presentAssistantMessage: (task: any) => Promise + +describe("presentAssistantMessage - hooks integration", () => { + let mockTask: any + + beforeEach(async () => { + if (!presentAssistantMessage) { + ;({ presentAssistantMessage } = await import("../presentAssistantMessage")) + } + + mockTask = { + taskId: "test-task-id", + instanceId: "test-instance", + cwd: "/project", + abort: false, + presentAssistantMessageLocked: false, + presentAssistantMessageHasPendingUpdates: false, + currentStreamingContentIndex: 0, + assistantMessageContent: [], + userMessageContent: [], + didCompleteReadingStream: false, + didRejectTool: false, + didAlreadyUseTool: false, + diffEnabled: false, + consecutiveMistakeCount: 0, + api: { + getModel: () => ({ id: "test-model", info: {} }), + }, + browserSession: { + closeBrowser: vi.fn().mockResolvedValue(undefined), + }, + recordToolUsage: vi.fn(), + toolRepetitionDetector: { + check: vi.fn().mockReturnValue({ allowExecution: true }), + }, + toolExecutionHooks: { + executePermissionRequest: vi.fn().mockResolvedValue({ proceed: true, hookResult: {} }), + executePreToolUse: vi.fn().mockResolvedValue({ proceed: true, hookResult: {} }), + executePostToolUse: vi.fn().mockResolvedValue({ results: [], blocked: false, totalDuration: 0 }), + executePostToolUseFailure: vi.fn().mockResolvedValue({ results: [], blocked: false, totalDuration: 0 }), + }, + providerRef: { + deref: () => ({ + getState: vi.fn().mockResolvedValue({ + mode: "code", + customModes: [], + }), + }), + }, + say: vi.fn().mockResolvedValue(undefined), + // ask() is called by presentAssistantMessage via askApproval + ask: vi.fn().mockResolvedValue({ response: "yesButtonClicked" }), + } + + mockTask.pushToolResultToUserContent = vi.fn().mockImplementation((toolResult: any) => { + const existingResult = mockTask.userMessageContent.find( + (block: any) => block.type === "tool_result" && block.tool_use_id === toolResult.tool_use_id, + ) + if (existingResult) { + return false + } + mockTask.userMessageContent.push(toolResult) + return true + }) + }) + + it("PreToolUse can block execution", async () => { + const toolCallId = "tool_call_block" + mockTask.assistantMessageContent = [ + { + type: "tool_use", + id: toolCallId, + name: "list_files", + params: { path: "." }, + }, + ] + + mockTask.toolExecutionHooks.executePreToolUse.mockResolvedValue({ + proceed: false, + blockReason: "nope", + hookResult: { results: [], blocked: true, totalDuration: 1 }, + }) + + await presentAssistantMessage(mockTask) + + expect(mockTask.toolExecutionHooks.executePreToolUse).toHaveBeenCalledTimes(1) + // Should not even attempt to show approval prompt + expect(mockTask.toolExecutionHooks.executePermissionRequest).not.toHaveBeenCalled() + // Should emit a tool_result (native protocol) with the denial message + const toolResult = mockTask.userMessageContent.find( + (item: any) => item.type === "tool_result" && item.tool_use_id === toolCallId, + ) + expect(toolResult).toBeDefined() + expect(toolResult.content).toContain("nope") + }) + + it("PreToolUse can modify tool input", async () => { + const toolCallId = "tool_call_modify" + mockTask.assistantMessageContent = [ + { + type: "tool_use", + id: toolCallId, + name: "list_files", + params: { path: "original" }, + }, + ] + + mockTask.toolExecutionHooks.executePreToolUse.mockResolvedValue({ + proceed: true, + modifiedInput: { path: "modified" }, + hookResult: { results: [], blocked: false, totalDuration: 1 }, + }) + + let askedPartialMessage: string | undefined + mockTask.ask = vi.fn().mockImplementation(async (_type: string, partialMessage?: string) => { + askedPartialMessage = partialMessage + return { response: "yesButtonClicked" } + }) + + await presentAssistantMessage(mockTask) + + expect(mockTask.toolExecutionHooks.executePreToolUse).toHaveBeenCalledTimes(1) + // list_files should invoke askApproval via our mock; its message should contain the modified path. + expect(askedPartialMessage).toContain("modified") + }) + + it("PostToolUse is invoked on success", async () => { + const toolCallId = "tool_call_post_success" + mockTask.assistantMessageContent = [ + { + type: "tool_use", + id: toolCallId, + name: "list_files", + params: { path: "." }, + }, + ] + + mockTask.ask = vi.fn().mockResolvedValue({ response: "yesButtonClicked" }) + + await presentAssistantMessage(mockTask) + + expect(mockTask.toolExecutionHooks.executePostToolUse).toHaveBeenCalledTimes(1) + expect(mockTask.toolExecutionHooks.executePostToolUseFailure).not.toHaveBeenCalled() + }) + + it("PostToolUseFailure is invoked on tool failure", async () => { + const toolCallId = "tool_call_post_failure" + mockTask.assistantMessageContent = [ + { + type: "tool_use", + id: toolCallId, + name: "list_files", + params: { path: "FAIL" }, + }, + ] + + await presentAssistantMessage(mockTask) + + expect(mockTask.toolExecutionHooks.executePostToolUseFailure).toHaveBeenCalledTimes(1) + }) + + it("PermissionRequest hook runs before approval prompt", async () => { + const toolCallId = "tool_call_permission_request" + mockTask.assistantMessageContent = [ + { + type: "tool_use", + id: toolCallId, + name: "list_files", + params: { path: "." }, + }, + ] + + const calls: string[] = [] + + mockTask.toolExecutionHooks.executePermissionRequest = vi.fn().mockImplementation(async () => { + calls.push("permission") + return { proceed: true, hookResult: {} } + }) + + mockTask.ask = vi.fn().mockImplementation(async () => { + calls.push("ask") + return { response: "yesButtonClicked" } + }) + + await presentAssistantMessage(mockTask) + + expect(calls[0]).toBe("permission") + expect(calls[1]).toBe("ask") + }) + + it("PermissionRequest hook can block showing approval prompt", async () => { + const toolCallId = "tool_call_permission_block" + mockTask.assistantMessageContent = [ + { + type: "tool_use", + id: toolCallId, + name: "list_files", + params: { path: "." }, + }, + ] + + mockTask.toolExecutionHooks.executePermissionRequest = vi.fn().mockResolvedValue({ + proceed: false, + blockReason: "blocked by policy", + hookResult: { results: [], blocked: true, totalDuration: 1 }, + }) + + await presentAssistantMessage(mockTask) + + // ask() should never be called if hook blocks the permission prompt + expect(mockTask.ask).not.toHaveBeenCalled() + + const toolResult = mockTask.userMessageContent.find( + (item: any) => item.type === "tool_result" && item.tool_use_id === toolCallId, + ) + expect(toolResult).toBeDefined() + expect(toolResult.content).toContain("blocked by policy") + }) +}) diff --git a/src/core/assistant-message/__tests__/presentAssistantMessage-images.spec.ts b/src/core/assistant-message/__tests__/presentAssistantMessage-images.spec.ts index 72ee4306097..6c41dc801ac 100644 --- a/src/core/assistant-message/__tests__/presentAssistantMessage-images.spec.ts +++ b/src/core/assistant-message/__tests__/presentAssistantMessage-images.spec.ts @@ -28,6 +28,7 @@ describe("presentAssistantMessage - Image Handling in Native Tool Calls", () => mockTask = { taskId: "test-task-id", instanceId: "test-instance", + cwd: "/project", abort: false, presentAssistantMessageLocked: false, presentAssistantMessageHasPendingUpdates: false, @@ -49,6 +50,12 @@ describe("presentAssistantMessage - Image Handling in Native Tool Calls", () => toolRepetitionDetector: { check: vi.fn().mockReturnValue({ allowExecution: true }), }, + toolExecutionHooks: { + executePermissionRequest: vi.fn().mockResolvedValue({ proceed: true, hookResult: {} }), + executePreToolUse: vi.fn().mockResolvedValue({ proceed: true, hookResult: {} }), + executePostToolUse: vi.fn().mockResolvedValue({ results: [], blocked: false, totalDuration: 0 }), + executePostToolUseFailure: vi.fn().mockResolvedValue({ results: [], blocked: false, totalDuration: 0 }), + }, providerRef: { deref: () => ({ getState: vi.fn().mockResolvedValue({ diff --git a/src/core/assistant-message/__tests__/presentAssistantMessage-unknown-tool.spec.ts b/src/core/assistant-message/__tests__/presentAssistantMessage-unknown-tool.spec.ts index d4ae2764a05..fe8314dbe28 100644 --- a/src/core/assistant-message/__tests__/presentAssistantMessage-unknown-tool.spec.ts +++ b/src/core/assistant-message/__tests__/presentAssistantMessage-unknown-tool.spec.ts @@ -37,6 +37,7 @@ describe("presentAssistantMessage - Unknown Tool Handling", () => { diffEnabled: false, consecutiveMistakeCount: 0, clineMessages: [], + cwd: "/mock/project/path", api: { getModel: () => ({ id: "test-model", info: {} }), }, @@ -48,6 +49,26 @@ describe("presentAssistantMessage - Unknown Tool Handling", () => { toolRepetitionDetector: { check: vi.fn().mockReturnValue({ allowExecution: true }), }, + toolExecutionHooks: { + executePreToolUse: vi.fn().mockResolvedValue({ + proceed: true, + hookResult: { + results: [], + blocked: false, + totalDuration: 0, + }, + }), + executePostToolUse: vi.fn().mockResolvedValue({ + results: [], + blocked: false, + totalDuration: 0, + }), + executePostToolUseFailure: vi.fn().mockResolvedValue({ + results: [], + blocked: false, + totalDuration: 0, + }), + }, providerRef: { deref: () => ({ getState: vi.fn().mockResolvedValue({ diff --git a/src/core/assistant-message/presentAssistantMessage.ts b/src/core/assistant-message/presentAssistantMessage.ts index 693327a022e..ca22dddfb3e 100644 --- a/src/core/assistant-message/presentAssistantMessage.ts +++ b/src/core/assistant-message/presentAssistantMessage.ts @@ -376,6 +376,25 @@ export async function presentAssistantMessage(cline: Task) { const state = await cline.providerRef.deref()?.getState() const { mode, customModes, experiments: stateExperiments } = state ?? {} + const buildToolExecutionHookContext = (toolName: string, toolInput: Record) => { + const projectDirectory = cline.cwd + const projectName = projectDirectory.split(/[/\\]/).filter(Boolean).pop() ?? projectDirectory + + return { + toolName, + toolInput, + session: { + taskId: cline.taskId, + sessionId: cline.instanceId, + mode: mode ?? defaultModeSlug, + }, + project: { + directory: projectDirectory, + name: projectName, + }, + } + } + const toolDescription = (): string => { switch (block.name) { case "execute_command": @@ -509,6 +528,7 @@ export async function presentAssistantMessage(cline: Task) { // Track if we've already pushed a tool result for this tool call (native protocol only) let hasToolResult = false + let toolOutputForHooks: ToolResponse | undefined // Determine protocol by checking if this tool call has an ID. // Native protocol tool calls ALWAYS have an ID (set when parsed from tool_call chunks). @@ -524,6 +544,13 @@ export async function presentAssistantMessage(cline: Task) { let approvalFeedback: { text: string; images?: string[] } | undefined const pushToolResult = (content: ToolResponse) => { + // Capture the final tool output for PostToolUse hooks. + // Note: This captures the first tool_result emitted by the tool. + // Tools generally emit a single tool result; if a tool emits multiple, we only retain the first. + if (toolOutputForHooks === undefined) { + toolOutputForHooks = content + } + if (toolProtocol === TOOL_PROTOCOL.NATIVE) { // For native protocol, only allow ONE tool_result per tool call if (hasToolResult) { @@ -638,12 +665,41 @@ export async function presentAssistantMessage(cline: Task) { // allow multiple tool calls in sequence (don't set didAlreadyUseTool) } + let toolDeniedByHook = false + let toolDeniedByUser = false + let toolExecutionHadFailure = false + let toolFailureAction: string | undefined + let toolFailureMessage: string | undefined + let toolInputForHooks = (block.nativeArgs ?? block.params ?? {}) as Record + let blockToExecute: any = block + const askApproval = async ( type: ClineAsk, partialMessage?: string, progressStatus?: ToolProgressStatus, isProtected?: boolean, ) => { + // Hooks: PermissionRequest (blocking) + // This hook is invoked immediately before the user approval prompt is shown. + // It must NOT bypass existing approval rules (it can only deny). + if (!block.partial && !toolDeniedByHook) { + const permissionRequest = await cline.toolExecutionHooks.executePermissionRequest( + buildToolExecutionHookContext(blockToExecute.name, toolInputForHooks), + ) + + if (!permissionRequest.proceed) { + toolDeniedByHook = true + pushToolResult( + formatResponse.toolDeniedWithFeedback( + permissionRequest.blockReason ?? "Blocked by PermissionRequest hook", + toolProtocol, + ), + ) + cline.didRejectTool = true + return false + } + } + const { response, text, images } = await cline.ask( type, partialMessage, @@ -654,6 +710,7 @@ export async function presentAssistantMessage(cline: Task) { if (response !== "yesButtonClicked") { // Handle both messageResponse and noButtonClicked with text. + toolDeniedByUser = true if (text) { await cline.say("user_feedback", text, images) pushToolResult( @@ -696,6 +753,9 @@ export async function presentAssistantMessage(cline: Task) { return } const errorString = `Error ${action}: ${JSON.stringify(serializeError(error))}` + toolExecutionHadFailure = true + toolFailureAction = action + toolFailureMessage = error.message ?? errorString await cline.say( "error", @@ -869,10 +929,39 @@ export async function presentAssistantMessage(cline: Task) { } } - switch (block.name) { + // Hooks: PreToolUse (blocking / may modify tool input) + if (!block.partial) { + const pre = await cline.toolExecutionHooks.executePreToolUse( + buildToolExecutionHookContext(blockToExecute.name, toolInputForHooks), + ) + + if (!pre.proceed) { + pushToolResult( + formatResponse.toolDeniedWithFeedback( + pre.blockReason ?? "Blocked by PreToolUse hook", + toolProtocol, + ), + ) + cline.didRejectTool = true + break + } + + if (pre.modifiedInput) { + toolInputForHooks = pre.modifiedInput + blockToExecute = { + ...block, + params: pre.modifiedInput, + nativeArgs: block.nativeArgs ? pre.modifiedInput : undefined, + } + } + } + + const toolExecutionStart = Date.now() + + switch (blockToExecute.name) { case "write_to_file": await checkpointSaveAndMark(cline) - await writeToFileTool.handle(cline, block as ToolUse<"write_to_file">, { + await writeToFileTool.handle(cline, blockToExecute as ToolUse<"write_to_file">, { askApproval, handleError, pushToolResult, @@ -881,7 +970,7 @@ export async function presentAssistantMessage(cline: Task) { }) break case "update_todo_list": - await updateTodoListTool.handle(cline, block as ToolUse<"update_todo_list">, { + await updateTodoListTool.handle(cline, blockToExecute as ToolUse<"update_todo_list">, { askApproval, handleError, pushToolResult, @@ -895,7 +984,7 @@ export async function presentAssistantMessage(cline: Task) { // Check if this tool call came from native protocol by checking for ID // Native calls always have IDs, XML calls never do if (toolProtocol === TOOL_PROTOCOL.NATIVE) { - await applyDiffToolClass.handle(cline, block as ToolUse<"apply_diff">, { + await applyDiffToolClass.handle(cline, blockToExecute as ToolUse<"apply_diff">, { askApproval, handleError, pushToolResult, @@ -918,9 +1007,16 @@ export async function presentAssistantMessage(cline: Task) { } if (isMultiFileApplyDiffEnabled) { - await applyDiffTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await applyDiffTool( + cline, + blockToExecute, + askApproval, + handleError, + pushToolResult, + removeClosingTag, + ) } else { - await applyDiffToolClass.handle(cline, block as ToolUse<"apply_diff">, { + await applyDiffToolClass.handle(cline, blockToExecute as ToolUse<"apply_diff">, { askApproval, handleError, pushToolResult, @@ -932,7 +1028,7 @@ export async function presentAssistantMessage(cline: Task) { } case "search_and_replace": await checkpointSaveAndMark(cline) - await searchAndReplaceTool.handle(cline, block as ToolUse<"search_and_replace">, { + await searchAndReplaceTool.handle(cline, blockToExecute as ToolUse<"search_and_replace">, { askApproval, handleError, pushToolResult, @@ -942,7 +1038,7 @@ export async function presentAssistantMessage(cline: Task) { break case "search_replace": await checkpointSaveAndMark(cline) - await searchReplaceTool.handle(cline, block as ToolUse<"search_replace">, { + await searchReplaceTool.handle(cline, blockToExecute as ToolUse<"search_replace">, { askApproval, handleError, pushToolResult, @@ -952,7 +1048,7 @@ export async function presentAssistantMessage(cline: Task) { break case "edit_file": await checkpointSaveAndMark(cline) - await editFileTool.handle(cline, block as ToolUse<"edit_file">, { + await editFileTool.handle(cline, blockToExecute as ToolUse<"edit_file">, { askApproval, handleError, pushToolResult, @@ -962,7 +1058,7 @@ export async function presentAssistantMessage(cline: Task) { break case "apply_patch": await checkpointSaveAndMark(cline) - await applyPatchTool.handle(cline, block as ToolUse<"apply_patch">, { + await applyPatchTool.handle(cline, blockToExecute as ToolUse<"apply_patch">, { askApproval, handleError, pushToolResult, @@ -972,7 +1068,7 @@ export async function presentAssistantMessage(cline: Task) { break case "read_file": // Type assertion is safe here because we're in the "read_file" case - await readFileTool.handle(cline, block as ToolUse<"read_file">, { + await readFileTool.handle(cline, blockToExecute as ToolUse<"read_file">, { askApproval, handleError, pushToolResult, @@ -981,7 +1077,7 @@ export async function presentAssistantMessage(cline: Task) { }) break case "fetch_instructions": - await fetchInstructionsTool.handle(cline, block as ToolUse<"fetch_instructions">, { + await fetchInstructionsTool.handle(cline, blockToExecute as ToolUse<"fetch_instructions">, { askApproval, handleError, pushToolResult, @@ -990,7 +1086,7 @@ export async function presentAssistantMessage(cline: Task) { }) break case "list_files": - await listFilesTool.handle(cline, block as ToolUse<"list_files">, { + await listFilesTool.handle(cline, blockToExecute as ToolUse<"list_files">, { askApproval, handleError, pushToolResult, @@ -999,7 +1095,7 @@ export async function presentAssistantMessage(cline: Task) { }) break case "codebase_search": - await codebaseSearchTool.handle(cline, block as ToolUse<"codebase_search">, { + await codebaseSearchTool.handle(cline, blockToExecute as ToolUse<"codebase_search">, { askApproval, handleError, pushToolResult, @@ -1008,7 +1104,7 @@ export async function presentAssistantMessage(cline: Task) { }) break case "search_files": - await searchFilesTool.handle(cline, block as ToolUse<"search_files">, { + await searchFilesTool.handle(cline, blockToExecute as ToolUse<"search_files">, { askApproval, handleError, pushToolResult, @@ -1019,7 +1115,7 @@ export async function presentAssistantMessage(cline: Task) { case "browser_action": await browserActionTool( cline, - block as ToolUse<"browser_action">, + blockToExecute as ToolUse<"browser_action">, askApproval, handleError, pushToolResult, @@ -1027,7 +1123,7 @@ export async function presentAssistantMessage(cline: Task) { ) break case "execute_command": - await executeCommandTool.handle(cline, block as ToolUse<"execute_command">, { + await executeCommandTool.handle(cline, blockToExecute as ToolUse<"execute_command">, { askApproval, handleError, pushToolResult, @@ -1036,7 +1132,7 @@ export async function presentAssistantMessage(cline: Task) { }) break case "use_mcp_tool": - await useMcpToolTool.handle(cline, block as ToolUse<"use_mcp_tool">, { + await useMcpToolTool.handle(cline, blockToExecute as ToolUse<"use_mcp_tool">, { askApproval, handleError, pushToolResult, @@ -1045,7 +1141,7 @@ export async function presentAssistantMessage(cline: Task) { }) break case "access_mcp_resource": - await accessMcpResourceTool.handle(cline, block as ToolUse<"access_mcp_resource">, { + await accessMcpResourceTool.handle(cline, blockToExecute as ToolUse<"access_mcp_resource">, { askApproval, handleError, pushToolResult, @@ -1054,7 +1150,7 @@ export async function presentAssistantMessage(cline: Task) { }) break case "ask_followup_question": - await askFollowupQuestionTool.handle(cline, block as ToolUse<"ask_followup_question">, { + await askFollowupQuestionTool.handle(cline, blockToExecute as ToolUse<"ask_followup_question">, { askApproval, handleError, pushToolResult, @@ -1063,7 +1159,7 @@ export async function presentAssistantMessage(cline: Task) { }) break case "switch_mode": - await switchModeTool.handle(cline, block as ToolUse<"switch_mode">, { + await switchModeTool.handle(cline, blockToExecute as ToolUse<"switch_mode">, { askApproval, handleError, pushToolResult, @@ -1072,13 +1168,13 @@ export async function presentAssistantMessage(cline: Task) { }) break case "new_task": - await newTaskTool.handle(cline, block as ToolUse<"new_task">, { + await newTaskTool.handle(cline, blockToExecute as ToolUse<"new_task">, { askApproval, handleError, pushToolResult, removeClosingTag, toolProtocol, - toolCallId: block.id, + toolCallId: blockToExecute.id, }) break case "attempt_completion": { @@ -1093,13 +1189,13 @@ export async function presentAssistantMessage(cline: Task) { } await attemptCompletionTool.handle( cline, - block as ToolUse<"attempt_completion">, + blockToExecute as ToolUse<"attempt_completion">, completionCallbacks, ) break } case "run_slash_command": - await runSlashCommandTool.handle(cline, block as ToolUse<"run_slash_command">, { + await runSlashCommandTool.handle(cline, blockToExecute as ToolUse<"run_slash_command">, { askApproval, handleError, pushToolResult, @@ -1109,7 +1205,7 @@ export async function presentAssistantMessage(cline: Task) { break case "generate_image": await checkpointSaveAndMark(cline) - await generateImageTool.handle(cline, block as ToolUse<"generate_image">, { + await generateImageTool.handle(cline, blockToExecute as ToolUse<"generate_image">, { askApproval, handleError, pushToolResult, @@ -1128,7 +1224,9 @@ export async function presentAssistantMessage(cline: Task) { break } - const customTool = stateExperiments?.customTools ? customToolRegistry.get(block.name) : undefined + const customTool = stateExperiments?.customTools + ? customToolRegistry.get(blockToExecute.name) + : undefined if (customTool) { try { @@ -1138,7 +1236,7 @@ export async function presentAssistantMessage(cline: Task) { try { customToolArgs = customTool.parameters.parse(block.nativeArgs || block.params || {}) } catch (parseParamsError) { - const message = `Custom tool "${block.name}" argument validation failed: ${parseParamsError.message}` + const message = `Custom tool "${blockToExecute.name}" argument validation failed: ${parseParamsError.message}` console.error(message) cline.consecutiveMistakeCount++ await cline.say("error", message) @@ -1162,17 +1260,17 @@ export async function presentAssistantMessage(cline: Task) { cline.consecutiveMistakeCount++ // Record custom tool error with static name cline.recordToolError("custom_tool", executionError.message) - await handleError(`executing custom tool "${block.name}"`, executionError) + await handleError(`executing custom tool "${blockToExecute.name}"`, executionError) } break } // Not a custom tool - handle as unknown tool error - const errorMessage = `Unknown tool "${block.name}". This tool does not exist. Please use one of the available tools.` + const errorMessage = `Unknown tool "${blockToExecute.name}". This tool does not exist. Please use one of the available tools.` cline.consecutiveMistakeCount++ - cline.recordToolError(block.name as ToolName, errorMessage) - await cline.say("error", t("tools:unknownToolError", { toolName: block.name })) + cline.recordToolError(blockToExecute.name as ToolName, errorMessage) + await cline.say("error", t("tools:unknownToolError", { toolName: blockToExecute.name })) // Push tool_result directly for native protocol WITHOUT setting didAlreadyUseTool // This prevents the stream from being interrupted with "Response interrupted by tool use result" if (toolProtocol === TOOL_PROTOCOL.NATIVE && toolCallId) { @@ -1189,6 +1287,30 @@ export async function presentAssistantMessage(cline: Task) { } } + // Hooks: PostToolUse / PostToolUseFailure (non-blocking) + if (!block.partial && !toolDeniedByHook && !toolDeniedByUser) { + const duration = Date.now() - toolExecutionStart + const finalToolInput = (blockToExecute.nativeArgs ?? blockToExecute.params ?? {}) as Record< + string, + unknown + > + const hookContext = buildToolExecutionHookContext(blockToExecute.name, finalToolInput) + + if (toolExecutionHadFailure) { + void cline.toolExecutionHooks + .executePostToolUseFailure( + hookContext, + toolFailureAction ?? "tool_error", + toolFailureMessage ?? "Tool execution failed", + ) + .catch(() => {}) + } else { + void cline.toolExecutionHooks + .executePostToolUse(hookContext, toolOutputForHooks, duration) + .catch(() => {}) + } + } + break } } diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index af7aed86d58..0402162f67c 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -81,6 +81,7 @@ import { BrowserSession } from "../../services/browser/BrowserSession" import { McpHub } from "../../services/mcp/McpHub" import { McpServerManager } from "../../services/mcp/McpServerManager" import { RepoPerTaskCheckpointService } from "../../services/checkpoints" +import { ToolExecutionHooks, createToolExecutionHooks } from "../../services/hooks" // integrations import { DiffViewProvider } from "../../integrations/editor/DiffViewProvider" @@ -334,6 +335,9 @@ export class Task extends EventEmitter implements TaskLike { // Computer User browserSession: BrowserSession + // Hooks + toolExecutionHooks: ToolExecutionHooks + // Editing diffViewProvider: DiffViewProvider diffStrategy?: DiffStrategy @@ -535,6 +539,21 @@ export class Task extends EventEmitter implements TaskLike { } } }) + + // Initialize tool execution hooks + this.toolExecutionHooks = createToolExecutionHooks( + provider.getHookManager() ?? null, + (status) => provider.postHookStatusToWebview(status), + async (type, text) => { + await this.say(type as ClineSay, text) + }, + // Getter for global hooksEnabled state + () => { + // Default to true if hooksEnabled is undefined (backwards compatibility) + return provider.contextProxy.getValue("hooksEnabled") ?? true + }, + ) + this.diffEnabled = enableDiff this.fuzzyMatchThreshold = fuzzyMatchThreshold this.consecutiveMistakeLimit = consecutiveMistakeLimit ?? DEFAULT_CONSECUTIVE_MISTAKE_LIMIT diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 33fa12ca78c..749112113b0 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -75,6 +75,7 @@ import { CodeIndexManager } from "../../services/code-index/manager" import type { IndexProgressUpdate } from "../../services/code-index/interfaces/manager" import { MdmService } from "../../services/mdm/MdmService" import { SkillsManager } from "../../services/skills/SkillsManager" +import { HookManager, createHookManager, type IHookManager } from "../../services/hooks" import { fileExistsAtPath } from "../../utils/fs" import { setTtsEnabled, setTtsSpeed } from "../../utils/tts" @@ -142,6 +143,10 @@ export class ClineProvider private _workspaceTracker?: WorkspaceTracker // workSpaceTracker read-only for access outside this class protected mcpHub?: McpHub // Change from private to protected protected skillsManager?: SkillsManager + protected hookManager?: IHookManager + private hookFileWatchers: vscode.FileSystemWatcher[] = [] + private hookReloadTimeout?: NodeJS.Timeout + private static readonly HOOK_RELOAD_DEBOUNCE_MS = 500 private marketplaceManager: MarketplaceManager private mdmService?: MdmService private taskCreationCallback: (task: Task) => void @@ -208,6 +213,11 @@ export class ClineProvider this.log(`Failed to initialize Skills Manager: ${error}`) }) + // Initialize Hook Manager for lifecycle hooks + this.initializeHookManager().catch((error) => { + this.log(`Failed to initialize Hook Manager: ${error}`) + }) + this.marketplaceManager = new MarketplaceManager(this.context, this.customModesManager) // Forward task events to the provider. @@ -616,6 +626,7 @@ export class ClineProvider this.mcpHub = undefined await this.skillsManager?.dispose() this.skillsManager = undefined + this.disposeHookManager() this.marketplaceManager?.cleanup() this.customModesManager?.dispose() this.log("Disposed all disposables") @@ -1979,6 +1990,7 @@ export class ClineProvider fuzzyMatchThreshold, mcpEnabled, enableMcpServerCreation, + hooksEnabled, currentApiConfigName, listApiConfigMeta, pinnedApiConfigs, @@ -2123,6 +2135,7 @@ export class ClineProvider fuzzyMatchThreshold: fuzzyMatchThreshold ?? 1.0, mcpEnabled: mcpEnabled ?? true, enableMcpServerCreation: enableMcpServerCreation ?? true, + hooksEnabled: hooksEnabled ?? true, currentApiConfigName: currentApiConfigName ?? "default", listApiConfigMeta: listApiConfigMeta ?? [], pinnedApiConfigs: pinnedApiConfigs ?? {}, @@ -2217,6 +2230,64 @@ export class ClineProvider } })(), debug: vscode.workspace.getConfiguration(Package.name).get("debug", false), + + // Hooks state for settings tab + hooks: this.getHooksStateForWebview(), + } + } + + /** + * Build hooks state for webview from HookManager. + * Converts internal types to serializable HooksState. + */ + private getHooksStateForWebview(): ExtensionState["hooks"] { + if (!this.hookManager) { + return undefined + } + + const snapshot = this.hookManager.getConfigSnapshot() + const executionHistory = this.hookManager.getHookExecutionHistory() + + // Build a list of *all* known hooks (including currently disabled ones) + // so the webview can show per-hook toggles and a global "Enable Hooks" toggle. + const allHooks = snapshot + ? Array.from(snapshot.hooksByEvent.values()).reduce((acc, hooks) => acc.concat(hooks), [] as any[]) + : [] + + // Convert ResolvedHook[] to HookInfo[] + const hookInfos = allHooks.map((hook) => ({ + id: hook.id, + filePath: hook.filePath, + event: hook.event, + matcher: hook.matcher, + commandPreview: hook.command, + enabled: (hook.enabled ?? true) && !(snapshot?.disabledHookIds?.has(hook.id) ?? false), + source: hook.source, + timeout: hook.timeout ?? 60, + shell: hook.shell, + description: hook.description, + })) + + // Convert HookExecution[] to HookExecutionRecord[] + // Limit to last 50 records for UI + const executionRecords = executionHistory.slice(-50).map((exec) => ({ + timestamp: exec.timestamp.toISOString(), + hookId: exec.hook.id, + event: exec.event, + toolName: exec.result.hook.matcher ? undefined : undefined, // Tool name is in context, not easily accessible here + exitCode: exec.result.exitCode, + duration: exec.result.duration, + timedOut: exec.result.timedOut, + blocked: exec.result.exitCode === 2, + error: exec.result.error?.message, + blockMessage: exec.result.exitCode === 2 ? exec.result.stderr : undefined, + })) + + return { + enabledHooks: hookInfos, + executionHistory: executionRecords, + hasProjectHooks: snapshot?.hasProjectHooks ?? false, + snapshotTimestamp: snapshot?.loadedAt?.toISOString(), } } @@ -2385,6 +2456,7 @@ export class ClineProvider language: stateValues.language ?? formatLanguage(vscode.env.language), mcpEnabled: stateValues.mcpEnabled ?? true, enableMcpServerCreation: stateValues.enableMcpServerCreation ?? true, + hooksEnabled: stateValues.hooksEnabled ?? true, mcpServers: this.mcpHub?.getAllServers() ?? [], currentApiConfigName: stateValues.currentApiConfigName ?? "default", listApiConfigMeta: stateValues.listApiConfigMeta ?? [], @@ -2582,6 +2654,197 @@ export class ClineProvider return this.mcpHub } + /** + * Initialize the Hook Manager for lifecycle hooks. + * This loads hooks configuration from project/.roo/hooks/ files. + * Only initializes if the hooks experiment is enabled. + * Sets up file watchers for automatic config reloading. + */ + public async initializeHookManager(): Promise { + const cwd = this.currentWorkspacePath || getWorkspacePath() + if (!cwd) { + this.log("[HookManager] No workspace path available, hooks disabled") + return + } + + try { + const state = await this.getState() + + this.hookManager = createHookManager({ + cwd, + mode: state?.mode, + logger: { + debug: (msg: string) => this.log(`[Hooks/debug] ${msg}`), + info: (msg: string) => this.log(`[Hooks/info] ${msg}`), + warn: (msg: string) => this.log(`[Hooks/warn] ${msg}`), + error: (msg: string) => this.log(`[Hooks/error] ${msg}`), + }, + }) + + // Load hooks configuration + await this.hookManager.loadHooksConfig() + this.log("[HookManager] Hooks loaded successfully") + + // Set up file watchers for hook configuration files + this.setupHookFileWatchers(cwd, state?.mode) + + // Notify webview of hook state + await this.postStateToWebview() + } catch (error) { + this.log( + `[HookManager] Failed to initialize hooks: ${error instanceof Error ? error.message : String(error)}`, + ) + // Don't throw - hooks are optional + this.hookManager = undefined + } + } + + /** + * Set up file watchers for hook configuration files. + * Watches .roo/hooks/, ~/.roo/hooks/, and mode-specific directories. + */ + private setupHookFileWatchers(cwd: string, mode?: string): void { + // Clean up any existing watchers first + this.disposeHookFileWatchers() + + const watchPatterns: string[] = [] + + // Project hooks: .roo/hooks/*.{json,yaml,yml} + const projectHooksPattern = new vscode.RelativePattern( + vscode.Uri.file(path.join(cwd, ".roo", "hooks")), + "*.{json,yaml,yml}", + ) + watchPatterns.push(".roo/hooks/*.{json,yaml,yml}") + + // Mode-specific hooks: .roo/hooks-{mode}/*.{json,yaml,yml} + let modeHooksPattern: vscode.RelativePattern | undefined + if (mode) { + modeHooksPattern = new vscode.RelativePattern( + vscode.Uri.file(path.join(cwd, ".roo", `hooks-${mode}`)), + "*.{json,yaml,yml}", + ) + watchPatterns.push(`.roo/hooks-${mode}/*.{json,yaml,yml}`) + } + + // Global hooks: ~/.roo/hooks/*.{json,yaml,yml} + const globalHooksPattern = new vscode.RelativePattern( + vscode.Uri.file(path.join(os.homedir(), ".roo", "hooks")), + "*.{json,yaml,yml}", + ) + watchPatterns.push("~/.roo/hooks/*.{json,yaml,yml}") + + this.log(`[HookManager] Setting up file watchers for: ${watchPatterns.join(", ")}`) + + // Create debounced reload handler + const debouncedReload = () => { + if (this.hookReloadTimeout) { + clearTimeout(this.hookReloadTimeout) + } + this.hookReloadTimeout = setTimeout(async () => { + this.log("[HookManager] Config file changed, reloading hooks...") + await this.reloadHooksConfig() + await this.postStateToWebview() + }, ClineProvider.HOOK_RELOAD_DEBOUNCE_MS) + } + + // Create watchers for each pattern + const projectWatcher = vscode.workspace.createFileSystemWatcher(projectHooksPattern) + projectWatcher.onDidCreate(debouncedReload) + projectWatcher.onDidChange(debouncedReload) + projectWatcher.onDidDelete(debouncedReload) + this.hookFileWatchers.push(projectWatcher) + + if (modeHooksPattern) { + const modeWatcher = vscode.workspace.createFileSystemWatcher(modeHooksPattern) + modeWatcher.onDidCreate(debouncedReload) + modeWatcher.onDidChange(debouncedReload) + modeWatcher.onDidDelete(debouncedReload) + this.hookFileWatchers.push(modeWatcher) + } + + const globalWatcher = vscode.workspace.createFileSystemWatcher(globalHooksPattern) + globalWatcher.onDidCreate(debouncedReload) + globalWatcher.onDidChange(debouncedReload) + globalWatcher.onDidDelete(debouncedReload) + this.hookFileWatchers.push(globalWatcher) + + this.log(`[HookManager] File watchers set up successfully (${this.hookFileWatchers.length} watchers)`) + } + + /** + * Dispose hook file watchers. + */ + private disposeHookFileWatchers(): void { + if (this.hookReloadTimeout) { + clearTimeout(this.hookReloadTimeout) + this.hookReloadTimeout = undefined + } + + for (const watcher of this.hookFileWatchers) { + watcher.dispose() + } + this.hookFileWatchers = [] + } + + /** + * Dispose the Hook Manager and clean up resources. + * Called when hooks experiment is disabled. + */ + public disposeHookManager(): void { + this.log("[HookManager] Disposing hook manager...") + + // Dispose file watchers + this.disposeHookFileWatchers() + + // Clear the hook manager reference + this.hookManager = undefined + + this.log("[HookManager] Hook manager disposed") + } + + /** + * Get the Hook Manager instance. + */ + public getHookManager(): IHookManager | undefined { + return this.hookManager + } + + /** + * Reload the Hook Manager configuration. + * Call this when hooks configuration files may have changed. + */ + public async reloadHooksConfig(): Promise { + if (this.hookManager) { + try { + await this.hookManager.reloadHooksConfig() + this.log("[HookManager] Hooks reloaded successfully") + } catch (error) { + this.log( + `[HookManager] Failed to reload hooks: ${error instanceof Error ? error.message : String(error)}`, + ) + } + } + } + + /** + * Post hook execution status to webview. + */ + public postHookStatusToWebview(status: { + status: "running" | "completed" | "failed" | "blocked" + event: string + toolName?: string + hookId?: string + duration?: number + error?: string + blockMessage?: string + modified?: boolean + }): void { + this.postMessageToWebview({ + type: "hookExecutionStatus", + hookExecutionStatus: status, + }) + } + public getSkillsManager(): SkillsManager | undefined { return this.skillsManager } diff --git a/src/core/webview/__tests__/ClineProvider.hooks-dynamic-init.spec.ts b/src/core/webview/__tests__/ClineProvider.hooks-dynamic-init.spec.ts new file mode 100644 index 00000000000..6c25b154778 --- /dev/null +++ b/src/core/webview/__tests__/ClineProvider.hooks-dynamic-init.spec.ts @@ -0,0 +1,350 @@ +// npx vitest run core/webview/__tests__/ClineProvider.hooks-dynamic-init.spec.ts + +import type { IHookManager } from "../../../services/hooks/types" + +// Mock vscode before importing ClineProvider +vi.mock("vscode", () => { + const mockFileSystemWatcher = { + onDidCreate: vi.fn().mockReturnValue({ dispose: vi.fn() }), + onDidChange: vi.fn().mockReturnValue({ dispose: vi.fn() }), + onDidDelete: vi.fn().mockReturnValue({ dispose: vi.fn() }), + dispose: vi.fn(), + } + + return { + window: { + showInformationMessage: vi.fn(), + showErrorMessage: vi.fn(), + showTextDocument: vi.fn().mockResolvedValue(undefined), + createWebviewPanel: vi.fn(), + }, + workspace: { + workspaceFolders: [{ uri: { fsPath: "/mock/workspace" } }], + openTextDocument: vi.fn().mockResolvedValue({ uri: { fsPath: "/mock/file" } }), + createFileSystemWatcher: vi.fn().mockReturnValue(mockFileSystemWatcher), + getConfiguration: vi.fn().mockReturnValue({ + get: vi.fn(), + update: vi.fn(), + }), + }, + commands: { + executeCommand: vi.fn().mockResolvedValue(undefined), + }, + Uri: { + file: vi.fn((path: string) => ({ fsPath: path })), + joinPath: vi.fn((_base: { fsPath: string }, ...segments: string[]) => ({ + fsPath: `${_base.fsPath}/${segments.join("/")}`, + })), + }, + RelativePattern: vi.fn().mockImplementation((_base: unknown, _pattern: string) => ({ _base, _pattern })), + EventEmitter: vi.fn().mockImplementation(() => ({ + event: vi.fn(), + fire: vi.fn(), + dispose: vi.fn(), + })), + ConfigurationTarget: { + Global: 1, + Workspace: 2, + }, + ViewColumn: { + One: 1, + }, + } +}) + +vi.mock("fs/promises", () => ({ + default: { + mkdir: vi.fn().mockResolvedValue(undefined), + readFile: vi.fn().mockResolvedValue(""), + writeFile: vi.fn().mockResolvedValue(undefined), + access: vi.fn().mockResolvedValue(undefined), + readdir: vi.fn().mockResolvedValue([]), + }, + mkdir: vi.fn().mockResolvedValue(undefined), + readFile: vi.fn().mockResolvedValue(""), + writeFile: vi.fn().mockResolvedValue(undefined), + access: vi.fn().mockResolvedValue(undefined), + readdir: vi.fn().mockResolvedValue([]), +})) + +vi.mock("os", () => ({ + default: { + homedir: vi.fn().mockReturnValue("/mock/home"), + }, + homedir: vi.fn().mockReturnValue("/mock/home"), +})) + +vi.mock("../../../services/hooks", () => ({ + createHookManager: vi.fn().mockImplementation(() => createMockHookManager()), +})) + +vi.mock("../../../utils/path", () => ({ + getWorkspacePath: vi.fn().mockReturnValue("/mock/workspace"), +})) + +import * as vscode from "vscode" +import { createHookManager } from "../../../services/hooks" + +// Create mock HookManager +const createMockHookManager = (): IHookManager => ({ + loadHooksConfig: vi.fn().mockResolvedValue({ + hooksByEvent: new Map(), + hooksById: new Map(), + loadedAt: new Date(), + disabledHookIds: new Set(), + hasProjectHooks: false, + }), + reloadHooksConfig: vi.fn().mockResolvedValue(undefined), + getEnabledHooks: vi.fn().mockReturnValue([]), + executeHooks: vi.fn().mockResolvedValue({ + results: [], + blocked: false, + totalDuration: 0, + }), + setHookEnabled: vi.fn().mockResolvedValue(undefined), + updateHook: vi.fn().mockResolvedValue(undefined), + getHookExecutionHistory: vi.fn().mockReturnValue([]), + getConfigSnapshot: vi.fn().mockReturnValue({ + hooksByEvent: new Map(), + hooksById: new Map(), + loadedAt: new Date(), + disabledHookIds: new Set(), + hasProjectHooks: false, + }), +}) + +describe("ClineProvider - Hook Dynamic Initialization", () => { + let mockHookManager: IHookManager + + beforeEach(() => { + vi.clearAllMocks() + mockHookManager = createMockHookManager() + vi.mocked(createHookManager).mockReturnValue(mockHookManager) + vi.mocked(vscode.workspace.createFileSystemWatcher).mockClear() + }) + + describe("initializeHookManager", () => { + it("should always initialize hook manager (hooks is a core feature)", async () => { + // Create a mock provider-like object to test the logic + const cwd = "/mock/workspace" + const state = { mode: "code" } + + // Hooks are always initialized - no experiment check needed + const newHookManager = createHookManager({ + cwd, + mode: state.mode, + logger: { + debug: vi.fn(), + info: vi.fn(), + warn: vi.fn(), + error: vi.fn(), + }, + }) + + await newHookManager.loadHooksConfig() + + expect(createHookManager).toHaveBeenCalledWith({ + cwd, + mode: state.mode, + logger: expect.any(Object), + }) + expect(newHookManager.loadHooksConfig).toHaveBeenCalled() + }) + + it("should set up file watchers for hook configuration files", async () => { + const cwd = "/mock/workspace" + const mode = "code" + + // Simulate setupHookFileWatchers + // Project hooks pattern + const projectPattern = new vscode.RelativePattern(vscode.Uri.file(`${cwd}/.roo/hooks`), "*.{json,yaml,yml}") + + // Mode-specific hooks pattern + const modePattern = new vscode.RelativePattern( + vscode.Uri.file(`${cwd}/.roo/hooks-${mode}`), + "*.{json,yaml,yml}", + ) + + // Global hooks pattern + const globalPattern = new vscode.RelativePattern( + vscode.Uri.file("/mock/home/.roo/hooks"), + "*.{json,yaml,yml}", + ) + + // Create watchers + vscode.workspace.createFileSystemWatcher(projectPattern) + vscode.workspace.createFileSystemWatcher(modePattern) + vscode.workspace.createFileSystemWatcher(globalPattern) + + expect(vscode.workspace.createFileSystemWatcher).toHaveBeenCalledTimes(3) + expect(vscode.RelativePattern).toHaveBeenCalledWith(expect.any(Object), "*.{json,yaml,yml}") + }) + + it("should register change event handlers on file watchers", async () => { + const watcher = vscode.workspace.createFileSystemWatcher({} as vscode.GlobPattern) + + watcher.onDidCreate(vi.fn()) + watcher.onDidChange(vi.fn()) + watcher.onDidDelete(vi.fn()) + + expect(watcher.onDidCreate).toHaveBeenCalled() + expect(watcher.onDidChange).toHaveBeenCalled() + expect(watcher.onDidDelete).toHaveBeenCalled() + }) + }) + + describe("disposeHookManager", () => { + it("should dispose all file watchers", () => { + const hookFileWatchers: { dispose: ReturnType }[] = [ + { dispose: vi.fn() }, + { dispose: vi.fn() }, + { dispose: vi.fn() }, + ] + + // Simulate disposeHookFileWatchers + for (const watcher of hookFileWatchers) { + watcher.dispose() + } + + expect(hookFileWatchers[0].dispose).toHaveBeenCalled() + expect(hookFileWatchers[1].dispose).toHaveBeenCalled() + expect(hookFileWatchers[2].dispose).toHaveBeenCalled() + }) + + it("should clear the hook manager reference", () => { + let hookManager: IHookManager | undefined = createMockHookManager() + + // Simulate disposeHookManager + hookManager = undefined + + expect(hookManager).toBeUndefined() + }) + + it("should clear pending reload timeout", () => { + vi.useFakeTimers() + + let hookReloadTimeout: NodeJS.Timeout | undefined = setTimeout(() => {}, 500) + + // Simulate clearing timeout in disposeHookFileWatchers + if (hookReloadTimeout) { + clearTimeout(hookReloadTimeout) + hookReloadTimeout = undefined + } + + expect(hookReloadTimeout).toBeUndefined() + + vi.useRealTimers() + }) + }) + + describe("debounced reload", () => { + it("should debounce multiple file change events", async () => { + vi.useFakeTimers() + + const HOOK_RELOAD_DEBOUNCE_MS = 500 + const mockReload = vi.fn() + let hookReloadTimeout: NodeJS.Timeout | undefined + + // Simulate debounced reload function + const debouncedReload = () => { + if (hookReloadTimeout) { + clearTimeout(hookReloadTimeout) + } + hookReloadTimeout = setTimeout(async () => { + await mockReload() + }, HOOK_RELOAD_DEBOUNCE_MS) + } + + // Trigger multiple change events rapidly + debouncedReload() + debouncedReload() + debouncedReload() + + // Should not have called reload yet + expect(mockReload).not.toHaveBeenCalled() + + // Advance time by debounce duration + await vi.advanceTimersByTimeAsync(HOOK_RELOAD_DEBOUNCE_MS) + + // Should have called reload exactly once + expect(mockReload).toHaveBeenCalledTimes(1) + + vi.useRealTimers() + }) + + it("should reset debounce timer on each new change event", async () => { + vi.useFakeTimers() + + const HOOK_RELOAD_DEBOUNCE_MS = 500 + const mockReload = vi.fn() + let hookReloadTimeout: NodeJS.Timeout | undefined + + const debouncedReload = () => { + if (hookReloadTimeout) { + clearTimeout(hookReloadTimeout) + } + hookReloadTimeout = setTimeout(async () => { + await mockReload() + }, HOOK_RELOAD_DEBOUNCE_MS) + } + + // First change + debouncedReload() + + // Advance time partially + await vi.advanceTimersByTimeAsync(300) + + // Second change should reset the timer + debouncedReload() + + // Advance time by original debounce (should not trigger because timer was reset) + await vi.advanceTimersByTimeAsync(300) + expect(mockReload).not.toHaveBeenCalled() + + // Advance remaining time + await vi.advanceTimersByTimeAsync(200) + expect(mockReload).toHaveBeenCalledTimes(1) + + vi.useRealTimers() + }) + }) +}) + +describe("File Watcher Patterns", () => { + it("should watch project hooks directory with correct pattern", () => { + const cwd = "/test/workspace" + const expectedPath = `${cwd}/.roo/hooks` + const expectedPattern = "*.{json,yaml,yml}" + + new vscode.RelativePattern(vscode.Uri.file(expectedPath), expectedPattern) + + expect(vscode.Uri.file).toHaveBeenCalledWith(expectedPath) + expect(vscode.RelativePattern).toHaveBeenCalledWith(expect.any(Object), expectedPattern) + }) + + it("should watch mode-specific hooks directory when mode is provided", () => { + const cwd = "/test/workspace" + const mode = "architect" + const expectedPath = `${cwd}/.roo/hooks-${mode}` + + new vscode.RelativePattern(vscode.Uri.file(expectedPath), "*.{json,yaml,yml}") + + expect(vscode.Uri.file).toHaveBeenCalledWith(expectedPath) + }) + + it("should watch global hooks directory", () => { + const homedir = "/mock/home" + const expectedPath = `${homedir}/.roo/hooks` + + new vscode.RelativePattern(vscode.Uri.file(expectedPath), "*.{json,yaml,yml}") + + expect(vscode.Uri.file).toHaveBeenCalledWith(expectedPath) + }) + + it("should support json, yaml, and yml file extensions", () => { + const expectedPattern = "*.{json,yaml,yml}" + new vscode.RelativePattern(vscode.Uri.file("/any/path"), expectedPattern) + + expect(vscode.RelativePattern).toHaveBeenCalledWith(expect.any(Object), expectedPattern) + }) +}) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index ff186892f2e..a9305c47c6a 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -561,6 +561,7 @@ describe("ClineProvider", () => { fuzzyMatchThreshold: 1.0, mcpEnabled: true, enableMcpServerCreation: false, + hooksEnabled: true, mode: defaultModeSlug, customModes: [], experiments: experimentDefault, diff --git a/src/core/webview/__tests__/webviewMessageHandler.hooks.spec.ts b/src/core/webview/__tests__/webviewMessageHandler.hooks.spec.ts new file mode 100644 index 00000000000..aaa0200e21a --- /dev/null +++ b/src/core/webview/__tests__/webviewMessageHandler.hooks.spec.ts @@ -0,0 +1,577 @@ +// npx vitest run core/webview/__tests__/webviewMessageHandler.hooks.spec.ts + +import type { IHookManager, ResolvedHook, HookExecution, HooksConfigSnapshot } from "../../../services/hooks/types" + +// Mock vscode before importing webviewMessageHandler +vi.mock("vscode", () => { + const executeCommand = vi.fn().mockResolvedValue(undefined) + const showInformationMessage = vi.fn() + const showErrorMessage = vi.fn() + const showTextDocument = vi.fn().mockResolvedValue(undefined) + const openTextDocument = vi.fn().mockResolvedValue({ uri: { fsPath: "/mock/file" } }) + + return { + window: { + showInformationMessage, + showErrorMessage, + showTextDocument, + }, + workspace: { + workspaceFolders: [{ uri: { fsPath: "/mock/workspace" } }], + openTextDocument, + }, + commands: { + executeCommand, + }, + Uri: { + file: vi.fn((path: string) => ({ fsPath: path })), + }, + } +}) + +vi.mock("fs/promises", () => { + const mockMkdir = vi.fn().mockResolvedValue(undefined) + const mockReadFile = vi.fn().mockResolvedValue("") + const mockWriteFile = vi.fn().mockResolvedValue(undefined) + const mockAccess = vi.fn().mockResolvedValue(undefined) + const mockRename = vi.fn().mockResolvedValue(undefined) + const mockUnlink = vi.fn().mockResolvedValue(undefined) + const mockReaddir = vi.fn().mockResolvedValue([]) + + return { + default: { + mkdir: mockMkdir, + readFile: mockReadFile, + writeFile: mockWriteFile, + access: mockAccess, + rename: mockRename, + unlink: mockUnlink, + readdir: mockReaddir, + }, + mkdir: mockMkdir, + readFile: mockReadFile, + writeFile: mockWriteFile, + access: mockAccess, + rename: mockRename, + unlink: mockUnlink, + readdir: mockReaddir, + } +}) + +vi.mock("../../../utils/fs", () => ({ + fileExistsAtPath: vi.fn().mockResolvedValue(true), +})) + +vi.mock("../../../utils/safeWriteJson", () => ({ + safeWriteJson: vi.fn().mockResolvedValue(undefined), +})) + +vi.mock("../../../utils/safeWriteText", () => ({ + safeWriteText: vi.fn().mockResolvedValue(undefined), +})) + +vi.mock("../../../api/providers/fetchers/modelCache") + +import * as vscode from "vscode" +import * as fs from "fs/promises" +import * as fsUtils from "../../../utils/fs" +import { safeWriteJson } from "../../../utils/safeWriteJson" +import { webviewMessageHandler } from "../webviewMessageHandler" +import type { ClineProvider } from "../ClineProvider" + +// Create mock HookManager +const createMockHookManager = (): IHookManager => ({ + loadHooksConfig: vi.fn().mockResolvedValue({ + hooksByEvent: new Map(), + hooksById: new Map(), + loadedAt: new Date(), + disabledHookIds: new Set(), + hasProjectHooks: false, + }), + reloadHooksConfig: vi.fn().mockResolvedValue(undefined), + getEnabledHooks: vi.fn().mockReturnValue([]), + executeHooks: vi.fn().mockResolvedValue({ + results: [], + blocked: false, + totalDuration: 0, + }), + setHookEnabled: vi.fn().mockResolvedValue(undefined), + updateHook: vi.fn().mockResolvedValue(undefined), + getHookExecutionHistory: vi.fn().mockReturnValue([]), + getConfigSnapshot: vi.fn().mockReturnValue({ + hooksByEvent: new Map(), + hooksById: new Map(), + loadedAt: new Date(), + disabledHookIds: new Set(), + hasProjectHooks: false, + }), +}) + +// Create mock ClineProvider +const createMockClineProvider = (hookManager?: IHookManager) => { + const mockProvider = { + getState: vi.fn(), + postMessageToWebview: vi.fn(), + postStateToWebview: vi.fn(), + getHookManager: vi.fn().mockReturnValue(hookManager), + log: vi.fn(), + getCurrentTask: vi.fn(), + getTaskWithId: vi.fn(), + createTaskWithHistoryItem: vi.fn(), + cwd: "/mock/workspace", + context: { + extensionPath: "/mock/extension/path", + globalStorageUri: { fsPath: "/mock/global/storage" }, + }, + contextProxy: { + context: { + extensionPath: "/mock/extension/path", + globalStorageUri: { fsPath: "/mock/global/storage" }, + }, + setValue: vi.fn(), + getValue: vi.fn().mockImplementation((key: string) => { + if (key === "experiments") { + return { hooks: true } // Enable hooks experiment for tests + } + return undefined + }), + }, + customModesManager: { + getCustomModes: vi.fn(), + deleteCustomMode: vi.fn(), + }, + } as unknown as ClineProvider + + return mockProvider +} + +describe("webviewMessageHandler - hooks commands", () => { + let mockHookManager: IHookManager + let mockClineProvider: ClineProvider + + beforeEach(() => { + vi.clearAllMocks() + mockHookManager = createMockHookManager() + mockClineProvider = createMockClineProvider(mockHookManager) + }) + + describe("hooksReloadConfig", () => { + it("should call reloadHooksConfig and postStateToWebview when hookManager exists", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksReloadConfig", + }) + + expect(mockHookManager.reloadHooksConfig).toHaveBeenCalledTimes(1) + expect(mockClineProvider.postStateToWebview).toHaveBeenCalledTimes(1) + }) + + it("should not throw when hookManager is undefined", async () => { + const providerWithoutHookManager = createMockClineProvider(undefined) + + await expect( + webviewMessageHandler(providerWithoutHookManager, { + type: "hooksReloadConfig", + }), + ).resolves.not.toThrow() + + expect(providerWithoutHookManager.postStateToWebview).not.toHaveBeenCalled() + }) + + it("should show error message when reloadHooksConfig fails", async () => { + const error = new Error("Failed to load hooks config") + vi.mocked(mockHookManager.reloadHooksConfig).mockRejectedValueOnce(error) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksReloadConfig", + }) + + expect(mockClineProvider.log).toHaveBeenCalledWith( + "Failed to reload hooks config: Failed to load hooks config", + ) + expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to reload hooks configuration") + }) + }) + + describe("hooksSetEnabled", () => { + it("should call setHookEnabled with correct parameters and postStateToWebview", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksSetEnabled", + hookId: "test-hook-id", + hookEnabled: false, + }) + + expect(mockHookManager.setHookEnabled).toHaveBeenCalledWith("test-hook-id", false) + expect(mockClineProvider.postStateToWebview).toHaveBeenCalledTimes(1) + }) + + it("should enable a previously disabled hook", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksSetEnabled", + hookId: "test-hook-id", + hookEnabled: true, + }) + + expect(mockHookManager.setHookEnabled).toHaveBeenCalledWith("test-hook-id", true) + expect(mockClineProvider.postStateToWebview).toHaveBeenCalledTimes(1) + }) + + it("should not call setHookEnabled when hookId is missing", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksSetEnabled", + hookEnabled: true, + } as any) + + expect(mockHookManager.setHookEnabled).not.toHaveBeenCalled() + expect(mockClineProvider.postStateToWebview).not.toHaveBeenCalled() + }) + + it("should not call setHookEnabled when hookEnabled is not a boolean", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksSetEnabled", + hookId: "test-hook-id", + hookEnabled: "true", // string, not boolean + } as any) + + expect(mockHookManager.setHookEnabled).not.toHaveBeenCalled() + expect(mockClineProvider.postStateToWebview).not.toHaveBeenCalled() + }) + + it("should show error message when setHookEnabled fails", async () => { + const error = new Error("Hook not found") + vi.mocked(mockHookManager.setHookEnabled).mockRejectedValueOnce(error) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksSetEnabled", + hookId: "nonexistent-hook", + hookEnabled: true, + }) + + expect(mockClineProvider.log).toHaveBeenCalledWith("Failed to set hook enabled: Hook not found") + expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to enable hook") + }) + + it("should show correct error message when disabling fails", async () => { + const error = new Error("Hook not found") + vi.mocked(mockHookManager.setHookEnabled).mockRejectedValueOnce(error) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksSetEnabled", + hookId: "nonexistent-hook", + hookEnabled: false, + }) + + expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to disable hook") + }) + }) + + describe("hooksSetAllEnabled", () => { + it("should update global hooksEnabled and postStateToWebview", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksSetAllEnabled", + hooksEnabled: false, + }) + + // hooksSetAllEnabled no longer iterates hooks; it toggles global state. + expect(mockHookManager.setHookEnabled).not.toHaveBeenCalled() + expect((mockClineProvider as any).contextProxy.setValue).toHaveBeenCalledWith("hooksEnabled", false) + expect(mockClineProvider.postStateToWebview).toHaveBeenCalledTimes(1) + }) + + it("should not call setHookEnabled when hooksEnabled is not a boolean", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksSetAllEnabled", + hooksEnabled: "false", + } as any) + + expect(mockHookManager.setHookEnabled).not.toHaveBeenCalled() + expect((mockClineProvider as any).contextProxy.setValue).not.toHaveBeenCalled() + expect(mockClineProvider.postStateToWebview).not.toHaveBeenCalled() + }) + + it("should show error message when updating hooksEnabled global state fails", async () => { + vi.mocked((mockClineProvider as any).contextProxy.setValue).mockRejectedValueOnce(new Error("boom")) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksSetAllEnabled", + hooksEnabled: true, + }) + + expect(mockHookManager.setHookEnabled).not.toHaveBeenCalled() + expect(mockClineProvider.postStateToWebview).not.toHaveBeenCalled() + expect(mockClineProvider.log).toHaveBeenCalledWith("Failed to set hooks enabled: boom") + expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to enable hooks") + }) + }) + + describe("hooksOpenConfigFolder", () => { + it("should open project hooks folder by default", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenConfigFolder", + }) + + expect(vscode.Uri.file).toHaveBeenCalledWith("/mock/workspace/.roo/hooks") + expect(vscode.commands.executeCommand).toHaveBeenCalledWith("revealFileInOS", expect.any(Object)) + }) + + it("should open global hooks folder when source is global", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenConfigFolder", + hooksSource: "global", + }) + + expect(vscode.Uri.file).toHaveBeenCalledWith(expect.stringContaining(".roo/hooks")) + expect(vscode.commands.executeCommand).toHaveBeenCalledWith("revealFileInOS", expect.any(Object)) + }) + + it("should open project hooks folder when source is project", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenConfigFolder", + hooksSource: "project", + }) + + expect(vscode.Uri.file).toHaveBeenCalledWith("/mock/workspace/.roo/hooks") + expect(vscode.commands.executeCommand).toHaveBeenCalledWith("revealFileInOS", expect.any(Object)) + }) + + it("should create hooks folder if it does not exist", async () => { + vi.mocked(fsUtils.fileExistsAtPath).mockResolvedValueOnce(false) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenConfigFolder", + }) + + expect(fs.mkdir).toHaveBeenCalledWith("/mock/workspace/.roo/hooks", { recursive: true }) + expect(vscode.commands.executeCommand).toHaveBeenCalledWith("revealFileInOS", expect.any(Object)) + }) + + it("should not create hooks folder if it already exists", async () => { + vi.mocked(fsUtils.fileExistsAtPath).mockResolvedValueOnce(true) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenConfigFolder", + }) + + expect(fs.mkdir).not.toHaveBeenCalled() + expect(vscode.commands.executeCommand).toHaveBeenCalledWith("revealFileInOS", expect.any(Object)) + }) + + it("should show error message when open fails", async () => { + vi.mocked(vscode.commands.executeCommand).mockRejectedValueOnce(new Error("Failed to open folder")) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenConfigFolder", + }) + + expect(mockClineProvider.log).toHaveBeenCalledWith("Failed to open hooks folder: Failed to open folder") + expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to open hooks configuration folder") + }) + }) + + describe("hooksDeleteHook", () => { + it("should delete hook from JSON config file and then reload + post state", async () => { + const hookId = "hook-to-delete" + const hookFilePath = "/mock/workspace/.roo/hooks/hooks.json" + + const hooksById = new Map() + hooksById.set(hookId, { + id: hookId, + event: "PreToolUse" as any, + matcher: ".*", + command: "echo hi", + enabled: true, + source: "project" as any, + timeout: 30, + filePath: hookFilePath, + includeConversationHistory: false, + } as any) + + vi.mocked(mockHookManager.getConfigSnapshot).mockReturnValue({ + hooksByEvent: new Map(), + hooksById, + loadedAt: new Date(), + disabledHookIds: new Set(), + hasProjectHooks: true, + } as HooksConfigSnapshot) + + vi.mocked(fs.readFile).mockResolvedValueOnce( + JSON.stringify({ + version: "1", + hooks: { + PreToolUse: [ + { id: hookId, command: "echo hi" }, + { id: "keep", command: "echo keep" }, + ], + }, + }), + ) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksDeleteHook", + hookId, + } as any) + + expect(safeWriteJson).toHaveBeenCalledWith( + hookFilePath, + expect.objectContaining({ + version: "1", + hooks: { + PreToolUse: [{ id: "keep", command: "echo keep" }], + }, + }), + ) + expect(mockHookManager.reloadHooksConfig).toHaveBeenCalledTimes(1) + expect(mockClineProvider.postStateToWebview).toHaveBeenCalledTimes(1) + }) + + it("should show error and not reload when hook is not found in config file", async () => { + const hookId = "missing-hook" + const hookFilePath = "/mock/workspace/.roo/hooks/hooks.json" + + const hooksById = new Map() + hooksById.set(hookId, { + id: hookId, + event: "PreToolUse" as any, + matcher: ".*", + command: "echo hi", + enabled: true, + source: "project" as any, + timeout: 30, + filePath: hookFilePath, + includeConversationHistory: false, + } as any) + + vi.mocked(mockHookManager.getConfigSnapshot).mockReturnValue({ + hooksByEvent: new Map(), + hooksById, + loadedAt: new Date(), + disabledHookIds: new Set(), + hasProjectHooks: true, + } as HooksConfigSnapshot) + + vi.mocked(fs.readFile).mockResolvedValueOnce( + JSON.stringify({ + version: "1", + hooks: { + PreToolUse: [{ id: "keep", command: "echo keep" }], + }, + }), + ) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksDeleteHook", + hookId, + } as any) + + expect(safeWriteJson).not.toHaveBeenCalled() + expect(mockHookManager.reloadHooksConfig).not.toHaveBeenCalled() + expect(mockClineProvider.postStateToWebview).not.toHaveBeenCalled() + expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to delete hook") + }) + }) + + describe("hooksOpenHookFile", () => { + it("should open hook file in editor when filePath is provided and file exists", async () => { + const hookFilePath = "/mock/workspace/.roo/hooks/hooks.json" + + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenHookFile", + filePath: hookFilePath, + } as any) + + expect(vscode.Uri.file).toHaveBeenCalledWith(hookFilePath) + expect(vscode.workspace.openTextDocument).toHaveBeenCalled() + expect(vscode.window.showTextDocument).toHaveBeenCalled() + }) + + it("should show error message when file does not exist", async () => { + const hookFilePath = "/mock/workspace/.roo/hooks/missing.json" + vi.mocked(fsUtils.fileExistsAtPath).mockResolvedValueOnce(false) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenHookFile", + filePath: hookFilePath, + } as any) + + expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(`Hook file not found: ${hookFilePath}`) + }) + + it("should not attempt to open when filePath is missing", async () => { + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenHookFile", + } as any) + + expect(vscode.workspace.openTextDocument).not.toHaveBeenCalled() + expect(vscode.window.showTextDocument).not.toHaveBeenCalled() + }) + + it("should show error message when open fails", async () => { + const hookFilePath = "/mock/workspace/.roo/hooks/hooks.json" + vi.mocked(vscode.workspace.openTextDocument).mockRejectedValueOnce(new Error("Cannot open file")) + + await webviewMessageHandler(mockClineProvider, { + type: "hooksOpenHookFile", + filePath: hookFilePath, + } as any) + + expect(mockClineProvider.log).toHaveBeenCalledWith(expect.stringContaining("Failed to open hook file")) + expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to open hook configuration file") + }) + }) +}) + +describe("webviewMessageHandler - hooks state integration", () => { + it("should return hooks state when hookManager has data", () => { + const mockResolvedHook: ResolvedHook = { + id: "hook-1", + event: "PreToolUse", + matcher: ".*", + command: "echo 'hello'", + enabled: true, + source: "project", + timeout: 30, + shell: "/bin/bash", + description: "Test hook", + filePath: "/mock/workspace/.roo/hooks/pre-tool-use.json", + includeConversationHistory: false, + } + + const mockExecutionHistory: HookExecution[] = [ + { + timestamp: new Date(1642000000000), + hook: mockResolvedHook, + event: "PreToolUse", + result: { + hook: mockResolvedHook, + exitCode: 0, + stdout: "hello", + stderr: "", + duration: 100, + timedOut: false, + }, + }, + ] + + const mockHookManager = createMockHookManager() + vi.mocked(mockHookManager.getEnabledHooks).mockReturnValue([mockResolvedHook]) + vi.mocked(mockHookManager.getHookExecutionHistory).mockReturnValue(mockExecutionHistory) + + const hooksByEvent = new Map() + hooksByEvent.set("PreToolUse", [mockResolvedHook]) + + const hooksById = new Map() + hooksById.set("hook-1", mockResolvedHook) + + vi.mocked(mockHookManager.getConfigSnapshot).mockReturnValue({ + hooksByEvent, + hooksById, + loadedAt: new Date(1642000000000), + disabledHookIds: new Set(), + hasProjectHooks: true, + }) + + // Verify mock data is correctly formatted + expect(mockHookManager.getEnabledHooks()).toHaveLength(1) + expect(mockHookManager.getHookExecutionHistory()).toHaveLength(1) + expect(mockHookManager.getConfigSnapshot()?.hasProjectHooks).toBe(true) + }) +}) diff --git a/src/core/webview/webviewMessageHandler.ts b/src/core/webview/webviewMessageHandler.ts index e93be3278d2..56c55ada36a 100644 --- a/src/core/webview/webviewMessageHandler.ts +++ b/src/core/webview/webviewMessageHandler.ts @@ -1,7 +1,13 @@ import { safeWriteJson } from "../../utils/safeWriteJson" +import { safeWriteText } from "../../utils/safeWriteText" import * as path from "path" import * as os from "os" import * as fs from "fs/promises" +import { + HookEventType as HookEventTypeSchema, + type HookEventType, + type HookUpdateData, +} from "../../services/hooks/types" import { getRooDirectoriesForCwd } from "../../services/roo-config/index.js" import pWaitFor from "p-wait-for" import * as vscode from "vscode" @@ -38,7 +44,7 @@ import { type RouterName, toRouterName } from "../../shared/api" import { MessageEnhancer } from "./messageEnhancer" import { checkExistKey } from "../../shared/checkExistApiConfig" -import { experimentDefault } from "../../shared/experiments" +import { experimentDefault, experiments, EXPERIMENT_IDS } from "../../shared/experiments" import { Terminal } from "../../integrations/terminal/Terminal" import { openFile } from "../../integrations/misc/open-file" import { openImage, saveImage } from "../../integrations/misc/image-handler" @@ -634,8 +640,9 @@ export const webviewMessageHandler = async ( continue } + const oldExperiments = getGlobalState("experiments") ?? experimentDefault newValue = { - ...(getGlobalState("experiments") ?? experimentDefault), + ...oldExperiments, ...(value as Record), } } else if (key === "customSupportPrompts") { @@ -3336,6 +3343,298 @@ export const webviewMessageHandler = async ( break } + // ===================================================================== + // Hooks Management Commands + // ===================================================================== + + case "hooksReloadConfig": { + // Reload hooks configuration from all sources + const hookManager = provider.getHookManager() + if (hookManager) { + try { + await hookManager.reloadHooksConfig() + await provider.postStateToWebview() + } catch (error) { + provider.log( + `Failed to reload hooks config: ${error instanceof Error ? error.message : String(error)}`, + ) + vscode.window.showErrorMessage("Failed to reload hooks configuration") + } + } + break + } + + case "hooksSetEnabled": { + // Enable or disable a specific hook + const hookManager = provider.getHookManager() + if (hookManager && message.hookId && typeof message.hookEnabled === "boolean") { + try { + await hookManager.setHookEnabled(message.hookId, message.hookEnabled) + await provider.postStateToWebview() + } catch (error) { + provider.log( + `Failed to set hook enabled: ${error instanceof Error ? error.message : String(error)}`, + ) + vscode.window.showErrorMessage(`Failed to ${message.hookEnabled ? "enable" : "disable"} hook`) + } + } + break + } + + case "hooksSetAllEnabled": { + // Enable or disable hooks globally via the master toggle. + // This is stored in global state and checked before executing any hook. + if (typeof message.hooksEnabled === "boolean") { + try { + await updateGlobalState("hooksEnabled", message.hooksEnabled) + await provider.postStateToWebview() + } catch (error) { + provider.log( + `Failed to set hooks enabled: ${error instanceof Error ? error.message : String(error)}`, + ) + vscode.window.showErrorMessage(`Failed to ${message.hooksEnabled ? "enable" : "disable"} hooks`) + } + } + break + } + + case "hooksOpenConfigFolder": { + // Open the hooks configuration folder in VS Code + const source = message.hooksSource ?? "project" + try { + let hooksPath: string + if (source === "global") { + // Global hooks: ~/.roo/hooks + hooksPath = path.join(os.homedir(), ".roo", "hooks") + } else { + // Project hooks: .roo/hooks in workspace + const cwd = provider.cwd + hooksPath = path.join(cwd, ".roo", "hooks") + } + + // Check if directory exists, create if not + const exists = await fileExistsAtPath(hooksPath) + if (!exists) { + await fs.mkdir(hooksPath, { recursive: true }) + } + + // Open the folder in VS Code + const uri = vscode.Uri.file(hooksPath) + await vscode.commands.executeCommand("revealFileInOS", uri) + } catch (error) { + provider.log(`Failed to open hooks folder: ${error instanceof Error ? error.message : String(error)}`) + vscode.window.showErrorMessage("Failed to open hooks configuration folder") + } + break + } + + case "hooksDeleteHook": { + const hookManager = provider.getHookManager() + if (!hookManager || !message.hookId) { + break + } + + try { + const hookId = message.hookId + const snapshot = hookManager.getConfigSnapshot() + const targetHook = snapshot?.hooksById.get(hookId) + // Prefer resolved snapshot filePath (ResolvedHook.filePath) + const targetFilePath = targetHook?.filePath + + const removeHookFromFile = async (filePath: string): Promise => { + const lower = filePath.toLowerCase() + const content = await fs.readFile(filePath, "utf-8") + const parsed = lower.endsWith(".json") + ? JSON.parse(content) + : (await import("yaml")).default.parse(content) + + if (!parsed || typeof parsed !== "object") { + throw new Error(`Invalid hooks config format in ${filePath}`) + } + + const hooks = (parsed as any).hooks + if (!hooks || typeof hooks !== "object") { + return false + } + + let removed = false + for (const [event, defs] of Object.entries(hooks)) { + if (!Array.isArray(defs)) continue + const before = defs.length + const after = defs.filter((d: any) => d?.id !== hookId) + if (after.length !== before) { + removed = true + ;(hooks as any)[event] = after + } + } + + if (!removed) return false + + if (lower.endsWith(".json")) { + await safeWriteJson(filePath, parsed) + } else { + const YAML = (await import("yaml")).default + const newYaml = YAML.stringify(parsed, { lineWidth: 0 }) + await safeWriteText(filePath, newYaml) + } + + return true + } + + let deleted = false + if (typeof targetFilePath === "string" && targetFilePath.length > 0) { + deleted = await removeHookFromFile(targetFilePath) + } else { + // Fallback: scan all loaded roo directories for hook configs and remove matching id. + const cwd = provider.cwd + const rooDirs = getRooDirectoriesForCwd(cwd) + const candidateDirs: string[] = [] + candidateDirs.push(path.join(rooDirs[0], "hooks")) + if (message.hooksSource === "mode") { + const mode = (await provider.getState()).mode + candidateDirs.push(path.join(rooDirs[1], `hooks-${mode}`)) + } + candidateDirs.push(path.join(rooDirs[1], "hooks")) + + for (const dir of candidateDirs) { + let entries: any[] = [] + try { + entries = await fs.readdir(dir, { withFileTypes: true }) + } catch { + continue + } + const files = entries + .filter((e) => e.isFile()) + .map((e) => path.join(dir, e.name)) + .filter((p) => { + const l = p.toLowerCase() + return l.endsWith(".json") || l.endsWith(".yaml") || l.endsWith(".yml") + }) + .sort() + for (const filePath of files) { + if (await removeHookFromFile(filePath)) { + deleted = true + break + } + } + if (deleted) break + } + } + + if (!deleted) { + throw new Error("Hook not found in any loaded config file") + } + + await hookManager.reloadHooksConfig() + await provider.postStateToWebview() + } catch (error) { + provider.log(`Failed to delete hook: ${error instanceof Error ? error.message : String(error)}`) + vscode.window.showErrorMessage("Failed to delete hook") + } + break + } + + case "hooksOpenHookFile": { + const { filePath: hookFilePath } = message + if (!hookFilePath) { + return + } + + try { + const exists = await fileExistsAtPath(hookFilePath) + if (exists) { + // Open the file in the editor + const uri = vscode.Uri.file(hookFilePath) + const doc = await vscode.workspace.openTextDocument(uri) + await vscode.window.showTextDocument(doc) + } else { + vscode.window.showErrorMessage(`Hook file not found: ${hookFilePath}`) + } + } catch (error) { + provider.log(`Failed to open hook file: ${error}`) + vscode.window.showErrorMessage("Failed to open hook configuration file") + } + break + } + + case "hooksUpdateHook": { + const hookManager = provider.getHookManager() + if (!hookManager || !message.hookId || !message.filePath || !message.hookUpdates) { + break + } + + try { + const hookUpdates: HookUpdateData = { + // Webview messages are not strongly typed, so validate and narrow. + events: Array.isArray(message.hookUpdates.events) + ? message.hookUpdates.events.filter( + (event): event is HookEventType => HookEventTypeSchema.safeParse(event).success, + ) + : undefined, + matcher: typeof message.hookUpdates.matcher === "string" ? message.hookUpdates.matcher : undefined, + timeout: typeof message.hookUpdates.timeout === "number" ? message.hookUpdates.timeout : undefined, + } + + await hookManager.updateHook(message.filePath, message.hookId, hookUpdates) + await hookManager.reloadHooksConfig() + await provider.postStateToWebview() + } catch (error) { + provider.log(`Failed to update hook: ${error instanceof Error ? error.message : String(error)}`) + vscode.window.showErrorMessage("Failed to update hook") + } + break + } + + case "hooksCreateNew": { + try { + const cwd = provider.cwd + const hooksPath = path.join(cwd, ".roo", "hooks") + + // Create directory if it doesn't exist + await fs.mkdir(hooksPath, { recursive: true }) + + const exampleFilePath = path.join(hooksPath, "example.yaml") + + // Check if file already exists + const exists = await fileExistsAtPath(exampleFilePath) + if (exists) { + // Open existing file instead of overwriting + const uri = vscode.Uri.file(exampleFilePath) + const doc = await vscode.workspace.openTextDocument(uri) + await vscode.window.showTextDocument(doc) + break + } + + // Create the example hook file + const exampleContent = `version: "1" +hooks: + PreToolUse: + - id: example-hook + matcher: "edit" + enabled: true + command: 'echo "Verification hook triggered"' + timeout: 5 +` + await safeWriteText(exampleFilePath, exampleContent) + + // Open the file in the editor + const uri = vscode.Uri.file(exampleFilePath) + const doc = await vscode.workspace.openTextDocument(uri) + await vscode.window.showTextDocument(doc) + + // Reload hooks config to pick up the new file + const hookManager = provider.getHookManager() + if (hookManager) { + await hookManager.reloadHooksConfig() + await provider.postStateToWebview() + } + } catch (error) { + provider.log(`Failed to create hook file: ${error instanceof Error ? error.message : String(error)}`) + vscode.window.showErrorMessage("Failed to create hook configuration file") + } + break + } + default: { // console.log(`Unhandled message type: ${message.type}`) // diff --git a/src/services/hooks/HookConfigLoader.ts b/src/services/hooks/HookConfigLoader.ts new file mode 100644 index 00000000000..77f11f5f72c --- /dev/null +++ b/src/services/hooks/HookConfigLoader.ts @@ -0,0 +1,362 @@ +/** + * Hook Configuration Loader + * + * Loads and merges hook configurations from: + * 1. Project directory: .roo/hooks/*.yaml or *.json (highest priority) + * 2. Mode-specific: .roo/hooks-{mode}/*.yaml or *.json (middle priority) + * 3. Global directory: ~/.roo/hooks/*.yaml or *.json (lowest priority) + * + * Files within each directory are processed in alphabetical order. + * Same hook ID at higher precedence level overrides lower levels. + */ + +import * as path from "path" +import fs from "fs/promises" +import YAML from "yaml" +import { z } from "zod" +import { + HooksConfigFileSchema, + HooksConfigSnapshot, + HookDefinition, + ResolvedHook, + HookSource, + HookEventType, +} from "./types" +import { getGlobalRooDirectory, getProjectRooDirectoryForCwd } from "../roo-config" + +/** + * Result of loading a single config file. + */ +interface LoadedConfigFile { + filePath: string + source: HookSource + hooks: Map + errors: string[] +} + +/** + * Options for loading hooks configuration. + */ +export interface LoadHooksConfigOptions { + /** Project directory (cwd) */ + cwd: string + + /** Current mode slug (for mode-specific hooks) */ + mode?: string +} + +/** + * Result of loading all hooks configuration. + */ +export interface LoadHooksConfigResult { + snapshot: HooksConfigSnapshot + errors: string[] + warnings: string[] +} + +/** + * Check if a file has a supported extension (.yaml, .yml, .json). + */ +function isSupportedConfigFile(filename: string): boolean { + const lower = filename.toLowerCase() + return lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".json") +} + +/** + * Parse a config file content (YAML or JSON). + */ +function parseConfigContent(content: string, filePath: string): unknown { + const lower = filePath.toLowerCase() + + if (lower.endsWith(".json")) { + return JSON.parse(content) + } + + // Parse as YAML (which also handles plain JSON) + return YAML.parse(content) +} + +/** + * Validate parsed config against the schema. + */ +function validateConfig( + parsed: unknown, + filePath: string, +): { success: true; data: z.infer } | { success: false; errors: string[] } { + const result = HooksConfigFileSchema.safeParse(parsed) + + if (result.success) { + return { success: true, data: result.data } + } + + // Format Zod errors nicely + const errors = result.error.errors.map((err) => { + const pathStr = err.path.length > 0 ? err.path.join(".") : "(root)" + return `${filePath}: ${pathStr}: ${err.message}` + }) + + return { success: false, errors } +} + +/** + * Load a single config file. + */ +async function loadConfigFile(filePath: string, source: HookSource): Promise { + const result: LoadedConfigFile = { + filePath, + source, + hooks: new Map(), + errors: [], + } + + try { + const content = await fs.readFile(filePath, "utf-8") + const parsed = parseConfigContent(content, filePath) + const validated = validateConfig(parsed, filePath) + + if (!validated.success) { + result.errors = validated.errors + return result + } + + // Convert hooks record to Map + const hooksRecord = validated.data.hooks || {} + for (const [eventStr, definitions] of Object.entries(hooksRecord)) { + const event = eventStr as HookEventType + if (definitions && definitions.length > 0) { + result.hooks.set(event, definitions) + } + } + } catch (err) { + if ((err as NodeJS.ErrnoException).code === "ENOENT") { + // File doesn't exist - not an error, just skip + return result + } + + const message = err instanceof Error ? err.message : String(err) + result.errors.push(`${filePath}: Failed to load: ${message}`) + } + + return result +} + +/** + * List config files in a directory (sorted alphabetically). + */ +async function listConfigFiles(dirPath: string): Promise { + try { + const entries = await fs.readdir(dirPath, { withFileTypes: true }) + const files = entries + .filter((entry) => entry.isFile() && isSupportedConfigFile(entry.name)) + .map((entry) => path.join(dirPath, entry.name)) + .sort() // Alphabetical order + + return files + } catch (err) { + if ((err as NodeJS.ErrnoException).code === "ENOENT") { + // Directory doesn't exist - not an error + return [] + } + throw err + } +} + +/** + * Load all config files from a directory. + */ +async function loadConfigDirectory(dirPath: string, source: HookSource): Promise { + const files = await listConfigFiles(dirPath) + const results: LoadedConfigFile[] = [] + + for (const filePath of files) { + const loaded = await loadConfigFile(filePath, source) + results.push(loaded) + } + + return results +} + +/** + * Merge loaded configs into a snapshot, respecting precedence rules. + * + * Precedence (highest to lowest): + * 1. Project hooks (.roo/hooks/) + * 2. Mode-specific hooks (.roo/hooks-{mode}/) + * 3. Global hooks (~/.roo/hooks/) + * + * Within same level: alphabetical file order. + * Same hook ID: higher precedence wins (can also disable with enabled: false). + */ +function mergeConfigs(loadedConfigs: LoadedConfigFile[]): { + hooksByEvent: Map + hooksById: Map + hasProjectHooks: boolean +} { + // Track hooks by ID to detect overrides + const hooksById = new Map() + + // Track hooks by event for efficient lookup + const hooksByEvent = new Map() + + // Track if we have any project hooks (for security warnings) + let hasProjectHooks = false + + // Process configs in reverse precedence order (global -> mode -> project) + // so that later (higher precedence) configs override earlier ones + const orderedConfigs = [...loadedConfigs].sort((a, b) => { + const precedence: Record = { + global: 0, + mode: 1, + project: 2, + } + return precedence[a.source] - precedence[b.source] + }) + + for (const config of orderedConfigs) { + if (config.source === "project" && config.hooks.size > 0) { + hasProjectHooks = true + } + + for (const [event, definitions] of config.hooks) { + for (const def of definitions) { + const resolved: ResolvedHook = { + ...def, + source: config.source, + event, + filePath: config.filePath, + } + + // Check for existing hook with same ID + const existing = hooksById.get(def.id) + if (existing) { + // Remove from its event list + const eventList = hooksByEvent.get(existing.event) + if (eventList) { + const idx = eventList.findIndex((h) => h.id === def.id) + if (idx !== -1) { + eventList.splice(idx, 1) + } + } + } + + // Add/replace in lookup maps + hooksById.set(def.id, resolved) + + // Add to event list + if (!hooksByEvent.has(event)) { + hooksByEvent.set(event, []) + } + hooksByEvent.get(event)!.push(resolved) + } + } + } + + return { hooksByEvent, hooksById, hasProjectHooks } +} + +/** + * Load hooks configuration from all sources. + * + * @param options - Loading options (cwd, mode) + * @returns Loaded configuration snapshot and any errors/warnings + */ +export async function loadHooksConfig(options: LoadHooksConfigOptions): Promise { + const { cwd, mode } = options + const errors: string[] = [] + const warnings: string[] = [] + const loadedConfigs: LoadedConfigFile[] = [] + + // 1. Load global hooks (~/.roo/hooks/) + const globalDir = path.join(getGlobalRooDirectory(), "hooks") + try { + const globalConfigs = await loadConfigDirectory(globalDir, "global") + loadedConfigs.push(...globalConfigs) + for (const config of globalConfigs) { + errors.push(...config.errors) + } + } catch (err) { + const message = err instanceof Error ? err.message : String(err) + warnings.push(`Failed to load global hooks from ${globalDir}: ${message}`) + } + + // 2. Load mode-specific hooks (.roo/hooks-{mode}/) + if (mode) { + const modeDir = path.join(getProjectRooDirectoryForCwd(cwd), `hooks-${mode}`) + try { + const modeConfigs = await loadConfigDirectory(modeDir, "mode") + loadedConfigs.push(...modeConfigs) + for (const config of modeConfigs) { + errors.push(...config.errors) + } + } catch (err) { + const message = err instanceof Error ? err.message : String(err) + warnings.push(`Failed to load mode-specific hooks from ${modeDir}: ${message}`) + } + } + + // 3. Load project hooks (.roo/hooks/) + const projectDir = path.join(getProjectRooDirectoryForCwd(cwd), "hooks") + try { + const projectConfigs = await loadConfigDirectory(projectDir, "project") + loadedConfigs.push(...projectConfigs) + for (const config of projectConfigs) { + errors.push(...config.errors) + } + } catch (err) { + const message = err instanceof Error ? err.message : String(err) + warnings.push(`Failed to load project hooks from ${projectDir}: ${message}`) + } + + // Merge configs with precedence rules + const { hooksByEvent, hooksById, hasProjectHooks } = mergeConfigs(loadedConfigs) + + // Create snapshot + const snapshot: HooksConfigSnapshot = { + hooksByEvent, + hooksById, + loadedAt: new Date(), + disabledHookIds: new Set(), + hasProjectHooks, + } + + // Security warning for project hooks + if (hasProjectHooks) { + warnings.push( + "⚠️ Project hooks are active: This workspace has hooks defined in .roo/hooks/. " + + "These hooks run shell commands when Roo Code performs actions. " + + "Only enable project hooks for repositories you trust.", + ) + } + + return { snapshot, errors, warnings } +} + +/** + * Get hooks for a specific event from a snapshot. + * + * @param snapshot - The config snapshot + * @param event - The event type + * @returns Array of hooks for the event (excluding disabled ones) + */ +export function getHooksForEvent(snapshot: HooksConfigSnapshot, event: HookEventType): ResolvedHook[] { + const hooks = snapshot.hooksByEvent.get(event) || [] + return hooks.filter((hook) => { + // Check if explicitly disabled via setHookEnabled + if (snapshot.disabledHookIds.has(hook.id)) { + return false + } + // Check if disabled in config + return hook.enabled !== false + }) +} + +/** + * Get a specific hook by ID from a snapshot. + * + * @param snapshot - The config snapshot + * @param hookId - The hook ID + * @returns The hook, or undefined if not found + */ +export function getHookById(snapshot: HooksConfigSnapshot, hookId: string): ResolvedHook | undefined { + return snapshot.hooksById.get(hookId) +} diff --git a/src/services/hooks/HookConfigWriter.ts b/src/services/hooks/HookConfigWriter.ts new file mode 100644 index 00000000000..47b05c41c0d --- /dev/null +++ b/src/services/hooks/HookConfigWriter.ts @@ -0,0 +1,127 @@ +import YAML from "yaml" +import { HookUpdateData, HookEventType, HookDefinition } from "./types" +import fs from "fs/promises" +import { safeWriteJson } from "../../utils/safeWriteJson" +import { safeWriteText } from "../../utils/safeWriteText" + +/** + * Update a hook configuration in a YAML/JSON file. + * + * @param filePath - Path to the config file + * @param hookId - ID of the hook to update + * @param updates - Updates to apply + */ +export async function updateHookConfig(filePath: string, hookId: string, updates: HookUpdateData): Promise { + const isJson = filePath.toLowerCase().endsWith(".json") + const content = await fs.readFile(filePath, "utf-8") + + let parsed: any + try { + if (isJson) { + parsed = JSON.parse(content) + } else { + parsed = YAML.parse(content) + } + } catch (e) { + throw new Error(`Failed to parse config file ${filePath}: ${e}`) + } + + if (!parsed || typeof parsed !== "object") { + throw new Error(`Invalid config file format: ${filePath}`) + } + + if (!parsed.hooks) { + parsed.hooks = {} + } + + // Find the hook definition first to ensure it exists and get a template + let templateHook: HookDefinition | undefined + + // Iterate all events to find the hook + for (const eventKey of Object.keys(parsed.hooks)) { + const hooks = parsed.hooks[eventKey] + if (Array.isArray(hooks)) { + const found = hooks.find((h: any) => h.id === hookId) + if (found) { + templateHook = { ...found } + break + } + } + } + + if (!templateHook) { + throw new Error(`Hook with ID '${hookId}' not found in ${filePath}`) + } + + // Apply simple property updates to the template first, so they carry over to new events + if (updates.matcher !== undefined) { + if (updates.matcher === "") { + delete templateHook.matcher + } else { + templateHook.matcher = updates.matcher + } + } + if (updates.timeout !== undefined) { + templateHook.timeout = updates.timeout + } + + // Handle Event Updates + if (updates.events) { + if (updates.events.length === 0) { + throw new Error("Hook must have at least one event") + } + const newEventsSet = new Set(updates.events) + + // 1. Remove hook from events that are NOT in the new set + for (const eventKey of Object.keys(parsed.hooks)) { + const event = eventKey as HookEventType + if (!newEventsSet.has(event)) { + const hooks = parsed.hooks[event] + if (Array.isArray(hooks)) { + parsed.hooks[event] = hooks.filter((h: any) => h?.id !== hookId) + } + } + } + + // 2. Add hook to events that are in the new set + for (const event of updates.events) { + if (!parsed.hooks[event]) { + parsed.hooks[event] = [] + } + const hooks = parsed.hooks[event] + // Check if already exists + const existing = hooks.find((h: any) => h.id === hookId) + if (!existing) { + // Add the template hook + hooks.push({ ...templateHook }) + } + } + } + + // Apply property updates to ALL instances of the hook in the file + for (const eventKey of Object.keys(parsed.hooks)) { + const hooks = parsed.hooks[eventKey] + if (Array.isArray(hooks)) { + const hook = hooks.find((h: any) => h.id === hookId) + if (hook) { + if (updates.matcher !== undefined) { + if (updates.matcher === "") { + delete hook.matcher + } else { + hook.matcher = updates.matcher + } + } + if (updates.timeout !== undefined) { + hook.timeout = updates.timeout + } + } + } + } + + // Write back (atomic) + if (isJson) { + await safeWriteJson(filePath, parsed) + } else { + await safeWriteText(filePath, YAML.stringify(parsed)) + } +} diff --git a/src/services/hooks/HookExecutor.ts b/src/services/hooks/HookExecutor.ts new file mode 100644 index 00000000000..16730625613 --- /dev/null +++ b/src/services/hooks/HookExecutor.ts @@ -0,0 +1,351 @@ +/** + * Hook Executor + * + * Executes shell commands for hooks with: + * - JSON context passed via stdin + * - Environment variables set per PRD + * - Timeout handling + * - Exit code interpretation (0=success, 2=block, other=error) + * - stdout/stderr capture + */ + +import { spawn, ChildProcess } from "child_process" +import * as os from "os" +import * as path from "path" +import { + ResolvedHook, + HookContext, + HookExecutionResult, + HookExitCode, + HookModificationSchema, + HookModification, + isBlockingEvent, + ConversationHistoryEntry, +} from "./types" + +/** + * Default timeout in seconds. + */ +const DEFAULT_TIMEOUT = 60 + +/** + * Get the default shell based on platform. + * Windows: PowerShell + * Unix: User's shell from SHELL env var, or /bin/sh + */ +function getDefaultShell(): { shell: string; shellArgs: string[] } { + if (os.platform() === "win32") { + return { + shell: "powershell.exe", + shellArgs: ["-NoProfile", "-NonInteractive", "-Command"], + } + } + + // Unix: try user's shell, fall back to /bin/sh + const userShell = process.env.SHELL || "/bin/sh" + return { + shell: userShell, + shellArgs: ["-c"], + } +} + +/** + * Parse a custom shell specification. + * Supports "bash", "/bin/bash", "powershell.exe", etc. + */ +function parseShellSpec(shellSpec: string): { shell: string; shellArgs: string[] } { + const lower = shellSpec.toLowerCase() + + // Handle PowerShell variants + if (lower.includes("powershell") || lower.includes("pwsh")) { + return { + shell: shellSpec, + shellArgs: ["-NoProfile", "-NonInteractive", "-Command"], + } + } + + // All other shells use -c + return { + shell: shellSpec, + shellArgs: ["-c"], + } +} + +/** + * Build environment variables for hook execution. + */ +function buildEnvVars(hook: ResolvedHook, context: HookContext): NodeJS.ProcessEnv { + const baseEnv = { ...process.env } + + return { + ...baseEnv, + ROO_PROJECT_DIR: context.project.directory, + ROO_TASK_ID: context.session.taskId, + ROO_SESSION_ID: context.session.sessionId, + ROO_MODE: context.session.mode, + ROO_TOOL_NAME: context.tool?.name || "", + ROO_EVENT: context.event, + ROO_HOOK_ID: hook.id, + } +} + +/** + * Build the stdin JSON payload for a hook. + */ +function buildStdinPayload( + hook: ResolvedHook, + context: HookContext, + conversationHistory?: ConversationHistoryEntry[], +): string { + // Start with the base context + const payload: HookContext = { ...context } + + // Only include conversation history if the hook opts in + if (hook.includeConversationHistory && conversationHistory) { + payload.conversationHistory = conversationHistory + } + + return JSON.stringify(payload) +} + +/** + * Try to parse stdout as a modification response. + * Returns undefined if stdout is empty or not valid modification JSON. + */ +function parseModificationResponse(stdout: string, hook: ResolvedHook): HookModification | undefined { + if (!stdout.trim()) { + return undefined + } + + try { + const parsed = JSON.parse(stdout) + const result = HookModificationSchema.safeParse(parsed) + + if (result.success) { + // Only PreToolUse hooks can modify input + if (hook.event !== "PreToolUse") { + console.warn(`Hook "${hook.id}" returned modification but is not a PreToolUse hook - ignoring`) + return undefined + } + return result.data + } + + // Not a valid modification response - that's fine, hooks don't have to return JSON + return undefined + } catch { + // Not valid JSON - that's fine + return undefined + } +} + +/** + * Execute a single hook command. + * + * @param hook - The hook to execute + * @param context - The hook context + * @param conversationHistory - Optional conversation history (only included if hook opts in) + * @returns Execution result + */ +export async function executeHook( + hook: ResolvedHook, + context: HookContext, + conversationHistory?: ConversationHistoryEntry[], +): Promise { + const startTime = Date.now() + const timeout = (hook.timeout || DEFAULT_TIMEOUT) * 1000 // Convert to ms + + // Determine shell + const shellConfig = hook.shell ? parseShellSpec(hook.shell) : getDefaultShell() + + // Build environment and stdin + const env = buildEnvVars(hook, context) + const stdin = buildStdinPayload(hook, context, conversationHistory) + + return new Promise((resolve) => { + let child: ChildProcess | null = null + let stdout = "" + let stderr = "" + let timedOut = false + let resolved = false + + const finalize = (exitCode: number | null, error?: Error) => { + if (resolved) return + resolved = true + + const duration = Date.now() - startTime + + // Try to parse modification from stdout + const modification = parseModificationResponse(stdout, hook) + + resolve({ + hook, + exitCode, + stdout, + stderr, + duration, + timedOut, + error, + modification, + }) + } + + // Set up timeout + const timeoutHandle = setTimeout(() => { + timedOut = true + if (child) { + // Try graceful kill first (SIGTERM), then force (SIGKILL) + child.kill("SIGTERM") + setTimeout(() => { + if (child && !child.killed) { + child.kill("SIGKILL") + } + }, 1000) + } + }, timeout) + + try { + // Spawn the shell process + child = spawn(shellConfig.shell, [...shellConfig.shellArgs, hook.command], { + cwd: context.project.directory, + env, + stdio: ["pipe", "pipe", "pipe"], + // Don't throw on Windows if shell not found + windowsHide: true, + }) + + // Write stdin + if (child.stdin) { + child.stdin.write(stdin) + child.stdin.end() + } + + // Capture stdout + if (child.stdout) { + child.stdout.on("data", (data: Buffer) => { + stdout += data.toString() + }) + } + + // Capture stderr + if (child.stderr) { + child.stderr.on("data", (data: Buffer) => { + stderr += data.toString() + }) + } + + // Handle process exit + child.on("close", (code) => { + clearTimeout(timeoutHandle) + finalize(code) + }) + + // Handle spawn errors + child.on("error", (err) => { + clearTimeout(timeoutHandle) + finalize(null, err) + }) + } catch (err) { + clearTimeout(timeoutHandle) + finalize(null, err instanceof Error ? err : new Error(String(err))) + } + }) +} + +/** + * Interpret the result of a hook execution. + * + * @param result - The execution result + * @returns Object with interpretation flags + */ +export function interpretResult(result: HookExecutionResult): { + success: boolean + blocked: boolean + blockMessage: string | undefined + shouldContinue: boolean +} { + // Check for execution errors first + if (result.error || result.exitCode === null) { + return { + success: false, + blocked: false, + blockMessage: undefined, + shouldContinue: true, // Execution errors don't block, per PRD + } + } + + // Check for timeout + if (result.timedOut) { + return { + success: false, + blocked: false, + blockMessage: undefined, + shouldContinue: true, // Timeouts don't block, per PRD + } + } + + // Exit code 0 = success + if (result.exitCode === HookExitCode.Success) { + return { + success: true, + blocked: false, + blockMessage: undefined, + shouldContinue: true, + } + } + + // Exit code 2 = block (only for blocking events) + if (result.exitCode === HookExitCode.Block) { + if (isBlockingEvent(result.hook.event)) { + return { + success: false, + blocked: true, + blockMessage: result.stderr.trim() || `Hook "${result.hook.id}" blocked execution`, + shouldContinue: false, + } + } else { + // Non-blocking event with exit code 2 is treated as regular failure + console.warn( + `Hook "${result.hook.id}" returned exit code 2 (block) but ${result.hook.event} is not a blocking event - treating as error`, + ) + return { + success: false, + blocked: false, + blockMessage: undefined, + shouldContinue: true, + } + } + } + + // Other non-zero exit codes = error, but don't block + return { + success: false, + blocked: false, + blockMessage: undefined, + shouldContinue: true, + } +} + +/** + * Get a human-readable description of a hook result for logging. + */ +export function describeResult(result: HookExecutionResult): string { + const hook = result.hook + + if (result.error) { + return `Hook "${hook.id}" failed to execute: ${result.error.message}` + } + + if (result.timedOut) { + return `Hook "${hook.id}" timed out after ${hook.timeout || DEFAULT_TIMEOUT}s` + } + + if (result.exitCode === HookExitCode.Success) { + return `Hook "${hook.id}" completed successfully in ${result.duration}ms` + } + + if (result.exitCode === HookExitCode.Block) { + return `Hook "${hook.id}" blocked with: ${result.stderr.trim() || "(no message)"}` + } + + return `Hook "${hook.id}" returned exit code ${result.exitCode} in ${result.duration}ms` +} diff --git a/src/services/hooks/HookManager.ts b/src/services/hooks/HookManager.ts new file mode 100644 index 00000000000..e092795937d --- /dev/null +++ b/src/services/hooks/HookManager.ts @@ -0,0 +1,331 @@ +/** + * Hook Manager + * + * Central service for orchestrating hooks in Roo Code. + * Implements the IHookManager interface from the PRD. + * + * Key responsibilities: + * - Load and maintain a snapshot of hook configuration + * - Execute matching hooks sequentially for events + * - Manage execution history for debugging + * - Provide enable/disable API for individual hooks + */ + +import { + IHookManager, + HookEventType, + HooksConfigSnapshot, + ResolvedHook, + HookExecution, + HooksExecutionResult, + HookExecutionResult, + ExecuteHooksOptions, + HookContext, + ConversationHistoryEntry, + HookUpdateData, +} from "./types" +import { loadHooksConfig, getHooksForEvent, LoadHooksConfigOptions } from "./HookConfigLoader" +import { filterMatchingHooks } from "./HookMatcher" +import { executeHook, interpretResult, describeResult } from "./HookExecutor" +import { updateHookConfig } from "./HookConfigWriter" + +/** + * Default options for the HookManager. + */ +export interface HookManagerOptions { + /** Project directory (cwd) */ + cwd: string + + /** Current mode slug */ + mode?: string + + /** Maximum execution history entries to keep (default: 100) */ + maxHistoryEntries?: number + + /** Optional logger for hook activity */ + logger?: { + debug: (message: string) => void + info: (message: string) => void + warn: (message: string) => void + error: (message: string) => void + } +} + +/** + * Default maximum history entries. + */ +const DEFAULT_MAX_HISTORY = 100 + +/** + * HookManager implementation. + * + * This class maintains an immutable snapshot of hook configuration that is + * loaded once and only changes on explicit reload (for security). + */ +export class HookManager implements IHookManager { + private options: HookManagerOptions + private snapshot: HooksConfigSnapshot | null = null + private executionHistory: HookExecution[] = [] + private maxHistoryEntries: number + + constructor(options: HookManagerOptions) { + this.options = options + this.maxHistoryEntries = options.maxHistoryEntries ?? DEFAULT_MAX_HISTORY + } + + /** + * Load hooks configuration from all sources. + * Creates an immutable snapshot that won't change until explicit reload. + */ + async loadHooksConfig(): Promise { + const loadOptions: LoadHooksConfigOptions = { + cwd: this.options.cwd, + mode: this.options.mode, + } + + const { snapshot, errors, warnings } = await loadHooksConfig(loadOptions) + + // Log errors and warnings + if (this.options.logger) { + for (const error of errors) { + this.options.logger.error(`Hook config error: ${error}`) + } + for (const warning of warnings) { + this.options.logger.warn(warning) + } + } + + // Store the snapshot + this.snapshot = snapshot + + // Log summary + const hookCount = Array.from(snapshot.hooksByEvent.values()).reduce((sum, hooks) => sum + hooks.length, 0) + this.log("info", `Loaded ${hookCount} hooks from configuration`) + + return snapshot + } + + /** + * Explicitly reload hooks configuration. + * Required for security - config changes don't auto-apply. + */ + async reloadHooksConfig(): Promise { + this.log("info", "Reloading hooks configuration...") + + // Preserve disabled hook IDs across reload + const previousDisabled = this.snapshot?.disabledHookIds ?? new Set() + + await this.loadHooksConfig() + + // Restore disabled state for hooks that still exist + if (this.snapshot) { + for (const hookId of previousDisabled) { + if (this.snapshot.hooksById.has(hookId)) { + this.snapshot.disabledHookIds.add(hookId) + } + } + } + + this.log("info", "Hooks configuration reloaded") + } + + /** + * Execute all matching hooks for an event. + * Hooks are executed sequentially in their defined order. + * If a blocking event returns exit code 2, subsequent hooks are skipped. + */ + async executeHooks(event: HookEventType, options: ExecuteHooksOptions): Promise { + const startTime = Date.now() + const results: HookExecutionResult[] = [] + + // Ensure config is loaded + if (!this.snapshot) { + await this.loadHooksConfig() + } + + // Get enabled hooks for this event + const eventHooks = getHooksForEvent(this.snapshot!, event) + + // Filter by tool name if this is a tool-related event + let matchingHooks: ResolvedHook[] + if (options.context.tool?.name) { + matchingHooks = filterMatchingHooks(eventHooks, options.context.tool.name) + } else { + matchingHooks = eventHooks + } + + this.log("debug", `Executing ${matchingHooks.length} hooks for ${event}`) + + let blocked = false + let blockMessage: string | undefined + let blockingHook: ResolvedHook | undefined + let modification: HooksExecutionResult["modification"] + + // Execute hooks sequentially + for (const hook of matchingHooks) { + this.log("debug", `Executing hook "${hook.id}" for ${event}`) + + // Execute the hook + const result = await executeHook(hook, options.context, options.conversationHistory) + results.push(result) + + // Record in history + this.recordExecution(hook, event, result) + + // Log the result + this.log("info", describeResult(result)) + + // Interpret the result + const interpretation = interpretResult(result) + + // Check for blocking + if (interpretation.blocked) { + blocked = true + blockMessage = interpretation.blockMessage + blockingHook = hook + this.log("warn", `Hook "${hook.id}" blocked ${event}: ${blockMessage}`) + break // Stop executing subsequent hooks + } + + // Check for modification (only first modification wins) + if (!modification && result.modification) { + modification = result.modification + this.log("info", `Hook "${hook.id}" modified tool input`) + } + + // If hook returned an error but we should continue, log it + if (!interpretation.success && interpretation.shouldContinue) { + this.log("warn", `Hook "${hook.id}" failed but continuing: ${result.error?.message || result.stderr}`) + } + } + + const totalDuration = Date.now() - startTime + this.log("debug", `Executed ${results.length} hooks in ${totalDuration}ms`) + + return { + results, + blocked, + blockMessage, + blockingHook, + modification, + totalDuration, + } + } + + /** + * Get all currently enabled hooks. + */ + getEnabledHooks(): ResolvedHook[] { + if (!this.snapshot) { + return [] + } + + const allHooks: ResolvedHook[] = [] + for (const hooks of this.snapshot.hooksByEvent.values()) { + for (const hook of hooks) { + // Check if enabled in config AND not disabled at runtime + if (hook.enabled !== false && !this.snapshot.disabledHookIds.has(hook.id)) { + allHooks.push(hook) + } + } + } + + return allHooks + } + + /** + * Enable or disable a specific hook by ID. + * This persists until config reload. + */ + async setHookEnabled(hookId: string, enabled: boolean): Promise { + if (!this.snapshot) { + await this.loadHooksConfig() + } + + const hook = this.snapshot!.hooksById.get(hookId) + if (!hook) { + throw new Error(`Hook not found: ${hookId}`) + } + + if (enabled) { + this.snapshot!.disabledHookIds.delete(hookId) + this.log("info", `Enabled hook "${hookId}"`) + } else { + this.snapshot!.disabledHookIds.add(hookId) + this.log("info", `Disabled hook "${hookId}"`) + } + } + + /** + * Get execution history for debugging. + */ + getHookExecutionHistory(): HookExecution[] { + return [...this.executionHistory] + } + + /** + * Get the current config snapshot (or null if not loaded). + */ + getConfigSnapshot(): HooksConfigSnapshot | null { + return this.snapshot + } + + /** + * Update the current mode (useful when mode changes during session). + * Requires reload to take effect. + */ + setMode(mode: string): void { + this.options.mode = mode + } + + /** + * Update a hook inside a specific config file. + * This modifies the file on disk; callers should trigger a reload to apply changes. + */ + async updateHook(filePath: string, hookId: string, updates: HookUpdateData): Promise { + await updateHookConfig(filePath, hookId, updates) + this.log("info", `Updated hook "${hookId}" in ${filePath}`) + } + + /** + * Clear execution history. + */ + clearHistory(): void { + this.executionHistory = [] + } + + /** + * Record a hook execution in history. + */ + private recordExecution(hook: ResolvedHook, event: HookEventType, result: HookExecutionResult): void { + const entry: HookExecution = { + timestamp: new Date(), + hook, + event, + result, + } + + this.executionHistory.push(entry) + + // Trim history if needed + if (this.executionHistory.length > this.maxHistoryEntries) { + this.executionHistory = this.executionHistory.slice(-this.maxHistoryEntries) + } + } + + /** + * Log a message using the configured logger. + */ + private log(level: "debug" | "info" | "warn" | "error", message: string): void { + if (this.options.logger) { + this.options.logger[level](`[Hooks] ${message}`) + } + } +} + +/** + * Create a new HookManager instance. + */ +export function createHookManager(options: HookManagerOptions): IHookManager { + return new HookManager(options) +} diff --git a/src/services/hooks/HookMatcher.ts b/src/services/hooks/HookMatcher.ts new file mode 100644 index 00000000000..d881130b47f --- /dev/null +++ b/src/services/hooks/HookMatcher.ts @@ -0,0 +1,200 @@ +/** + * Hook Matcher + * + * Provides pattern matching for hooks against tool names. + * Supports exact match, regex patterns, glob patterns, group names, and match-all. + */ + +import { ResolvedHook } from "./types" +import { getToolsForGroup } from "../../shared/tools" + +/** + * Expand group patterns in a matcher pattern. + * Only expands groups if the pattern is a simple group name or alternation of group names. + * For complex regex patterns, groups are not expanded to avoid breaking existing behavior. + */ +function expandGroupPatterns(pattern: string): string { + // Don't expand groups in patterns that contain | (to preserve existing regex alternation behavior) + if (pattern.includes("|")) { + return pattern + } + + // Don't expand groups in complex patterns that contain regex metacharacters + const regexMetaChars = /[*^$+.()[\]{}\\]/ + if (regexMetaChars.test(pattern)) { + return pattern // Keep complex patterns as-is + } + + // Single group name + const tools = getToolsForGroup(pattern) + if (tools) { + // It's a known group, expand to all tools in the group + return tools.join("|") + } else { + // Not a group, keep as-is, but warn if it looks like it was intended as a group + console.warn(`Unknown tool group "${pattern}". Treating as literal tool name.`) + return pattern + } +} + +/** + * Result of compiling a matcher pattern. + */ +interface CompiledMatcher { + /** The original pattern string */ + pattern: string + + /** Type of matching to use */ + type: "all" | "exact" | "regex" | "glob" + + /** Compiled regex for regex/glob matching */ + regex?: RegExp + + /** Test if a tool name matches this pattern */ + matches: (toolName: string) => boolean +} + +/** + * Compile a matcher pattern into an efficient matcher function. + * + * Supports: + * - Exact tool name: "Write" + * - Regex pattern: "Edit|Write" (contains | or regex metacharacters) + * - Glob pattern: "mcp__*" (contains * or ?) + * - Match all: "*" or undefined/empty + * + * @param pattern - The matcher pattern string (or undefined for match-all) + * @returns Compiled matcher object + */ +export function compileMatcher(pattern: string | undefined): CompiledMatcher { + // Handle match-all cases + if (!pattern || pattern === "*") { + return { + pattern: pattern || "*", + type: "all", + matches: () => true, + } + } + + // Expand group patterns before processing + const expandedPattern = expandGroupPatterns(pattern) + + // Check if expanded pattern looks like a regex (contains regex metacharacters except * and ?) + const regexMetaChars = /[|^$+.()[\]{}\\]/ + const isRegexPattern = regexMetaChars.test(expandedPattern) + + // Check if expanded pattern looks like a glob (contains * or ?) + const isGlobPattern = /[*?]/.test(expandedPattern) && !isRegexPattern + + if (isRegexPattern) { + // Treat as regex pattern + try { + const regex = new RegExp(`^(?:${expandedPattern})$`, "i") + return { + pattern, + type: "regex", + regex, + matches: (toolName: string) => regex.test(toolName), + } + } catch (e) { + // If regex compilation fails, fall back to exact match + console.warn(`Invalid regex pattern "${pattern}", falling back to exact match:`, e) + return { + pattern, + type: "exact", + matches: (toolName: string) => toolName.toLowerCase() === expandedPattern.toLowerCase(), + } + } + } + + if (isGlobPattern) { + // Convert glob to regex + // * matches any characters, ? matches single character + const regexPattern = expandedPattern + .replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape regex special chars except * and ? + .replace(/\*/g, ".*") // * -> .* + .replace(/\?/g, ".") // ? -> . + + try { + const regex = new RegExp(`^${regexPattern}$`, "i") + return { + pattern, + type: "glob", + regex, + matches: (toolName: string) => regex.test(toolName), + } + } catch (e) { + // If regex compilation fails, fall back to exact match + console.warn(`Invalid glob pattern "${pattern}", falling back to exact match:`, e) + return { + pattern, + type: "exact", + matches: (toolName: string) => toolName.toLowerCase() === expandedPattern.toLowerCase(), + } + } + } + + // Exact match (case-insensitive) + return { + pattern, + type: "exact", + matches: (toolName: string) => toolName.toLowerCase() === expandedPattern.toLowerCase(), + } +} + +/** + * Cache of compiled matchers for performance. + * Key is the pattern string, value is the compiled matcher. + */ +const matcherCache = new Map() + +/** + * Get a compiled matcher, using cache when possible. + * + * @param pattern - The matcher pattern string (or undefined for match-all) + * @returns Compiled matcher object + */ +export function getMatcher(pattern: string | undefined): CompiledMatcher { + const cacheKey = pattern || "*" + + let matcher = matcherCache.get(cacheKey) + if (!matcher) { + matcher = compileMatcher(pattern) + matcherCache.set(cacheKey, matcher) + } + + return matcher +} + +/** + * Clear the matcher cache (useful for testing). + */ +export function clearMatcherCache(): void { + matcherCache.clear() +} + +/** + * Filter hooks that match a given tool name. + * + * @param hooks - Array of hooks to filter + * @param toolName - Tool name to match against + * @returns Hooks that match the tool name + */ +export function filterMatchingHooks(hooks: ResolvedHook[], toolName: string): ResolvedHook[] { + return hooks.filter((hook) => { + const matcher = getMatcher(hook.matcher) + return matcher.matches(toolName) + }) +} + +/** + * Check if a single hook matches a tool name. + * + * @param hook - The hook to check + * @param toolName - Tool name to match against + * @returns Whether the hook matches + */ +export function hookMatchesTool(hook: ResolvedHook, toolName: string): boolean { + const matcher = getMatcher(hook.matcher) + return matcher.matches(toolName) +} diff --git a/src/services/hooks/ToolExecutionHooks.ts b/src/services/hooks/ToolExecutionHooks.ts new file mode 100644 index 00000000000..2c0113434f1 --- /dev/null +++ b/src/services/hooks/ToolExecutionHooks.ts @@ -0,0 +1,534 @@ +/** + * Tool Execution Hooks Service + * + * Provides integration between the tool execution pipeline and the hooks system. + * Handles PreToolUse, PostToolUse, PostToolUseFailure, and PermissionRequest events. + */ + +import type { + IHookManager, + HookEventType, + HookContext, + HookSessionContext, + HookProjectContext, + HookToolContext, + HooksExecutionResult, + ExecuteHooksOptions, +} from "./types" + +/** + * Tool execution context for hooks. + */ +export interface ToolExecutionContext { + /** Tool name being executed */ + toolName: string + /** Tool input parameters */ + toolInput: Record + /** Session context */ + session: HookSessionContext + /** Project context */ + project: HookProjectContext +} + +/** + * Result from PreToolUse hook execution. + */ +export interface PreToolUseResult { + /** Whether the tool execution should proceed */ + proceed: boolean + /** If blocked, the reason */ + blockReason?: string + /** Modified tool input (if hooks modified it) */ + modifiedInput?: Record + /** Hook execution result for debugging */ + hookResult: HooksExecutionResult +} + +/** + * Result from PermissionRequest hook execution. + */ +export interface PermissionRequestResult { + /** Whether the permission request should proceed to user */ + proceed: boolean + /** If blocked, the reason */ + blockReason?: string + /** Hook execution result for debugging */ + hookResult: HooksExecutionResult +} + +/** + * Callback for emitting hook execution status to webview. + */ +export type HookStatusCallback = (status: { + status: "running" | "completed" | "failed" | "blocked" + event: HookEventType + toolName?: string + hookId?: string + duration?: number + error?: string + blockMessage?: string + modified?: boolean +}) => void + +/** + * Callback for emitting messages to chat history. + */ +export type SayCallback = (type: string, text?: string) => Promise + +/** + * Callback to check if hooks are globally enabled. + */ +export type HooksEnabledGetter = () => boolean + +/** + * Tool Execution Hooks Service + * + * Orchestrates hook execution for tool lifecycle events. + */ +export class ToolExecutionHooks { + private hookManager: IHookManager | null + private statusCallback?: HookStatusCallback + private sayCallback?: SayCallback + private hooksEnabledGetter?: HooksEnabledGetter + + constructor( + hookManager: IHookManager | null, + statusCallback?: HookStatusCallback, + sayCallback?: SayCallback, + hooksEnabledGetter?: HooksEnabledGetter, + ) { + this.hookManager = hookManager + this.statusCallback = statusCallback + this.sayCallback = sayCallback + this.hooksEnabledGetter = hooksEnabledGetter + } + + /** + * Update the hook manager instance. + */ + setHookManager(hookManager: IHookManager | null): void { + this.hookManager = hookManager + } + + /** + * Update the status callback. + */ + setStatusCallback(callback: HookStatusCallback | undefined): void { + this.statusCallback = callback + } + + /** + * Update the say callback. + */ + setSayCallback(callback: SayCallback | undefined): void { + this.sayCallback = callback + } + + /** + * Update the hooks enabled getter. + */ + setHooksEnabledGetter(getter: HooksEnabledGetter | undefined): void { + this.hooksEnabledGetter = getter + } + + /** + * Check if hooks are globally enabled. + * Returns true if no getter is set (backwards compatibility) or if the getter returns true. + */ + private isHooksEnabled(): boolean { + if (!this.hooksEnabledGetter) { + return true // Default to enabled for backwards compatibility + } + return this.hooksEnabledGetter() + } + + /** + * Execute PreToolUse hooks before a tool is executed. + * + * @returns Result indicating whether to proceed, and optionally modified input + */ + async executePreToolUse(context: ToolExecutionContext): Promise { + // Check global hooks enabled state first + if (!this.isHooksEnabled() || !this.hookManager) { + // No hooks configured - proceed normally + return { + proceed: true, + hookResult: { + results: [], + blocked: false, + totalDuration: 0, + }, + } + } + + const hookContext = this.buildToolHookContext("PreToolUse", context) + + // Emit running status + this.emitStatus({ + status: "running", + event: "PreToolUse", + toolName: context.toolName, + }) + + try { + const result = await this.hookManager.executeHooks("PreToolUse", { context: hookContext }) + + await this.emitHookTriggeredMessages(result) + + if (result.blocked) { + // Hook blocked the execution + this.emitStatus({ + status: "blocked", + event: "PreToolUse", + toolName: context.toolName, + blockMessage: result.blockMessage, + duration: result.totalDuration, + }) + + return { + proceed: false, + blockReason: result.blockMessage || "Blocked by PreToolUse hook", + hookResult: result, + } + } + + // Check for modifications + const modified = !!result.modification + const modifiedInput = result.modification?.toolInput + + this.emitStatus({ + status: "completed", + event: "PreToolUse", + toolName: context.toolName, + duration: result.totalDuration, + modified, + }) + + return { + proceed: true, + modifiedInput, + hookResult: result, + } + } catch (error) { + const errorMessage = error instanceof Error ? error.message : String(error) + + this.emitStatus({ + status: "failed", + event: "PreToolUse", + toolName: context.toolName, + error: errorMessage, + }) + + // On hook execution error, proceed with original execution + // (fail-open for safety) + return { + proceed: true, + hookResult: { + results: [], + blocked: false, + totalDuration: 0, + }, + } + } + } + + /** + * Execute PostToolUse hooks after successful tool execution. + * This is non-blocking and fire-and-forget. + */ + async executePostToolUse( + context: ToolExecutionContext, + output: unknown, + duration: number, + ): Promise { + // Check global hooks enabled state first + if (!this.isHooksEnabled() || !this.hookManager) { + return { + results: [], + blocked: false, + totalDuration: 0, + } + } + + const hookContext = this.buildToolHookContext("PostToolUse", context, { + output, + duration, + }) + + this.emitStatus({ + status: "running", + event: "PostToolUse", + toolName: context.toolName, + }) + + try { + const result = await this.hookManager.executeHooks("PostToolUse", { context: hookContext }) + + await this.emitHookTriggeredMessages(result) + + this.emitStatus({ + status: "completed", + event: "PostToolUse", + toolName: context.toolName, + duration: result.totalDuration, + }) + + return result + } catch (error) { + const errorMessage = error instanceof Error ? error.message : String(error) + + this.emitStatus({ + status: "failed", + event: "PostToolUse", + toolName: context.toolName, + error: errorMessage, + }) + + return { + results: [], + blocked: false, + totalDuration: 0, + } + } + } + + /** + * Execute PostToolUseFailure hooks after failed tool execution. + * This is non-blocking and fire-and-forget. + */ + async executePostToolUseFailure( + context: ToolExecutionContext, + error: string, + errorMessage: string, + ): Promise { + // Check global hooks enabled state first + if (!this.isHooksEnabled() || !this.hookManager) { + return { + results: [], + blocked: false, + totalDuration: 0, + } + } + + const hookContext = this.buildToolHookContext("PostToolUseFailure", context, { + error, + errorMessage, + }) + + this.emitStatus({ + status: "running", + event: "PostToolUseFailure", + toolName: context.toolName, + }) + + try { + const result = await this.hookManager.executeHooks("PostToolUseFailure", { context: hookContext }) + + await this.emitHookTriggeredMessages(result) + + this.emitStatus({ + status: "completed", + event: "PostToolUseFailure", + toolName: context.toolName, + duration: result.totalDuration, + }) + + return result + } catch (err) { + const errMsg = err instanceof Error ? err.message : String(err) + + this.emitStatus({ + status: "failed", + event: "PostToolUseFailure", + toolName: context.toolName, + error: errMsg, + }) + + return { + results: [], + blocked: false, + totalDuration: 0, + } + } + } + + /** + * Execute PermissionRequest hooks before showing approval prompt. + * + * Note: Even if hooks indicate "block", this does NOT auto-approve restricted tools. + * The hook can only prevent the approval dialog from appearing (denying the tool), + * not bypass the existing approval/auto-approval rules. + * + * @returns Result indicating whether to proceed with showing the prompt + */ + async executePermissionRequest(context: ToolExecutionContext): Promise { + // Check global hooks enabled state first + if (!this.isHooksEnabled() || !this.hookManager) { + return { + proceed: true, + hookResult: { + results: [], + blocked: false, + totalDuration: 0, + }, + } + } + + const hookContext = this.buildToolHookContext("PermissionRequest", context) + + this.emitStatus({ + status: "running", + event: "PermissionRequest", + toolName: context.toolName, + }) + + try { + const result = await this.hookManager.executeHooks("PermissionRequest", { context: hookContext }) + + await this.emitHookTriggeredMessages(result) + + if (result.blocked) { + // Hook blocked - do not show approval dialog, deny the tool + this.emitStatus({ + status: "blocked", + event: "PermissionRequest", + toolName: context.toolName, + blockMessage: result.blockMessage, + duration: result.totalDuration, + }) + + return { + proceed: false, + blockReason: result.blockMessage || "Blocked by PermissionRequest hook", + hookResult: result, + } + } + + this.emitStatus({ + status: "completed", + event: "PermissionRequest", + toolName: context.toolName, + duration: result.totalDuration, + }) + + return { + proceed: true, + hookResult: result, + } + } catch (error) { + const errorMessage = error instanceof Error ? error.message : String(error) + + this.emitStatus({ + status: "failed", + event: "PermissionRequest", + toolName: context.toolName, + error: errorMessage, + }) + + // On hook execution error, proceed with showing approval prompt + // (fail-open for safety) + return { + proceed: true, + hookResult: { + results: [], + blocked: false, + totalDuration: 0, + }, + } + } + } + + /** + * Check if hooks are configured and available. + */ + hasHooks(): boolean { + return this.isHooksEnabled() && this.hookManager !== null && this.hookManager.getConfigSnapshot() !== null + } + + /** + * Build hook context for tool-related events. + */ + private buildToolHookContext( + event: HookEventType, + context: ToolExecutionContext, + extra?: { + output?: unknown + duration?: number + error?: string + errorMessage?: string + }, + ): HookContext { + const toolContext: HookToolContext = { + name: context.toolName, + input: context.toolInput, + } + + if (extra?.output !== undefined) { + toolContext.output = extra.output + } + + if (extra?.duration !== undefined) { + toolContext.duration = extra.duration + } + + if (extra?.error !== undefined) { + toolContext.error = extra.error + } + + if (extra?.errorMessage !== undefined) { + toolContext.errorMessage = extra.errorMessage + } + + return { + event, + timestamp: new Date().toISOString(), + session: context.session, + project: context.project, + tool: toolContext, + } + } + + /** + * Emit status to webview if callback is set. + */ + private emitStatus(status: Parameters[0]): void { + if (this.statusCallback) { + try { + this.statusCallback(status) + } catch { + // Ignore callback errors + } + } + } + + /** + * Emit hook triggered messages for successful hook executions. + */ + private async emitHookTriggeredMessages(result: HooksExecutionResult): Promise { + if (!this.sayCallback) { + return + } + + for (const hookResult of result.results) { + if (!hookResult.error && hookResult.exitCode === 0) { + try { + await this.sayCallback("hook_triggered", hookResult.hook.id) + } catch { + // Ignore callback errors + } + } + } + } +} + +/** + * Create a ToolExecutionHooks instance. + */ +export function createToolExecutionHooks( + hookManager: IHookManager | null, + statusCallback?: HookStatusCallback, + sayCallback?: SayCallback, + hooksEnabledGetter?: HooksEnabledGetter, +): ToolExecutionHooks { + return new ToolExecutionHooks(hookManager, statusCallback, sayCallback, hooksEnabledGetter) +} diff --git a/src/services/hooks/__tests__/HookConfigLoader.spec.ts b/src/services/hooks/__tests__/HookConfigLoader.spec.ts new file mode 100644 index 00000000000..252cb5ae00d --- /dev/null +++ b/src/services/hooks/__tests__/HookConfigLoader.spec.ts @@ -0,0 +1,337 @@ +/** + * Tests for HookConfigLoader + * + * Covers: + * - Config parsing (YAML and JSON) + * - Zod validation + * - Precedence merging (project > mode > global) + * - Error handling for invalid configs + */ + +import { loadHooksConfig, getHooksForEvent, getHookById } from "../HookConfigLoader" +import type { HooksConfigSnapshot, HookEventType } from "../types" + +// Create hoisted mocks +const mockFsPromises = vi.hoisted(() => ({ + readdir: vi.fn(), + readFile: vi.fn(), + access: vi.fn(), +})) + +vi.mock("fs/promises", () => ({ + default: mockFsPromises, + readdir: mockFsPromises.readdir, + readFile: mockFsPromises.readFile, + access: mockFsPromises.access, +})) + +vi.mock("../../roo-config", () => ({ + getGlobalRooDirectory: () => "/home/user/.roo", + getProjectRooDirectoryForCwd: (cwd: string) => `${cwd}/.roo`, +})) + +describe("HookConfigLoader", () => { + beforeEach(() => { + vi.clearAllMocks() + }) + + describe("loadHooksConfig", () => { + it("should return empty snapshot when no config files exist", async () => { + // Mock: no directories exist + mockFsPromises.readdir.mockRejectedValue({ code: "ENOENT" }) + + const result = await loadHooksConfig({ cwd: "/project" }) + + expect(result.snapshot.hooksByEvent.size).toBe(0) + expect(result.snapshot.hooksById.size).toBe(0) + expect(result.errors).toHaveLength(0) + }) + + it("should parse YAML config files", async () => { + const yamlContent = ` +version: "1" +hooks: + PreToolUse: + - id: lint-check + matcher: "Edit|Write" + command: "./lint.sh" + timeout: 30 +` + mockFsPromises.readdir.mockImplementation(async (dirPath) => { + const dir = dirPath.toString() + if (dir.includes("/.roo/hooks")) { + return [{ name: "pre-tool.yaml", isFile: () => true, isDirectory: () => false }] + } + throw { code: "ENOENT" } + }) + mockFsPromises.readFile.mockImplementation(async (filePath) => { + if (filePath.toString().endsWith("pre-tool.yaml")) { + return yamlContent + } + throw { code: "ENOENT" } + }) + + const result = await loadHooksConfig({ cwd: "/project" }) + + expect(result.errors).toHaveLength(0) + expect(result.snapshot.hooksByEvent.has("PreToolUse")).toBe(true) + const hooks = result.snapshot.hooksByEvent.get("PreToolUse")! + expect(hooks).toHaveLength(1) + expect(hooks[0].id).toBe("lint-check") + expect(hooks[0].command).toBe("./lint.sh") + expect(hooks[0].timeout).toBe(30) + }) + + it("should parse JSON config files", async () => { + const jsonContent = JSON.stringify({ + version: "1", + hooks: { + PostToolUse: [{ id: "notify-slack", command: "./notify.sh" }], + }, + }) + + mockFsPromises.readdir.mockImplementation(async (dirPath) => { + const dir = dirPath.toString() + if (dir.includes("/.roo/hooks")) { + return [{ name: "post-tool.json", isFile: () => true, isDirectory: () => false }] + } + throw { code: "ENOENT" } + }) + mockFsPromises.readFile.mockImplementation(async (filePath) => { + if (filePath.toString().endsWith("post-tool.json")) { + return jsonContent + } + throw { code: "ENOENT" } + }) + + const result = await loadHooksConfig({ cwd: "/project" }) + + expect(result.errors).toHaveLength(0) + expect(result.snapshot.hooksByEvent.has("PostToolUse")).toBe(true) + }) + + it("should report validation errors for invalid config", async () => { + // Missing required 'command' field + const invalidYaml = ` +version: "1" +hooks: + PreToolUse: + - id: bad-hook + command: "" +` + mockFsPromises.readdir.mockImplementation(async (dirPath) => { + const dir = dirPath.toString() + if (dir.includes("/.roo/hooks")) { + return [{ name: "invalid.yaml", isFile: () => true, isDirectory: () => false }] + } + throw { code: "ENOENT" } + }) + mockFsPromises.readFile.mockImplementation(async (filePath) => { + if (filePath.toString().endsWith("invalid.yaml")) { + return invalidYaml + } + throw { code: "ENOENT" } + }) + + const result = await loadHooksConfig({ cwd: "/project" }) + + // Should have validation error (command cannot be empty) + expect(result.errors.length).toBeGreaterThan(0) + expect(result.errors[0]).toContain("command") + }) + + it("should merge configs with project taking precedence over global", async () => { + const globalYaml = ` +version: "1" +hooks: + PreToolUse: + - id: shared-hook + command: "global-command" +` + const projectYaml = ` +version: "1" +hooks: + PreToolUse: + - id: shared-hook + command: "project-command" +` + mockFsPromises.readdir.mockImplementation(async (dirPath) => { + const dir = dirPath.toString() + if (dir.includes(".roo/hooks")) { + return [{ name: "hooks.yaml", isFile: () => true, isDirectory: () => false }] + } + throw { code: "ENOENT" } + }) + mockFsPromises.readFile.mockImplementation(async (filePath) => { + const path = filePath.toString() + if (path.includes("/home/user/.roo") && path.endsWith("hooks.yaml")) { + return globalYaml + } + if (path.includes("/project/.roo") && path.endsWith("hooks.yaml")) { + return projectYaml + } + throw { code: "ENOENT" } + }) + + const result = await loadHooksConfig({ cwd: "/project" }) + + expect(result.errors).toHaveLength(0) + const hooks = result.snapshot.hooksByEvent.get("PreToolUse")! + expect(hooks).toHaveLength(1) + // Project should take precedence + expect(hooks[0].command).toBe("project-command") + }) + + it("should include mode-specific hooks when mode is provided", async () => { + const modeYaml = ` +version: "1" +hooks: + PreToolUse: + - id: mode-hook + command: "./mode-specific.sh" +` + mockFsPromises.readdir.mockImplementation(async (dirPath) => { + const dir = dirPath.toString() + if (dir.includes("hooks-code")) { + return [{ name: "hooks.yaml", isFile: () => true, isDirectory: () => false }] + } + throw { code: "ENOENT" } + }) + mockFsPromises.readFile.mockImplementation(async (filePath) => { + if (filePath.toString().includes("hooks-code")) { + return modeYaml + } + throw { code: "ENOENT" } + }) + + const result = await loadHooksConfig({ cwd: "/project", mode: "code" }) + + expect(result.errors).toHaveLength(0) + expect(result.snapshot.hooksByEvent.has("PreToolUse")).toBe(true) + }) + + it("should set hasProjectHooks flag when project hooks exist", async () => { + const projectYaml = ` +version: "1" +hooks: + PreToolUse: + - id: project-hook + command: "./project.sh" +` + mockFsPromises.readdir.mockImplementation(async (dirPath) => { + const dir = dirPath.toString() + if (dir.endsWith("/.roo/hooks")) { + return [{ name: "hooks.yaml", isFile: () => true, isDirectory: () => false }] + } + throw { code: "ENOENT" } + }) + mockFsPromises.readFile.mockImplementation(async (filePath) => { + if (filePath.toString().includes("/project/.roo")) { + return projectYaml + } + throw { code: "ENOENT" } + }) + + const result = await loadHooksConfig({ cwd: "/project" }) + + expect(result.snapshot.hasProjectHooks).toBe(true) + }) + }) + + describe("getHooksForEvent", () => { + const createSnapshot = ( + hooks: Array<{ id: string; event: HookEventType; command: string }>, + ): HooksConfigSnapshot => { + const hooksByEvent = new Map() + const hooksById = new Map() + + for (const h of hooks) { + const hook = { ...h, enabled: true, _runtimeDisabled: false } + if (!hooksByEvent.has(h.event)) { + hooksByEvent.set(h.event, []) + } + hooksByEvent.get(h.event)!.push(hook) + hooksById.set(h.id, hook) + } + + return { + hooksByEvent, + hooksById, + hasProjectHooks: false, + loadedAt: new Date(), + disabledHookIds: new Set(), + } + } + + it("should return hooks for specific event", () => { + const snapshot = createSnapshot([ + { id: "hook1", event: "PreToolUse", command: "./a.sh" }, + { id: "hook2", event: "PostToolUse", command: "./b.sh" }, + ]) + + const result = getHooksForEvent(snapshot, "PreToolUse") + + expect(result).toHaveLength(1) + expect(result[0].id).toBe("hook1") + }) + + it("should exclude disabled hooks", () => { + const snapshot = createSnapshot([{ id: "hook1", event: "PreToolUse", command: "./a.sh" }]) + // Manually disable the hook + snapshot.hooksByEvent.get("PreToolUse")![0].enabled = false + + const result = getHooksForEvent(snapshot, "PreToolUse") + + expect(result).toHaveLength(0) + }) + + it("should exclude runtime-disabled hooks", () => { + const snapshot = createSnapshot([{ id: "hook1", event: "PreToolUse", command: "./a.sh" }]) + // Add hook ID to disabled set + snapshot.disabledHookIds.add("hook1") + + const result = getHooksForEvent(snapshot, "PreToolUse") + + expect(result).toHaveLength(0) + }) + + it("should return empty array for events with no hooks", () => { + const snapshot = createSnapshot([]) + + const result = getHooksForEvent(snapshot, "Notification") + + expect(result).toHaveLength(0) + }) + }) + + describe("getHookById", () => { + it("should return hook by ID", () => { + const snapshot: HooksConfigSnapshot = { + hooksByEvent: new Map(), + hooksById: new Map([["my-hook", { id: "my-hook", command: "./test.sh" } as any]]), + hasProjectHooks: false, + loadedAt: new Date(), + disabledHookIds: new Set(), + } + + const result = getHookById(snapshot, "my-hook") + + expect(result).toBeDefined() + expect(result!.id).toBe("my-hook") + }) + + it("should return undefined for non-existent hook", () => { + const snapshot: HooksConfigSnapshot = { + hooksByEvent: new Map(), + hooksById: new Map(), + hasProjectHooks: false, + loadedAt: new Date(), + disabledHookIds: new Set(), + } + + const result = getHookById(snapshot, "non-existent") + + expect(result).toBeUndefined() + }) + }) +}) diff --git a/src/services/hooks/__tests__/HookExecutor.spec.ts b/src/services/hooks/__tests__/HookExecutor.spec.ts new file mode 100644 index 00000000000..71482d17734 --- /dev/null +++ b/src/services/hooks/__tests__/HookExecutor.spec.ts @@ -0,0 +1,542 @@ +/** + * Tests for HookExecutor + * + * Covers: + * - Exit code handling (0=success, 2=block, other=error) + * - Timeout behavior + * - Environment variable setup + * - stdin JSON payload + * - Blocking vs non-blocking events + */ + +import { spawn } from "child_process" +import { executeHook, interpretResult, describeResult } from "../HookExecutor" +import type { ResolvedHook, HookContext, HookExecutionResult, HookEventType } from "../types" + +// Mock child_process +vi.mock("child_process", () => ({ + spawn: vi.fn(), +})) + +const mockSpawn = vi.mocked(spawn) + +describe("HookExecutor", () => { + const createMockHook = (overrides: Partial = {}): ResolvedHook => + ({ + id: "test-hook", + matcher: "*", + enabled: true, + command: "echo test", + timeout: 5, + source: "project", + event: "PreToolUse" as HookEventType, + filePath: "/test/hooks.yaml", + includeConversationHistory: false, + ...overrides, + }) as ResolvedHook + + const createMockContext = (overrides: Partial = {}): HookContext => ({ + event: "PreToolUse", + timestamp: "2026-01-16T12:00:00Z", + session: { + taskId: "task_123", + sessionId: "session_456", + mode: "code", + }, + project: { + directory: "/project", + name: "test-project", + }, + tool: { + name: "Write", + input: { filePath: "/src/index.ts", content: "// test" }, + }, + ...overrides, + }) + + describe("interpretResult", () => { + it("should interpret exit code 0 as success", () => { + const result: HookExecutionResult = { + hook: createMockHook(), + exitCode: 0, + stdout: "", + stderr: "", + duration: 100, + timedOut: false, + } + + const interpretation = interpretResult(result) + + expect(interpretation.success).toBe(true) + expect(interpretation.blocked).toBe(false) + expect(interpretation.shouldContinue).toBe(true) + }) + + it("should interpret exit code 2 as block for blocking events", () => { + const result: HookExecutionResult = { + hook: createMockHook({ event: "PreToolUse" }), + exitCode: 2, + stdout: "", + stderr: "Lint errors found", + duration: 100, + timedOut: false, + } + + const interpretation = interpretResult(result) + + expect(interpretation.success).toBe(false) + expect(interpretation.blocked).toBe(true) + expect(interpretation.blockMessage).toBe("Lint errors found") + expect(interpretation.shouldContinue).toBe(false) + }) + + it("should NOT block for non-blocking events even with exit code 2", () => { + const result: HookExecutionResult = { + hook: createMockHook({ event: "PostToolUse" }), + exitCode: 2, + stdout: "", + stderr: "Some error", + duration: 100, + timedOut: false, + } + + const interpretation = interpretResult(result) + + expect(interpretation.blocked).toBe(false) + expect(interpretation.shouldContinue).toBe(true) + }) + + it("should interpret other non-zero codes as error (continue)", () => { + const result: HookExecutionResult = { + hook: createMockHook(), + exitCode: 1, + stdout: "", + stderr: "Command failed", + duration: 100, + timedOut: false, + } + + const interpretation = interpretResult(result) + + expect(interpretation.success).toBe(false) + expect(interpretation.blocked).toBe(false) + expect(interpretation.shouldContinue).toBe(true) + }) + + it("should handle timeout (continue)", () => { + const result: HookExecutionResult = { + hook: createMockHook(), + exitCode: null, + stdout: "", + stderr: "", + duration: 5000, + timedOut: true, + } + + const interpretation = interpretResult(result) + + expect(interpretation.success).toBe(false) + expect(interpretation.blocked).toBe(false) + expect(interpretation.shouldContinue).toBe(true) + }) + + it("should handle execution error (continue)", () => { + const result: HookExecutionResult = { + hook: createMockHook(), + exitCode: null, + stdout: "", + stderr: "", + duration: 10, + timedOut: false, + error: new Error("Command not found"), + } + + const interpretation = interpretResult(result) + + expect(interpretation.success).toBe(false) + expect(interpretation.blocked).toBe(false) + expect(interpretation.shouldContinue).toBe(true) + }) + + describe("blocking events", () => { + const blockingEvents: HookEventType[] = [ + "PreToolUse", + "PermissionRequest", + "UserPromptSubmit", + "Stop", + "SubagentStop", + ] + + for (const event of blockingEvents) { + it(`should allow blocking for ${event}`, () => { + const result: HookExecutionResult = { + hook: createMockHook({ event }), + exitCode: 2, + stdout: "", + stderr: "Blocked", + duration: 100, + timedOut: false, + } + + const interpretation = interpretResult(result) + expect(interpretation.blocked).toBe(true) + }) + } + }) + + describe("non-blocking events", () => { + const nonBlockingEvents: HookEventType[] = [ + "PostToolUse", + "PostToolUseFailure", + "SubagentStart", + "SessionStart", + "SessionEnd", + "Notification", + "PreCompact", + ] + + for (const event of nonBlockingEvents) { + it(`should NOT block for ${event}`, () => { + const result: HookExecutionResult = { + hook: createMockHook({ event }), + exitCode: 2, + stdout: "", + stderr: "Attempted block", + duration: 100, + timedOut: false, + } + + const interpretation = interpretResult(result) + expect(interpretation.blocked).toBe(false) + }) + } + }) + }) + + describe("describeResult", () => { + it("should describe successful execution", () => { + const result: HookExecutionResult = { + hook: createMockHook({ id: "my-hook" }), + exitCode: 0, + stdout: "", + stderr: "", + duration: 150, + timedOut: false, + } + + const description = describeResult(result) + + expect(description).toContain("my-hook") + expect(description).toContain("successfully") + expect(description).toContain("150ms") + }) + + it("should describe blocked execution", () => { + const result: HookExecutionResult = { + hook: createMockHook({ id: "blocker" }), + exitCode: 2, + stdout: "", + stderr: "Policy violation", + duration: 100, + timedOut: false, + } + + const description = describeResult(result) + + expect(description).toContain("blocker") + expect(description).toContain("blocked") + expect(description).toContain("Policy violation") + }) + + it("should describe timeout", () => { + const result: HookExecutionResult = { + hook: createMockHook({ id: "slow-hook", timeout: 30 }), + exitCode: null, + stdout: "", + stderr: "", + duration: 30000, + timedOut: true, + } + + const description = describeResult(result) + + expect(description).toContain("slow-hook") + expect(description).toContain("timed out") + expect(description).toContain("30") + }) + + it("should describe execution error", () => { + const result: HookExecutionResult = { + hook: createMockHook({ id: "broken" }), + exitCode: null, + stdout: "", + stderr: "", + duration: 10, + timedOut: false, + error: new Error("Command not found: badcmd"), + } + + const description = describeResult(result) + + expect(description).toContain("broken") + expect(description).toContain("failed") + expect(description).toContain("Command not found") + }) + }) + + describe("executeHook", () => { + beforeEach(() => { + vi.clearAllMocks() + }) + + it("should spawn process with correct arguments", async () => { + const mockProcess = { + stdin: { write: vi.fn(), end: vi.fn() }, + stdout: { on: vi.fn() }, + stderr: { on: vi.fn() }, + on: vi.fn((event, cb) => { + if (event === "close") { + setTimeout(() => cb(0), 10) + } + }), + kill: vi.fn(), + killed: false, + } + mockSpawn.mockReturnValue(mockProcess as any) + + const hook = createMockHook({ command: "./test-script.sh" }) + const context = createMockContext() + + const resultPromise = executeHook(hook, context) + + // Wait a tick for the spawn to be called + await new Promise((r) => setTimeout(r, 0)) + + expect(mockSpawn).toHaveBeenCalled() + const [shell, args, options] = mockSpawn.mock.calls[0] + + // Should use shell with -c flag (or PowerShell equivalent) + expect(args[args.length - 1]).toBe("./test-script.sh") + expect(options.cwd).toBe("/project") + + const result = await resultPromise + expect(result.exitCode).toBe(0) + }) + + it("should write JSON context to stdin", async () => { + const stdinWrite = vi.fn() + const mockProcess = { + stdin: { write: stdinWrite, end: vi.fn() }, + stdout: { on: vi.fn() }, + stderr: { on: vi.fn() }, + on: vi.fn((event, cb) => { + if (event === "close") { + setTimeout(() => cb(0), 10) + } + }), + kill: vi.fn(), + killed: false, + } + mockSpawn.mockReturnValue(mockProcess as any) + + const hook = createMockHook() + const context = createMockContext() + + await executeHook(hook, context) + + expect(stdinWrite).toHaveBeenCalled() + const jsonPayload = stdinWrite.mock.calls[0][0] + const parsed = JSON.parse(jsonPayload) + + expect(parsed.event).toBe("PreToolUse") + expect(parsed.session.taskId).toBe("task_123") + expect(parsed.project.directory).toBe("/project") + expect(parsed.tool.name).toBe("Write") + }) + + it("should set environment variables", async () => { + const mockProcess = { + stdin: { write: vi.fn(), end: vi.fn() }, + stdout: { on: vi.fn() }, + stderr: { on: vi.fn() }, + on: vi.fn((event, cb) => { + if (event === "close") { + setTimeout(() => cb(0), 10) + } + }), + kill: vi.fn(), + killed: false, + } + mockSpawn.mockReturnValue(mockProcess as any) + + const hook = createMockHook({ id: "env-test" }) + const context = createMockContext() + + await executeHook(hook, context) + + const options = mockSpawn.mock.calls[0][2] + const env = options.env + + expect(env).toBeDefined() + if (!env) throw new Error("Expected env to be captured") + + expect(env.ROO_PROJECT_DIR).toBe("/project") + expect(env.ROO_TASK_ID).toBe("task_123") + expect(env.ROO_SESSION_ID).toBe("session_456") + expect(env.ROO_MODE).toBe("code") + expect(env.ROO_TOOL_NAME).toBe("Write") + expect(env.ROO_EVENT).toBe("PreToolUse") + expect(env.ROO_HOOK_ID).toBe("env-test") + }) + + it("should NOT include conversation history by default", async () => { + const stdinWrite = vi.fn() + const mockProcess = { + stdin: { write: stdinWrite, end: vi.fn() }, + stdout: { on: vi.fn() }, + stderr: { on: vi.fn() }, + on: vi.fn((event, cb) => { + if (event === "close") { + setTimeout(() => cb(0), 10) + } + }), + kill: vi.fn(), + killed: false, + } + mockSpawn.mockReturnValue(mockProcess as any) + + const hook = createMockHook({ includeConversationHistory: false }) + const context = createMockContext() + const history = [{ role: "user" as const, content: "Hello" }] + + await executeHook(hook, context, history) + + const jsonPayload = stdinWrite.mock.calls[0][0] + const parsed = JSON.parse(jsonPayload) + + expect(parsed.conversationHistory).toBeUndefined() + }) + + it("should include conversation history when opted in", async () => { + const stdinWrite = vi.fn() + const mockProcess = { + stdin: { write: stdinWrite, end: vi.fn() }, + stdout: { on: vi.fn() }, + stderr: { on: vi.fn() }, + on: vi.fn((event, cb) => { + if (event === "close") { + setTimeout(() => cb(0), 10) + } + }), + kill: vi.fn(), + killed: false, + } + mockSpawn.mockReturnValue(mockProcess as any) + + const hook = createMockHook({ includeConversationHistory: true }) + const context = createMockContext() + const history = [{ role: "user" as const, content: "Hello" }] + + await executeHook(hook, context, history) + + const jsonPayload = stdinWrite.mock.calls[0][0] + const parsed = JSON.parse(jsonPayload) + + expect(parsed.conversationHistory).toBeDefined() + expect(parsed.conversationHistory).toHaveLength(1) + }) + + it("should capture stdout and stderr", async () => { + let stdoutCallback: ((data: Buffer) => void) | undefined + let stderrCallback: ((data: Buffer) => void) | undefined + + const mockProcess = { + stdin: { write: vi.fn(), end: vi.fn() }, + stdout: { + on: vi.fn((event, cb) => { + if (event === "data") stdoutCallback = cb + }), + }, + stderr: { + on: vi.fn((event, cb) => { + if (event === "data") stderrCallback = cb + }), + }, + on: vi.fn((event, cb) => { + if (event === "close") { + setTimeout(() => { + stdoutCallback?.(Buffer.from("stdout content")) + stderrCallback?.(Buffer.from("stderr content")) + cb(0) + }, 10) + } + }), + kill: vi.fn(), + killed: false, + } + mockSpawn.mockReturnValue(mockProcess as any) + + const result = await executeHook(createMockHook(), createMockContext()) + + expect(result.stdout).toContain("stdout content") + expect(result.stderr).toContain("stderr content") + }) + + it("should handle process spawn errors", async () => { + const mockProcess = { + stdin: null, + stdout: { on: vi.fn() }, + stderr: { on: vi.fn() }, + on: vi.fn((event, cb) => { + if (event === "error") { + setTimeout(() => cb(new Error("spawn ENOENT")), 10) + } + }), + kill: vi.fn(), + killed: false, + } + mockSpawn.mockReturnValue(mockProcess as any) + + const result = await executeHook(createMockHook(), createMockContext()) + + expect(result.error).toBeDefined() + expect(result.error?.message).toContain("ENOENT") + }) + + it("should parse modification JSON from stdout for PreToolUse", async () => { + let stdoutCallback: ((data: Buffer) => void) | undefined + + const modificationJson = JSON.stringify({ + action: "modify", + toolInput: { filePath: "/modified/path.ts", content: "// modified" }, + }) + + const mockProcess = { + stdin: { write: vi.fn(), end: vi.fn() }, + stdout: { + on: vi.fn((event, cb) => { + if (event === "data") stdoutCallback = cb + }), + }, + stderr: { on: vi.fn() }, + on: vi.fn((event, cb) => { + if (event === "close") { + setTimeout(() => { + stdoutCallback?.(Buffer.from(modificationJson)) + cb(0) + }, 10) + } + }), + kill: vi.fn(), + killed: false, + } + mockSpawn.mockReturnValue(mockProcess as any) + + const result = await executeHook(createMockHook({ event: "PreToolUse" }), createMockContext()) + + expect(result.modification).toBeDefined() + expect(result.modification?.action).toBe("modify") + expect(result.modification?.toolInput.filePath).toBe("/modified/path.ts") + }) + }) +}) diff --git a/src/services/hooks/__tests__/HookManager.spec.ts b/src/services/hooks/__tests__/HookManager.spec.ts new file mode 100644 index 00000000000..be49e5a2647 --- /dev/null +++ b/src/services/hooks/__tests__/HookManager.spec.ts @@ -0,0 +1,548 @@ +/** + * Tests for HookManager + * + * Covers: + * - Config loading and snapshot management + * - Sequential hook execution + * - Enable/disable functionality + * - Execution history tracking + */ + +import { HookManager, createHookManager } from "../HookManager" +import * as HookConfigLoader from "../HookConfigLoader" +import * as HookExecutor from "../HookExecutor" +import type { HooksConfigSnapshot, ResolvedHook, HookEventType, HookContext } from "../types" + +// Mock dependencies +vi.mock("../HookConfigLoader") +vi.mock("../HookExecutor") + +const mockLoadHooksConfig = vi.mocked(HookConfigLoader.loadHooksConfig) +const mockGetHooksForEvent = vi.mocked(HookConfigLoader.getHooksForEvent) +const mockExecuteHook = vi.mocked(HookExecutor.executeHook) +const mockInterpretResult = vi.mocked(HookExecutor.interpretResult) +const mockDescribeResult = vi.mocked(HookExecutor.describeResult) + +describe("HookManager", () => { + const createMockHook = (id: string, event: HookEventType = "PreToolUse"): ResolvedHook => + ({ + id, + matcher: "*", + enabled: true, + command: `echo ${id}`, + timeout: 60, + source: "project", + event, + filePath: "/test/hooks.yaml", + }) as ResolvedHook + + const createMockSnapshot = (hooks: ResolvedHook[] = []): HooksConfigSnapshot => { + const hooksByEvent = new Map() + const hooksById = new Map() + + for (const hook of hooks) { + if (!hooksByEvent.has(hook.event)) { + hooksByEvent.set(hook.event, []) + } + hooksByEvent.get(hook.event)!.push(hook) + hooksById.set(hook.id, hook) + } + + return { + hooksByEvent, + hooksById, + loadedAt: new Date(), + disabledHookIds: new Set(), + hasProjectHooks: hooks.some((h) => h.source === "project"), + } + } + + beforeEach(() => { + vi.clearAllMocks() + mockDescribeResult.mockReturnValue("Hook executed") + }) + + describe("loadHooksConfig", () => { + it("should load config and return snapshot", async () => { + const mockSnapshot = createMockSnapshot([createMockHook("hook1")]) + mockLoadHooksConfig.mockResolvedValue({ + snapshot: mockSnapshot, + errors: [], + warnings: [], + }) + + const manager = createHookManager({ cwd: "/project" }) + const snapshot = await manager.loadHooksConfig() + + expect(mockLoadHooksConfig).toHaveBeenCalledWith({ cwd: "/project", mode: undefined }) + expect(snapshot).toBe(mockSnapshot) + }) + + it("should pass mode to config loader", async () => { + const mockSnapshot = createMockSnapshot([]) + mockLoadHooksConfig.mockResolvedValue({ + snapshot: mockSnapshot, + errors: [], + warnings: [], + }) + + const manager = createHookManager({ cwd: "/project", mode: "code" }) + await manager.loadHooksConfig() + + expect(mockLoadHooksConfig).toHaveBeenCalledWith({ cwd: "/project", mode: "code" }) + }) + + it("should log errors and warnings", async () => { + const mockSnapshot = createMockSnapshot([]) + const errorLog: string[] = [] + const warnLog: string[] = [] + + mockLoadHooksConfig.mockResolvedValue({ + snapshot: mockSnapshot, + errors: ["Config error 1"], + warnings: ["Warning 1"], + }) + + const manager = createHookManager({ + cwd: "/project", + logger: { + debug: vi.fn(), + info: vi.fn(), + warn: (msg) => warnLog.push(msg), + error: (msg) => errorLog.push(msg), + }, + }) + + await manager.loadHooksConfig() + + expect(errorLog.some((e) => e.includes("Config error 1"))).toBe(true) + expect(warnLog.some((w) => w.includes("Warning 1"))).toBe(true) + }) + }) + + describe("reloadHooksConfig", () => { + it("should reload config while preserving disabled hooks", async () => { + const hook1 = createMockHook("hook1") + const hook2 = createMockHook("hook2") + + // Initial load + const initialSnapshot = createMockSnapshot([hook1, hook2]) + mockLoadHooksConfig.mockResolvedValueOnce({ + snapshot: initialSnapshot, + errors: [], + warnings: [], + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + // Disable hook2 + await manager.setHookEnabled("hook2", false) + + // Reload with same hooks + const reloadedSnapshot = createMockSnapshot([hook1, hook2]) + mockLoadHooksConfig.mockResolvedValueOnce({ + snapshot: reloadedSnapshot, + errors: [], + warnings: [], + }) + + await manager.reloadHooksConfig() + + const snapshot = manager.getConfigSnapshot() + expect(snapshot?.disabledHookIds.has("hook2")).toBe(true) + }) + }) + + describe("executeHooks", () => { + const createMockContext = (): HookContext => ({ + event: "PreToolUse", + timestamp: "2026-01-16T12:00:00Z", + session: { taskId: "task_1", sessionId: "session_1", mode: "code" }, + project: { directory: "/project", name: "test" }, + tool: { name: "Write", input: { filePath: "/test.ts", content: "test" } }, + }) + + it("should execute hooks sequentially", async () => { + const hook1 = createMockHook("hook1") + const hook2 = createMockHook("hook2") + const snapshot = createMockSnapshot([hook1, hook2]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + mockGetHooksForEvent.mockReturnValue([hook1, hook2]) + mockExecuteHook.mockResolvedValue({ + hook: hook1, + exitCode: 0, + stdout: "", + stderr: "", + duration: 100, + timedOut: false, + }) + mockInterpretResult.mockReturnValue({ + success: true, + blocked: false, + blockMessage: undefined, + shouldContinue: true, + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + const result = await manager.executeHooks("PreToolUse", { context: createMockContext() }) + + // Should execute both hooks + expect(mockExecuteHook).toHaveBeenCalledTimes(2) + expect(result.results).toHaveLength(2) + expect(result.blocked).toBe(false) + }) + + it("should stop execution when a hook blocks", async () => { + const hook1 = createMockHook("blocker") + const hook2 = createMockHook("after-block") + const snapshot = createMockSnapshot([hook1, hook2]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + mockGetHooksForEvent.mockReturnValue([hook1, hook2]) + mockExecuteHook.mockResolvedValue({ + hook: hook1, + exitCode: 2, + stdout: "", + stderr: "Blocked!", + duration: 100, + timedOut: false, + }) + mockInterpretResult.mockReturnValue({ + success: false, + blocked: true, + blockMessage: "Blocked!", + shouldContinue: false, + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + const result = await manager.executeHooks("PreToolUse", { context: createMockContext() }) + + // Should only execute first hook (the blocker) + expect(mockExecuteHook).toHaveBeenCalledTimes(1) + expect(result.results).toHaveLength(1) + expect(result.blocked).toBe(true) + expect(result.blockMessage).toBe("Blocked!") + }) + + it("should continue on non-blocking failures", async () => { + const hook1 = createMockHook("failing") + const hook2 = createMockHook("after-fail") + const snapshot = createMockSnapshot([hook1, hook2]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + mockGetHooksForEvent.mockReturnValue([hook1, hook2]) + + let callCount = 0 + mockExecuteHook.mockImplementation(async (hook) => ({ + hook, + exitCode: callCount++ === 0 ? 1 : 0, + stdout: "", + stderr: callCount === 1 ? "Error" : "", + duration: 100, + timedOut: false, + })) + mockInterpretResult.mockImplementation((result) => ({ + success: result.exitCode === 0, + blocked: false, + blockMessage: undefined, + shouldContinue: true, + })) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + const result = await manager.executeHooks("PreToolUse", { context: createMockContext() }) + + // Should execute both hooks despite first failure + expect(mockExecuteHook).toHaveBeenCalledTimes(2) + expect(result.results).toHaveLength(2) + expect(result.blocked).toBe(false) + }) + + it("should return first modification only", async () => { + const hook1 = createMockHook("modifier1") + const hook2 = createMockHook("modifier2") + const snapshot = createMockSnapshot([hook1, hook2]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + mockGetHooksForEvent.mockReturnValue([hook1, hook2]) + + let callCount = 0 + mockExecuteHook.mockImplementation(async (hook) => ({ + hook, + exitCode: 0, + stdout: "", + stderr: "", + duration: 100, + timedOut: false, + modification: + callCount++ === 0 + ? { action: "modify" as const, toolInput: { from: "first" } } + : { action: "modify" as const, toolInput: { from: "second" } }, + })) + mockInterpretResult.mockReturnValue({ + success: true, + blocked: false, + blockMessage: undefined, + shouldContinue: true, + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + const result = await manager.executeHooks("PreToolUse", { context: createMockContext() }) + + expect(result.modification?.toolInput).toEqual({ from: "first" }) + }) + + it("should auto-load config if not loaded", async () => { + const hook1 = createMockHook("hook1") + const snapshot = createMockSnapshot([hook1]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + mockGetHooksForEvent.mockReturnValue([hook1]) + mockExecuteHook.mockResolvedValue({ + hook: hook1, + exitCode: 0, + stdout: "", + stderr: "", + duration: 100, + timedOut: false, + }) + mockInterpretResult.mockReturnValue({ + success: true, + blocked: false, + blockMessage: undefined, + shouldContinue: true, + }) + + const manager = createHookManager({ cwd: "/project" }) + // Don't call loadHooksConfig explicitly + + await manager.executeHooks("PreToolUse", { context: createMockContext() }) + + // Should have auto-loaded + expect(mockLoadHooksConfig).toHaveBeenCalled() + }) + }) + + describe("getEnabledHooks", () => { + it("should return all enabled hooks", async () => { + const hook1 = createMockHook("hook1") + const hook2 = createMockHook("hook2") + const disabledHook = { ...createMockHook("disabled"), enabled: false } as ResolvedHook + const snapshot = createMockSnapshot([hook1, hook2, disabledHook]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + const enabled = manager.getEnabledHooks() + + expect(enabled).toHaveLength(2) + expect(enabled.map((h) => h.id).sort()).toEqual(["hook1", "hook2"]) + }) + + it("should exclude runtime-disabled hooks", async () => { + const hook1 = createMockHook("hook1") + const hook2 = createMockHook("hook2") + const snapshot = createMockSnapshot([hook1, hook2]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + await manager.setHookEnabled("hook2", false) + + const enabled = manager.getEnabledHooks() + + expect(enabled).toHaveLength(1) + expect(enabled[0].id).toBe("hook1") + }) + }) + + describe("setHookEnabled", () => { + it("should disable a hook", async () => { + const hook1 = createMockHook("hook1") + const snapshot = createMockSnapshot([hook1]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + await manager.setHookEnabled("hook1", false) + + expect(manager.getConfigSnapshot()?.disabledHookIds.has("hook1")).toBe(true) + }) + + it("should re-enable a disabled hook", async () => { + const hook1 = createMockHook("hook1") + const snapshot = createMockSnapshot([hook1]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + await manager.setHookEnabled("hook1", false) + await manager.setHookEnabled("hook1", true) + + expect(manager.getConfigSnapshot()?.disabledHookIds.has("hook1")).toBe(false) + }) + + it("should throw for non-existent hook", async () => { + const snapshot = createMockSnapshot([]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + await expect(manager.setHookEnabled("nonexistent", false)).rejects.toThrow("Hook not found") + }) + }) + + describe("getHookExecutionHistory", () => { + it("should return execution history", async () => { + const hook1 = createMockHook("hook1") + const snapshot = createMockSnapshot([hook1]) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + mockGetHooksForEvent.mockReturnValue([hook1]) + mockExecuteHook.mockResolvedValue({ + hook: hook1, + exitCode: 0, + stdout: "", + stderr: "", + duration: 100, + timedOut: false, + }) + mockInterpretResult.mockReturnValue({ + success: true, + blocked: false, + blockMessage: undefined, + shouldContinue: true, + }) + + const manager = createHookManager({ cwd: "/project" }) + await manager.loadHooksConfig() + + await manager.executeHooks("PreToolUse", { + context: { + event: "PreToolUse", + timestamp: "2026-01-16T12:00:00Z", + session: { taskId: "task_1", sessionId: "session_1", mode: "code" }, + project: { directory: "/project", name: "test" }, + }, + }) + + const history = manager.getHookExecutionHistory() + + expect(history).toHaveLength(1) + expect(history[0].hook.id).toBe("hook1") + expect(history[0].event).toBe("PreToolUse") + }) + + it("should limit history size", async () => { + const hooks = Array.from({ length: 150 }, (_, i) => createMockHook(`hook${i}`)) + const snapshot = createMockSnapshot(hooks) + + mockLoadHooksConfig.mockResolvedValue({ + snapshot, + errors: [], + warnings: [], + }) + mockGetHooksForEvent.mockReturnValue(hooks) + mockExecuteHook.mockImplementation(async (hook) => ({ + hook, + exitCode: 0, + stdout: "", + stderr: "", + duration: 10, + timedOut: false, + })) + mockInterpretResult.mockReturnValue({ + success: true, + blocked: false, + blockMessage: undefined, + shouldContinue: true, + }) + + const manager = createHookManager({ cwd: "/project", maxHistoryEntries: 100 }) + await manager.loadHooksConfig() + + await manager.executeHooks("PreToolUse", { + context: { + event: "PreToolUse", + timestamp: "2026-01-16T12:00:00Z", + session: { taskId: "task_1", sessionId: "session_1", mode: "code" }, + project: { directory: "/project", name: "test" }, + }, + }) + + const history = manager.getHookExecutionHistory() + + expect(history.length).toBeLessThanOrEqual(100) + }) + }) + + describe("createHookManager", () => { + it("should create a HookManager instance", () => { + const manager = createHookManager({ cwd: "/project" }) + expect(manager).toBeInstanceOf(HookManager) + }) + }) +}) diff --git a/src/services/hooks/__tests__/HookMatcher.spec.ts b/src/services/hooks/__tests__/HookMatcher.spec.ts new file mode 100644 index 00000000000..e20c8f5b092 --- /dev/null +++ b/src/services/hooks/__tests__/HookMatcher.spec.ts @@ -0,0 +1,327 @@ +/** + * Tests for HookMatcher + * + * Covers: + * - Exact matching + * - Regex pattern matching + * - Glob pattern matching + * - Match-all behavior + * - Cache behavior + */ + +import { vi } from "vitest" +import { compileMatcher, getMatcher, clearMatcherCache, filterMatchingHooks, hookMatchesTool } from "../HookMatcher" +import type { ResolvedHook } from "../types" + +describe("HookMatcher", () => { + beforeEach(() => { + clearMatcherCache() + }) + + describe("compileMatcher", () => { + describe("match-all patterns", () => { + it('should match all tools with "*" pattern', () => { + const matcher = compileMatcher("*") + expect(matcher.type).toBe("all") + expect(matcher.matches("Write")).toBe(true) + expect(matcher.matches("Read")).toBe(true) + expect(matcher.matches("Bash")).toBe(true) + expect(matcher.matches("anything")).toBe(true) + }) + + it("should match all tools with undefined pattern", () => { + const matcher = compileMatcher(undefined) + expect(matcher.type).toBe("all") + expect(matcher.matches("Write")).toBe(true) + expect(matcher.matches("Read")).toBe(true) + }) + + it("should match all tools with empty string pattern", () => { + const matcher = compileMatcher("") + expect(matcher.type).toBe("all") + expect(matcher.matches("Write")).toBe(true) + }) + }) + + describe("exact matching", () => { + it("should match exact tool name (case-insensitive)", () => { + const matcher = compileMatcher("Write") + expect(matcher.type).toBe("exact") + expect(matcher.matches("Write")).toBe(true) + expect(matcher.matches("write")).toBe(true) + expect(matcher.matches("WRITE")).toBe(true) + expect(matcher.matches("Read")).toBe(false) + }) + + it("should not match partial names", () => { + const matcher = compileMatcher("Write") + expect(matcher.matches("WriteFile")).toBe(false) + expect(matcher.matches("FileWrite")).toBe(false) + }) + }) + + describe("regex pattern matching", () => { + it("should match regex with pipe (|) alternation", () => { + const matcher = compileMatcher("Edit|Write") + expect(matcher.type).toBe("regex") + expect(matcher.matches("Edit")).toBe(true) + expect(matcher.matches("Write")).toBe(true) + expect(matcher.matches("Read")).toBe(false) + }) + + it("should match regex with character classes", () => { + const matcher = compileMatcher("File[RW].*") + expect(matcher.type).toBe("regex") + expect(matcher.matches("FileRead")).toBe(true) + expect(matcher.matches("FileWrite")).toBe(true) + expect(matcher.matches("FileDelete")).toBe(false) + }) + + it("should be case-insensitive", () => { + const matcher = compileMatcher("foo|bar") + expect(matcher.matches("FOO")).toBe(true) + expect(matcher.matches("BAR")).toBe(true) + }) + + it("should fall back to exact match on invalid regex", () => { + // Unclosed bracket is invalid regex + const matcher = compileMatcher("Edit[") + expect(matcher.type).toBe("exact") + expect(matcher.matches("Edit[")).toBe(true) + }) + }) + + describe("glob pattern matching", () => { + it("should match glob with * wildcard", () => { + const matcher = compileMatcher("mcp__*") + expect(matcher.type).toBe("glob") + expect(matcher.matches("mcp__tool1")).toBe(true) + expect(matcher.matches("mcp__server__action")).toBe(true) + expect(matcher.matches("mcp_")).toBe(false) + expect(matcher.matches("other_tool")).toBe(false) + }) + + it("should match glob with ? single-char wildcard", () => { + const matcher = compileMatcher("Tool?") + expect(matcher.type).toBe("glob") + expect(matcher.matches("Tool1")).toBe(true) + expect(matcher.matches("ToolA")).toBe(true) + expect(matcher.matches("Tool")).toBe(false) + expect(matcher.matches("Tool12")).toBe(false) + }) + + it("should match glob with * in middle", () => { + const matcher = compileMatcher("*File*") + expect(matcher.type).toBe("glob") + expect(matcher.matches("FileRead")).toBe(true) + expect(matcher.matches("ReadFile")).toBe(true) + expect(matcher.matches("ReadFileNow")).toBe(true) + expect(matcher.matches("Tool")).toBe(false) + }) + + it("should be case-insensitive", () => { + const matcher = compileMatcher("MCP__*") + expect(matcher.matches("mcp__tool")).toBe(true) + expect(matcher.matches("MCP__TOOL")).toBe(true) + }) + }) + + describe("group expansion", () => { + it('should expand "edit" group to all edit tools', () => { + const matcher = compileMatcher("edit") + expect(matcher.type).toBe("regex") + expect(matcher.matches("apply_diff")).toBe(true) + expect(matcher.matches("write_to_file")).toBe(true) + expect(matcher.matches("generate_image")).toBe(true) + expect(matcher.matches("search_and_replace")).toBe(true) + expect(matcher.matches("search_replace")).toBe(true) + expect(matcher.matches("edit_file")).toBe(true) + expect(matcher.matches("apply_patch")).toBe(true) + expect(matcher.matches("read_file")).toBe(false) + }) + + it('should expand "read" group to all read tools', () => { + const matcher = compileMatcher("read") + expect(matcher.matches("read_file")).toBe(true) + expect(matcher.matches("fetch_instructions")).toBe(true) + expect(matcher.matches("search_files")).toBe(true) + expect(matcher.matches("list_files")).toBe(true) + expect(matcher.matches("codebase_search")).toBe(true) + expect(matcher.matches("write_to_file")).toBe(false) + }) + + it('should expand "browser" group', () => { + const matcher = compileMatcher("browser") + expect(matcher.matches("browser_action")).toBe(true) + expect(matcher.matches("read_file")).toBe(false) + }) + + it('should expand "command" group', () => { + const matcher = compileMatcher("command") + expect(matcher.matches("execute_command")).toBe(true) + expect(matcher.matches("read_file")).toBe(false) + }) + + it('should expand "mcp" group', () => { + const matcher = compileMatcher("mcp") + expect(matcher.matches("use_mcp_tool")).toBe(true) + expect(matcher.matches("access_mcp_resource")).toBe(true) + expect(matcher.matches("read_file")).toBe(false) + }) + + it('should expand "modes" group', () => { + const matcher = compileMatcher("modes") + expect(matcher.matches("switch_mode")).toBe(true) + expect(matcher.matches("new_task")).toBe(true) + expect(matcher.matches("read_file")).toBe(false) + }) + + it("should be case insensitive for groups", () => { + const matcher = compileMatcher("EDIT") + expect(matcher.matches("apply_diff")).toBe(true) + expect(matcher.matches("write_to_file")).toBe(true) + }) + + it("should still work with individual tool names", () => { + const matcher = compileMatcher("read_file") + expect(matcher.matches("read_file")).toBe(true) + expect(matcher.matches("write_to_file")).toBe(false) + }) + + it("should expand single group name", () => { + const matcher = compileMatcher("edit") + expect(matcher.matches("apply_diff")).toBe(true) + expect(matcher.matches("write_to_file")).toBe(true) + expect(matcher.matches("read_file")).toBe(false) + }) + + it("should treat unknown groups as literal tool names", () => { + // Mock console.warn to capture warnings + const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {}) + + const matcher = compileMatcher("unknown_group") + expect(matcher.matches("unknown_group")).toBe(true) + expect(matcher.matches("read_file")).toBe(false) + + // Should have warned about unknown group + expect(consoleWarnSpy).toHaveBeenCalledWith( + expect.stringContaining('Unknown tool group "unknown_group"'), + ) + + consoleWarnSpy.mockRestore() + }) + + it("should not warn for glob patterns that look like groups", () => { + const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {}) + + const matcher = compileMatcher("edit*") + expect(matcher.type).toBe("glob") + expect(matcher.matches("edit_file")).toBe(true) + + // Should not warn because it contains * + expect(consoleWarnSpy).not.toHaveBeenCalled() + + consoleWarnSpy.mockRestore() + }) + }) + }) + + describe("getMatcher (caching)", () => { + it("should return same matcher for same pattern", () => { + const matcher1 = getMatcher("Write") + const matcher2 = getMatcher("Write") + expect(matcher1).toBe(matcher2) + }) + + it("should cache undefined as '*'", () => { + const matcher1 = getMatcher(undefined) + const matcher2 = getMatcher("*") + expect(matcher1).toBe(matcher2) + }) + + it("should return different matchers for different patterns", () => { + const matcher1 = getMatcher("Write") + const matcher2 = getMatcher("Read") + expect(matcher1).not.toBe(matcher2) + }) + }) + + describe("filterMatchingHooks", () => { + const createMockHook = (id: string, matcher?: string): ResolvedHook => + ({ + id, + matcher, + enabled: true, + command: "echo test", + timeout: 60, + source: "project", + event: "PreToolUse", + filePath: "/test/hooks.yaml", + }) as ResolvedHook + + it("should filter hooks by tool name", () => { + const hooks = [ + createMockHook("hook1", "Write"), + createMockHook("hook2", "Read"), + createMockHook("hook3", "Edit|Write"), + ] + + const matching = filterMatchingHooks(hooks, "Write") + expect(matching).toHaveLength(2) + expect(matching.map((h) => h.id)).toEqual(["hook1", "hook3"]) + }) + + it("should include match-all hooks", () => { + const hooks = [ + createMockHook("hook1", "*"), + createMockHook("hook2", undefined), + createMockHook("hook3", "Read"), + ] + + const matching = filterMatchingHooks(hooks, "Write") + expect(matching).toHaveLength(2) + expect(matching.map((h) => h.id)).toEqual(["hook1", "hook2"]) + }) + + it("should return empty array when no hooks match", () => { + const hooks = [createMockHook("hook1", "Read"), createMockHook("hook2", "Edit")] + + const matching = filterMatchingHooks(hooks, "Write") + expect(matching).toHaveLength(0) + }) + + it("should NOT treat Claude Code-style tool labels as Roo Code internal tool ids", () => { + // Roo Code hook matching is against tool ids like write_to_file/apply_diff. + // A Claude Code-style matcher like Write|Edit should not match apply_diff. + const hooks = [createMockHook("hook1", "Write|Edit")] + const matching = filterMatchingHooks(hooks, "apply_diff") + expect(matching).toHaveLength(0) + }) + }) + + describe("hookMatchesTool", () => { + const createMockHook = (matcher?: string): ResolvedHook => + ({ + id: "test", + matcher, + enabled: true, + command: "echo test", + timeout: 60, + source: "project", + event: "PreToolUse", + filePath: "/test/hooks.yaml", + }) as ResolvedHook + + it("should return true for matching hook", () => { + expect(hookMatchesTool(createMockHook("Write"), "Write")).toBe(true) + }) + + it("should return false for non-matching hook", () => { + expect(hookMatchesTool(createMockHook("Read"), "Write")).toBe(false) + }) + + it("should return true for match-all hook", () => { + expect(hookMatchesTool(createMockHook("*"), "AnyTool")).toBe(true) + }) + }) +}) diff --git a/src/services/hooks/__tests__/ToolExecutionHooks.spec.ts b/src/services/hooks/__tests__/ToolExecutionHooks.spec.ts new file mode 100644 index 00000000000..9c511586b34 --- /dev/null +++ b/src/services/hooks/__tests__/ToolExecutionHooks.spec.ts @@ -0,0 +1,224 @@ +/** + * Tests for ToolExecutionHooks + * + * Covers: + * - Master toggle (hooksEnabled) enforcement + * - Pre/Post tool use hook execution + * - Permission request hooks + * - Backwards compatibility when no getter is provided + */ + +import { + ToolExecutionHooks, + createToolExecutionHooks, + type ToolExecutionContext, + type HookStatusCallback, + type SayCallback, + type HooksEnabledGetter, +} from "../ToolExecutionHooks" +import type { IHookManager, HooksExecutionResult, HooksConfigSnapshot } from "../types" + +describe("ToolExecutionHooks", () => { + // Mock IHookManager + const createMockHookManager = (): IHookManager => ({ + loadHooksConfig: vi.fn(), + reloadHooksConfig: vi.fn(), + getConfigSnapshot: vi.fn().mockReturnValue({} as HooksConfigSnapshot), + executeHooks: vi.fn().mockResolvedValue({ + results: [], + blocked: false, + totalDuration: 100, + } as HooksExecutionResult), + setHookEnabled: vi.fn(), + updateHook: vi.fn(), + getEnabledHooks: vi.fn().mockReturnValue([]), + getHookExecutionHistory: vi.fn().mockReturnValue([]), + }) + + const createMockContext = (): ToolExecutionContext => ({ + toolName: "Write", + toolInput: { filePath: "/test/file.ts", content: "test" }, + session: { taskId: "task_1", sessionId: "session_1", mode: "code" }, + project: { directory: "/test/project", name: "test-project" }, + }) + + describe("Master toggle (hooksEnabled) enforcement", () => { + it("should not execute hooks when hooksEnabledGetter returns false", async () => { + const mockManager = createMockHookManager() + const hooksEnabledGetter: HooksEnabledGetter = () => false + + const hooks = new ToolExecutionHooks(mockManager, undefined, undefined, hooksEnabledGetter) + + const result = await hooks.executePreToolUse(createMockContext()) + + expect(result.proceed).toBe(true) + expect(result.hookResult.results).toEqual([]) + expect(result.hookResult.totalDuration).toBe(0) + expect(mockManager.executeHooks).not.toHaveBeenCalled() + }) + + it("should execute hooks when hooksEnabledGetter returns true", async () => { + const mockManager = createMockHookManager() + const hooksEnabledGetter: HooksEnabledGetter = () => true + + const hooks = new ToolExecutionHooks(mockManager, undefined, undefined, hooksEnabledGetter) + + await hooks.executePreToolUse(createMockContext()) + + expect(mockManager.executeHooks).toHaveBeenCalledWith("PreToolUse", expect.any(Object)) + }) + + it("should default to enabled when no getter is provided (backwards compatibility)", async () => { + const mockManager = createMockHookManager() + + // No hooksEnabledGetter provided + const hooks = new ToolExecutionHooks(mockManager, undefined, undefined, undefined) + + await hooks.executePreToolUse(createMockContext()) + + expect(mockManager.executeHooks).toHaveBeenCalled() + }) + + it("should not execute PostToolUse hooks when disabled", async () => { + const mockManager = createMockHookManager() + const hooksEnabledGetter: HooksEnabledGetter = () => false + + const hooks = new ToolExecutionHooks(mockManager, undefined, undefined, hooksEnabledGetter) + + const result = await hooks.executePostToolUse(createMockContext(), "output", 100) + + expect(result.results).toEqual([]) + expect(result.totalDuration).toBe(0) + expect(mockManager.executeHooks).not.toHaveBeenCalled() + }) + + it("should not execute PostToolUseFailure hooks when disabled", async () => { + const mockManager = createMockHookManager() + const hooksEnabledGetter: HooksEnabledGetter = () => false + + const hooks = new ToolExecutionHooks(mockManager, undefined, undefined, hooksEnabledGetter) + + const result = await hooks.executePostToolUseFailure(createMockContext(), "error", "error message") + + expect(result.results).toEqual([]) + expect(result.totalDuration).toBe(0) + expect(mockManager.executeHooks).not.toHaveBeenCalled() + }) + + it("should not execute PermissionRequest hooks when disabled", async () => { + const mockManager = createMockHookManager() + const hooksEnabledGetter: HooksEnabledGetter = () => false + + const hooks = new ToolExecutionHooks(mockManager, undefined, undefined, hooksEnabledGetter) + + const result = await hooks.executePermissionRequest(createMockContext()) + + expect(result.proceed).toBe(true) + expect(result.hookResult.results).toEqual([]) + expect(result.hookResult.totalDuration).toBe(0) + expect(mockManager.executeHooks).not.toHaveBeenCalled() + }) + + it("hasHooks should return false when disabled", () => { + const mockManager = createMockHookManager() + const hooksEnabledGetter: HooksEnabledGetter = () => false + + const hooks = new ToolExecutionHooks(mockManager, undefined, undefined, hooksEnabledGetter) + + expect(hooks.hasHooks()).toBe(false) + }) + + it("hasHooks should return true when enabled and manager has config", () => { + const mockManager = createMockHookManager() + const hooksEnabledGetter: HooksEnabledGetter = () => true + + const hooks = new ToolExecutionHooks(mockManager, undefined, undefined, hooksEnabledGetter) + + expect(hooks.hasHooks()).toBe(true) + }) + }) + + describe("createToolExecutionHooks factory", () => { + it("should create instance with hooksEnabledGetter", async () => { + const mockManager = createMockHookManager() + const hooksEnabledGetter: HooksEnabledGetter = () => false + + const hooks = createToolExecutionHooks(mockManager, undefined, undefined, hooksEnabledGetter) + + // Verify hooks don't execute when disabled + await hooks.executePreToolUse(createMockContext()) + expect(mockManager.executeHooks).not.toHaveBeenCalled() + }) + + it("should work without hooksEnabledGetter for backwards compatibility", async () => { + const mockManager = createMockHookManager() + + const hooks = createToolExecutionHooks(mockManager, undefined, undefined) + + await hooks.executePreToolUse(createMockContext()) + expect(mockManager.executeHooks).toHaveBeenCalled() + }) + }) + + describe("setHooksEnabledGetter", () => { + it("should allow updating the getter after construction", async () => { + const mockManager = createMockHookManager() + + const hooks = new ToolExecutionHooks(mockManager, undefined, undefined, () => true) + + // First call with enabled + await hooks.executePreToolUse(createMockContext()) + expect(mockManager.executeHooks).toHaveBeenCalledTimes(1) + + // Update getter to disabled + hooks.setHooksEnabledGetter(() => false) + + // Second call with disabled + await hooks.executePreToolUse(createMockContext()) + expect(mockManager.executeHooks).toHaveBeenCalledTimes(1) // Still 1, no new call + }) + }) + + describe("No hook manager", () => { + it("should return default results when hookManager is null", async () => { + const hooks = new ToolExecutionHooks(null, undefined, undefined, () => true) + + const result = await hooks.executePreToolUse(createMockContext()) + + expect(result.proceed).toBe(true) + expect(result.hookResult.results).toEqual([]) + }) + + it("hasHooks should return false when hookManager is null", () => { + const hooks = new ToolExecutionHooks(null, undefined, undefined, () => true) + + expect(hooks.hasHooks()).toBe(false) + }) + }) + + describe("Status callback", () => { + it("should not emit status when disabled", async () => { + const mockManager = createMockHookManager() + const statusCallback: HookStatusCallback = vi.fn() + const hooksEnabledGetter: HooksEnabledGetter = () => false + + const hooks = new ToolExecutionHooks(mockManager, statusCallback, undefined, hooksEnabledGetter) + + await hooks.executePreToolUse(createMockContext()) + + expect(statusCallback).not.toHaveBeenCalled() + }) + + it("should emit status when enabled", async () => { + const mockManager = createMockHookManager() + const statusCallback: HookStatusCallback = vi.fn() + const hooksEnabledGetter: HooksEnabledGetter = () => true + + const hooks = new ToolExecutionHooks(mockManager, statusCallback, undefined, hooksEnabledGetter) + + await hooks.executePreToolUse(createMockContext()) + + expect(statusCallback).toHaveBeenCalled() + }) + }) +}) diff --git a/src/services/hooks/index.ts b/src/services/hooks/index.ts new file mode 100644 index 00000000000..538dc7e1989 --- /dev/null +++ b/src/services/hooks/index.ts @@ -0,0 +1,105 @@ +/** + * Hooks Service + * + * Provides Claude Code-style hooks for Roo Code. + * Hooks allow users to run custom shell commands at key lifecycle events. + * + * @example + * ```typescript + * import { createHookManager, HookEventType } from './services/hooks' + * + * const hookManager = createHookManager({ + * cwd: '/path/to/project', + * mode: 'code' + * }) + * + * // Load configuration + * await hookManager.loadHooksConfig() + * + * // Execute hooks for an event + * const result = await hookManager.executeHooks('PreToolUse', { + * context: { + * event: 'PreToolUse', + * timestamp: new Date().toISOString(), + * session: { taskId: 'task_1', sessionId: 'session_1', mode: 'code' }, + * project: { directory: '/path/to/project', name: 'my-project' }, + * tool: { name: 'Write', input: { filePath: '/src/index.ts', content: '...' } } + * } + * }) + * + * if (result.blocked) { + * console.log('Hook blocked:', result.blockMessage) + * } + * ``` + */ + +// Types +export { + // Event types + HookEventType, + BLOCKING_EVENTS, + isBlockingEvent, + + // Schema types + HookDefinitionSchema, + HooksConfigFileSchema, + HookModificationSchema, + + // Type definitions + type HookDefinition, + type HooksConfigFile, + type HookSource, + type ResolvedHook, + type HooksConfigSnapshot, + + // Context types + type HookContext, + type HookSessionContext, + type HookProjectContext, + type HookToolContext, + type HookPromptContext, + type HookNotificationContext, + type ConversationHistoryEntry, + + // Execution types + HookExitCode, + type HookExecutionResult, + type HooksExecutionResult, + type HookModification, + type HookExecution, + type ExecuteHooksOptions, + + // Manager interface + type IHookManager, +} from "./types" + +// Config loader +export { + loadHooksConfig, + getHooksForEvent, + getHookById, + type LoadHooksConfigOptions, + type LoadHooksConfigResult, +} from "./HookConfigLoader" + +// Matcher +export { compileMatcher, getMatcher, clearMatcherCache, filterMatchingHooks, hookMatchesTool } from "./HookMatcher" + +// Executor +export { executeHook, interpretResult, describeResult } from "./HookExecutor" + +// Manager +export { HookManager, createHookManager, type HookManagerOptions } from "./HookManager" + +// Config Writer +export { updateHookConfig } from "./HookConfigWriter" + +// Tool Execution Integration +export { + ToolExecutionHooks, + createToolExecutionHooks, + type ToolExecutionContext, + type PreToolUseResult, + type PermissionRequestResult, + type HookStatusCallback, +} from "./ToolExecutionHooks" diff --git a/src/services/hooks/types.ts b/src/services/hooks/types.ts new file mode 100644 index 00000000000..664c2476dba --- /dev/null +++ b/src/services/hooks/types.ts @@ -0,0 +1,391 @@ +/** + * Hook System Types and Zod Schemas + * + * This module defines the configuration schema and types for the Roo Code hooks system. + * Compatible with Claude Code hook semantics. + */ + +import { z } from "zod" + +// ============================================================================ +// Hook Events +// ============================================================================ + +/** + * All supported hook event types. + * Blocking events can halt/modify execution via exit code 2. + * Non-blocking events are informational only. + */ +export const HookEventType = z.enum([ + "PreToolUse", // Before tool execution (blocking) + "PostToolUse", // After successful tool completion + "PostToolUseFailure", // After tool execution fails + "PermissionRequest", // When tool approval dialog shown (blocking) + "UserPromptSubmit", // When user sends message (blocking) + "Stop", // When task completes or stops (blocking) + "SubagentStop", // When subtask completes (blocking) + "SubagentStart", // When subtask begins + "SessionStart", // When new task created + "SessionEnd", // When task fully ends + "Notification", // When status messages sent + "PreCompact", // Before context compaction +]) + +export type HookEventType = z.infer + +/** + * Events that can block execution by returning exit code 2. + */ +export const BLOCKING_EVENTS: Set = new Set([ + "PreToolUse", + "PermissionRequest", + "UserPromptSubmit", + "Stop", + "SubagentStop", +]) + +/** + * Check if an event type supports blocking behavior. + */ +export function isBlockingEvent(event: HookEventType): boolean { + return BLOCKING_EVENTS.has(event) +} + +// ============================================================================ +// Hook Definition Schema +// ============================================================================ + +/** + * Schema for a single hook definition within a config file. + */ +export const HookDefinitionSchema = z.object({ + /** Unique identifier for this hook */ + id: z.string().min(1, "Hook ID cannot be empty"), + + /** Tool name filter (regex/glob pattern). If omitted, matches all tools. */ + matcher: z.string().optional(), + + /** Whether this hook is enabled. Defaults to true. */ + enabled: z.boolean().optional().default(true), + + /** Shell command to execute */ + command: z.string().min(1, "Command cannot be empty"), + + /** Timeout in seconds. Defaults to 60. */ + timeout: z.number().positive().optional().default(60), + + /** Human-readable description of what this hook does */ + description: z.string().optional(), + + /** Override shell (default: user's shell on Unix, PowerShell on Windows) */ + shell: z.string().optional(), + + /** Opt-in to receive conversation history in stdin. Defaults to false. */ + includeConversationHistory: z.boolean().optional().default(false), +}) + +export type HookDefinition = z.infer + +// ============================================================================ +// Hook Config File Schema +// ============================================================================ + +/** + * Schema for a hooks configuration file (.roo/hooks/*.yaml or *.json). + */ +export const HooksConfigFileSchema = z.object({ + /** Config format version */ + version: z.literal("1"), + + /** Hooks organized by event type */ + hooks: z.record(HookEventType, z.array(HookDefinitionSchema)).optional().default({}), +}) + +export type HooksConfigFile = z.infer + +// ============================================================================ +// Internal Types (for runtime use) +// ============================================================================ + +/** + * Source of a hook configuration. + */ +export type HookSource = "project" | "mode" | "global" + +/** + * Data for updating a hook configuration. + */ +export interface HookUpdateData { + events?: HookEventType[] + matcher?: string + timeout?: number +} + +/** + * Extended hook definition with source information. + * Used internally after merging configs from multiple sources. + */ +export interface ResolvedHook extends HookDefinition { + /** Which config source this hook came from */ + source: HookSource + + /** The event type this hook is registered for */ + event: HookEventType + + /** File path where this hook was defined */ + filePath: string +} + +/** + * In-memory snapshot of all loaded hooks configuration. + * This is immutable once created - changes require explicit reload. + */ +export interface HooksConfigSnapshot { + /** All resolved hooks, organized by event type */ + hooksByEvent: Map + + /** Lookup by hook ID for quick access */ + hooksById: Map + + /** When this snapshot was created */ + loadedAt: Date + + /** IDs of hooks that have been disabled at runtime */ + disabledHookIds: Set + + /** Whether project hooks are present (for security warnings) */ + hasProjectHooks: boolean +} + +// ============================================================================ +// Hook Context (passed to hooks via stdin) +// ============================================================================ + +/** + * Session information included in hook context. + */ +export interface HookSessionContext { + taskId: string + sessionId: string + mode: string +} + +/** + * Project information included in hook context. + */ +export interface HookProjectContext { + directory: string + name: string +} + +/** + * Tool information for tool-related events. + */ +export interface HookToolContext { + name: string + input: Record + /** Only present for PostToolUse */ + output?: unknown + /** Only present for PostToolUse */ + duration?: number + /** Only present for PostToolUseFailure */ + error?: string + /** Only present for PostToolUseFailure */ + errorMessage?: string +} + +/** + * User prompt information for UserPromptSubmit event. + */ +export interface HookPromptContext { + text: string + images?: string[] +} + +/** + * Notification information for Notification event. + */ +export interface HookNotificationContext { + message: string + type: string +} + +/** + * Conversation history entry (opt-in via includeConversationHistory). + */ +export interface ConversationHistoryEntry { + role: "user" | "assistant" + content: string +} + +/** + * Full context passed to hooks via stdin as JSON. + */ +export interface HookContext { + event: HookEventType + timestamp: string + session: HookSessionContext + project: HookProjectContext + + /** Tool context - present for tool-related events */ + tool?: HookToolContext + + /** Prompt context - present for UserPromptSubmit */ + prompt?: HookPromptContext + + /** Notification context - present for Notification event */ + notification?: HookNotificationContext + + /** Stop reason - present for Stop event */ + reason?: string + + /** Summary - present for Stop event */ + summary?: string + + /** Conversation history - only if hook opts in via includeConversationHistory */ + conversationHistory?: ConversationHistoryEntry[] +} + +// ============================================================================ +// Hook Execution Types +// ============================================================================ + +/** + * Exit code semantics for hooks. + */ +export enum HookExitCode { + /** Success - continue execution */ + Success = 0, + + /** Block/deny - halt execution (only valid for blocking events) */ + Block = 2, +} + +/** + * Result of executing a single hook. + */ +export interface HookExecutionResult { + /** The hook that was executed */ + hook: ResolvedHook + + /** Exit code from the process */ + exitCode: number | null + + /** stdout output (may contain JSON for modification) */ + stdout: string + + /** stderr output (shown to user on block) */ + stderr: string + + /** Execution duration in milliseconds */ + duration: number + + /** Whether the hook timed out */ + timedOut: boolean + + /** Error if hook failed to execute */ + error?: Error + + /** Parsed modification request from stdout (PreToolUse only) */ + modification?: HookModification +} + +/** + * Modification request from hook stdout (PreToolUse only). + */ +export interface HookModification { + action: "modify" + toolInput: Record +} + +/** + * Schema for hook stdout modification response. + */ +export const HookModificationSchema = z.object({ + action: z.literal("modify"), + toolInput: z.record(z.unknown()), +}) + +/** + * Aggregated result of executing all hooks for an event. + */ +export interface HooksExecutionResult { + /** Results from each hook */ + results: HookExecutionResult[] + + /** Whether any hook blocked execution (exit code 2) */ + blocked: boolean + + /** Block message from stderr if blocked */ + blockMessage?: string + + /** The hook that blocked, if any */ + blockingHook?: ResolvedHook + + /** Tool input modification, if any hook modified it */ + modification?: HookModification + + /** Total execution time for all hooks */ + totalDuration: number +} + +// ============================================================================ +// Hook Manager Interface +// ============================================================================ + +/** + * Execution history entry for debugging/UI. + */ +export interface HookExecution { + /** When the hook was executed */ + timestamp: Date + + /** The hook that was executed */ + hook: ResolvedHook + + /** The event that triggered execution */ + event: HookEventType + + /** Execution result */ + result: HookExecutionResult +} + +/** + * Options for hook execution. + */ +export interface ExecuteHooksOptions { + /** Context to pass to hooks */ + context: HookContext + + /** Conversation history (will be included only for hooks with includeConversationHistory: true) */ + conversationHistory?: ConversationHistoryEntry[] +} + +/** + * Hook manager service interface (per PRD FR5). + */ +export interface IHookManager { + /** Load hooks configuration from all sources */ + loadHooksConfig(): Promise + + /** Explicitly reload hooks configuration */ + reloadHooksConfig(): Promise + + /** Execute all matching hooks for an event */ + executeHooks(event: HookEventType, options: ExecuteHooksOptions): Promise + + /** Get all currently enabled hooks */ + getEnabledHooks(): ResolvedHook[] + + /** Enable or disable a specific hook by ID */ + setHookEnabled(hookId: string, enabled: boolean): Promise + + /** Update a hook definition in its source file */ + updateHook(filePath: string, hookId: string, updates: HookUpdateData): Promise + + /** Get execution history for debugging */ + getHookExecutionHistory(): HookExecution[] + + /** Get the current config snapshot (or null if not loaded) */ + getConfigSnapshot(): HooksConfigSnapshot | null +} diff --git a/src/shared/__tests__/tools.spec.ts b/src/shared/__tests__/tools.spec.ts new file mode 100644 index 00000000000..512317799b3 --- /dev/null +++ b/src/shared/__tests__/tools.spec.ts @@ -0,0 +1,64 @@ +import { getToolsForGroup, TOOL_GROUPS } from "../tools" + +describe("getToolsForGroup", () => { + test("should return tools for 'read' group", () => { + const result = getToolsForGroup("read") + expect(result).toEqual(["read_file", "fetch_instructions", "search_files", "list_files", "codebase_search"]) + }) + + test("should return tools for 'edit' group (tools and customTools combined)", () => { + const result = getToolsForGroup("edit") + expect(result).toEqual([ + "apply_diff", + "write_to_file", + "generate_image", + "search_and_replace", + "search_replace", + "edit_file", + "apply_patch", + ]) + }) + + test("should return tools for 'browser' group", () => { + const result = getToolsForGroup("browser") + expect(result).toEqual(["browser_action"]) + }) + + test("should return tools for 'command' group", () => { + const result = getToolsForGroup("command") + expect(result).toEqual(["execute_command"]) + }) + + test("should return tools for 'mcp' group", () => { + const result = getToolsForGroup("mcp") + expect(result).toEqual(["use_mcp_tool", "access_mcp_resource"]) + }) + + test("should return tools for 'modes' group", () => { + const result = getToolsForGroup("modes") + expect(result).toEqual(["switch_mode", "new_task"]) + }) + + test("should be case insensitive", () => { + const result = getToolsForGroup("EDIT") + expect(result).toEqual([ + "apply_diff", + "write_to_file", + "generate_image", + "search_and_replace", + "search_replace", + "edit_file", + "apply_patch", + ]) + }) + + test("should return undefined for unknown groups", () => { + const result = getToolsForGroup("unknown") + expect(result).toBeUndefined() + }) + + test("should return undefined for empty string", () => { + const result = getToolsForGroup("") + expect(result).toBeUndefined() + }) +}) diff --git a/src/shared/tools.ts b/src/shared/tools.ts index f893a3d332e..a586a5fb591 100644 --- a/src/shared/tools.ts +++ b/src/shared/tools.ts @@ -293,6 +293,19 @@ export const TOOL_GROUPS: Record = { }, } +/** + * Gets all tools for a given group name (case-insensitive). + * Returns all tools in both `tools` and `customTools` arrays combined. + * Returns undefined if the group doesn't exist. + */ +export function getToolsForGroup(groupName: string): string[] | undefined { + const group = TOOL_GROUPS[groupName.toLowerCase() as ToolGroup] + if (!group) { + return undefined + } + return [...(group.tools || []), ...(group.customTools || [])] +} + // Tools that are always available to all modes. export const ALWAYS_AVAILABLE_TOOLS: ToolName[] = [ "ask_followup_question", diff --git a/src/utils/safeWriteText.ts b/src/utils/safeWriteText.ts new file mode 100644 index 00000000000..7f16fde7c99 --- /dev/null +++ b/src/utils/safeWriteText.ts @@ -0,0 +1,94 @@ +import * as fs from "fs/promises" +import * as path from "path" +import * as lockfile from "proper-lockfile" + +/** + * Safely writes text data to a file. + * - Creates parent directories if they don't exist + * - Uses 'proper-lockfile' for inter-process advisory locking to prevent concurrent writes + * - Writes to a temporary file in the same directory first + * - If the target file exists, it's backed up before being replaced + * - Attempts to roll back and clean up in case of errors + */ +export async function safeWriteText(filePath: string, content: string): Promise { + const absoluteFilePath = path.resolve(filePath) + let releaseLock = async () => {} + + const dirPath = path.dirname(absoluteFilePath) + await fs.mkdir(dirPath, { recursive: true }) + await fs.access(dirPath) + + releaseLock = await lockfile.lock(absoluteFilePath, { + stale: 31000, + update: 10000, + realpath: false, + retries: { + retries: 5, + factor: 2, + minTimeout: 100, + maxTimeout: 1000, + }, + onCompromised: (err) => { + throw err + }, + }) + + let tempNewPath: string | null = null + let tempBackupPath: string | null = null + + try { + tempNewPath = path.join( + path.dirname(absoluteFilePath), + `.${path.basename(absoluteFilePath)}.new_${Date.now()}_${Math.random().toString(36).substring(2)}.tmp`, + ) + + await fs.writeFile(tempNewPath, content, "utf8") + + try { + await fs.access(absoluteFilePath) + tempBackupPath = path.join( + path.dirname(absoluteFilePath), + `.${path.basename(absoluteFilePath)}.bak_${Date.now()}_${Math.random().toString(36).substring(2)}.tmp`, + ) + await fs.rename(absoluteFilePath, tempBackupPath) + } catch (accessError: any) { + if (accessError.code !== "ENOENT") { + throw accessError + } + } + + await fs.rename(tempNewPath, absoluteFilePath) + tempNewPath = null + + if (tempBackupPath) { + try { + await fs.unlink(tempBackupPath) + tempBackupPath = null + } catch { + // non-fatal + } + } + } catch (originalError) { + // Attempt rollback if backup was made + if (tempBackupPath) { + try { + await fs.rename(tempBackupPath, absoluteFilePath) + tempBackupPath = null + } catch { + // If rollback fails, preserve original error. + } + } + + if (tempNewPath) { + await fs.unlink(tempNewPath).catch(() => {}) + } + + if (tempBackupPath) { + await fs.unlink(tempBackupPath).catch(() => {}) + } + + throw originalError + } finally { + await releaseLock().catch(() => {}) + } +} diff --git a/webview-ui/package.json b/webview-ui/package.json index a316861389b..ce32c1c77ce 100644 --- a/webview-ui/package.json +++ b/webview-ui/package.json @@ -50,7 +50,7 @@ "katex": "^0.16.11", "knuth-shuffle-seeded": "^1.0.6", "lru-cache": "^11.1.0", - "lucide-react": "^0.518.0", + "lucide-react": "^0.562.0", "mermaid": "^11.4.1", "posthog-js": "^1.227.2", "pretty-bytes": "^7.0.0", diff --git a/webview-ui/src/App.tsx b/webview-ui/src/App.tsx index cccb0422ca8..01c4db6fa75 100644 --- a/webview-ui/src/App.tsx +++ b/webview-ui/src/App.tsx @@ -68,6 +68,14 @@ const App = () => { mdmCompliant, } = useExtensionState() + // Hooks auto-reload (always enabled since hooks is a permanent feature) + useEffect(() => { + const intervalId = setInterval(() => { + vscode.postMessage({ type: "hooksReloadConfig" }) + }, 5000) + return () => clearInterval(intervalId) + }, []) + // Create a persistent state manager const marketplaceStateManager = useMemo(() => new MarketplaceViewStateManager(), []) diff --git a/webview-ui/src/__tests__/App.spec.tsx b/webview-ui/src/__tests__/App.spec.tsx index e8e08782da4..c35bae815ef 100644 --- a/webview-ui/src/__tests__/App.spec.tsx +++ b/webview-ui/src/__tests__/App.spec.tsx @@ -4,6 +4,7 @@ import React from "react" import { render, screen, act, cleanup } from "@/utils/test-utils" import AppWithProviders from "../App" +import { vscode } from "@src/utils/vscode" vi.mock("@src/utils/vscode", () => ({ vscode: { @@ -172,6 +173,45 @@ describe("App", () => { }) }) + it("auto-reloads hooks config every 5 seconds", () => { + vi.useFakeTimers() + + mockUseExtensionState.mockReturnValue({ + didHydrateState: true, + showWelcome: false, + shouldShowAnnouncement: false, + experiments: {}, + language: "en", + telemetrySetting: "enabled", + }) + + const { unmount } = render() + + // Initial render shouldn't trigger reload (it's triggered by effect interval) + expect(vscode.postMessage).not.toHaveBeenCalledWith({ type: "hooksReloadConfig" }) + + // Advance time by 5s + act(() => { + vi.advanceTimersByTime(5000) + }) + expect(vscode.postMessage).toHaveBeenCalledWith({ type: "hooksReloadConfig" }) + + // Advance time another 5s + act(() => { + vi.advanceTimersByTime(5000) + }) + expect(vscode.postMessage).toHaveBeenCalledTimes(3) // 1 initial (webviewDidLaunch) + 2 repeats + + // Unmount and verify no more calls + unmount() + act(() => { + vi.advanceTimersByTime(5000) + }) + expect(vscode.postMessage).toHaveBeenCalledTimes(3) + + vi.useRealTimers() + }) + afterEach(() => { cleanup() window.removeEventListener("message", () => {}) diff --git a/webview-ui/src/components/chat/ChatRow.tsx b/webview-ui/src/components/chat/ChatRow.tsx index 24749bb4191..14c5aefe9f2 100644 --- a/webview-ui/src/components/chat/ChatRow.tsx +++ b/webview-ui/src/components/chat/ChatRow.tsx @@ -67,6 +67,7 @@ import { TerminalSquare, MessageCircle, Repeat2, + FishingHook, } from "lucide-react" import { cn } from "@/lib/utils" import { PathTooltip } from "../ui/PathTooltip" @@ -1364,6 +1365,21 @@ export const ChatRowContent = ({ checkpoint={message.checkpoint} /> ) + case "hook_triggered": + return ( +
+ + Hook: {message.text} triggered +
+ ) case "condense_context": // In-progress state if (message.partial) { diff --git a/webview-ui/src/components/settings/HooksSettings.tsx b/webview-ui/src/components/settings/HooksSettings.tsx new file mode 100644 index 00000000000..c76e9d6d1bd --- /dev/null +++ b/webview-ui/src/components/settings/HooksSettings.tsx @@ -0,0 +1,841 @@ +import React, { useCallback, useEffect, useMemo, useState } from "react" +import { RefreshCw, FolderOpen, AlertTriangle, Clock, FishingHook, X, Plus } from "lucide-react" +import { + VSCodeDropdown, + VSCodeOption, + VSCodePanels, + VSCodePanelTab, + VSCodePanelView, +} from "@vscode/webview-ui-toolkit/react" +import { useAppTranslation } from "@src/i18n/TranslationContext" +import { useExtensionState } from "@src/context/ExtensionStateContext" +import { vscode } from "@src/utils/vscode" +import { Button, StandardTooltip, ToggleSwitch } from "@src/components/ui" +import type { HookInfo, HookExecutionRecord, HookExecutionStatusPayload } from "@roo-code/types" +import { SectionHeader } from "./SectionHeader" +import { Section } from "./Section" + +const HOOK_EVENT_OPTIONS = [ + "PreToolUse", + "PostToolUse", + "PostToolUseFailure", + "PermissionRequest", + "UserPromptSubmit", + "Stop", + "SubagentStop", + "SubagentStart", + "SessionStart", + "SessionEnd", + "Notification", + "PreCompact", +] as const + +type HookEventOption = (typeof HOOK_EVENT_OPTIONS)[number] + +const TOOL_GROUPS = ["read", "edit", "browser", "command", "mcp", "modes"] as const +type ToolGroup = (typeof TOOL_GROUPS)[number] + +const TIMEOUT_OPTIONS: Array<{ label: string; seconds: number }> = [ + { label: "15 seconds", seconds: 15 }, + { label: "30 seconds", seconds: 30 }, + { label: "1 minute", seconds: 60 }, + { label: "5 minutes", seconds: 300 }, + { label: "10 minutes", seconds: 600 }, + { label: "15 minutes", seconds: 900 }, + { label: "30 minutes", seconds: 1800 }, + { label: "60 minutes", seconds: 3600 }, +] + +export const HooksSettings: React.FC = () => { + const { t } = useAppTranslation() + const { hooks, hooksEnabled } = useExtensionState() + const [executionHistory, setExecutionHistory] = useState(hooks?.executionHistory || []) + const [isUpdatingEnabled, setIsUpdatingEnabled] = useState(false) + + // Master toggle state - defaults to true if not explicitly set + const isHooksEnabled = hooksEnabled ?? true + + // Listen for realtime hookExecutionStatus messages + useEffect(() => { + const handleMessage = (event: MessageEvent) => { + const message = event.data + if (message.type === "hookExecutionStatus") { + const payload: HookExecutionStatusPayload = message.hookExecutionStatus + + // Convert realtime status to execution record format when completed/failed + if (payload.status === "completed" || payload.status === "failed" || payload.status === "blocked") { + const record: HookExecutionRecord = { + timestamp: new Date().toISOString(), + hookId: payload.hookId || "unknown", + event: payload.event, + toolName: payload.toolName, + exitCode: payload.status === "completed" ? 0 : 1, + duration: payload.duration || 0, + timedOut: false, + blocked: payload.status === "blocked", + error: payload.error, + blockMessage: payload.blockMessage, + } + + setExecutionHistory((prev) => [record, ...prev].slice(0, 50)) // Keep last 50 + } + } + } + + window.addEventListener("message", handleMessage) + return () => window.removeEventListener("message", handleMessage) + }, []) + + // Update local state when extension state changes + useEffect(() => { + if (hooks?.executionHistory) { + setExecutionHistory(hooks.executionHistory) + } + }, [hooks?.executionHistory]) + + const handleReloadConfig = useCallback(() => { + vscode.postMessage({ type: "hooksReloadConfig" }) + }, []) + + const handleOpenConfigFolder = useCallback((source: "global" | "project") => { + vscode.postMessage({ type: "hooksOpenConfigFolder", hooksSource: source }) + }, []) + + const handleToggleHook = useCallback((hookId: string, enabled: boolean) => { + vscode.postMessage({ type: "hooksSetEnabled", hookId, hookEnabled: enabled }) + }, []) + + const handleToggleHooksEnabled = useCallback((enabled: boolean) => { + setIsUpdatingEnabled(true) + vscode.postMessage({ type: "hooksSetAllEnabled", hooksEnabled: enabled }) + // Optimistically clear the "updating" flag after a short delay. + // The extension will send updated state via postStateToWebview(). + setTimeout(() => setIsUpdatingEnabled(false), 500) + }, []) + + const handleCreateNewHook = useCallback(() => { + vscode.postMessage({ type: "hooksCreateNew" }) + }, []) + + const enabledHooks = hooks?.enabledHooks || [] + const hasProjectHooks = hooks?.hasProjectHooks || false + const snapshotTimestamp = hooks?.snapshotTimestamp + + return ( +
+ {t("settings:sections.hooks")} + +
+ {/* Description paragraph */} +
+ {t("settings:hooks.description")} +
+ + {/* Master enable hooks toggle - always visible, similar to MCP toggle */} +
+ +

+ {t("settings:hooks.enableHooksDescription")} +

+
+ + {/* Only show the rest of the content when hooks are enabled */} + {isHooksEnabled && ( + <> + {/* Header */} +
+

{t("settings:hooks.configuredHooks")}

+ {snapshotTimestamp && ( + + + + )} +
+ + {/* Security warning for project hooks */} + {hasProjectHooks && ( +
+ +
+
+ {t("settings:hooks.projectHooksWarningTitle")} +
+
+ {t("settings:hooks.projectHooksWarningMessage")} +
+
+
+ )} + + {/* Note about edits requiring reload */} +
+ {t("settings:hooks.reloadNote")} +
+ {t("settings:hooks.matcherNote")} +
+ {t("settings:hooks.matcherExamplesLabel")} +
    +
  • + {t("settings:hooks.matcherExamples.writeOrEdit")} +
    • +
  • + {t("settings:hooks.matcherExamples.readOnly")} +
    • +
+
+ + {/* Hooks list */} + {enabledHooks.length === 0 ? ( +
+ +

{t("settings:hooks.noHooksConfigured")}

+

{t("settings:hooks.noHooksHint")}

+
+ ) : ( +
+ {enabledHooks.map((hook) => ( + + ))} +
+ )} + + {/* Hook Activity Log */} + + + {/* Bottom Action Buttons - mirroring MCP settings order: create, global, project, refresh */} +
+ + + + + + +
+ + )} +
+
+ ) +} + +interface HookItemProps { + hook: HookInfo + onToggle: (hookId: string, enabled: boolean) => void +} + +const HookItem: React.FC = ({ hook, onToggle }) => { + const { t } = useAppTranslation() + const { hooks } = useExtensionState() + const [isExpanded, setIsExpanded] = useState(false) + const [hookLogs, setHookLogs] = useState([]) + const [isUpdatingConfig, setIsUpdatingConfig] = useState(false) + + const hooksForId = useMemo(() => { + const enabledHooks = hooks?.enabledHooks ?? [] + return enabledHooks.filter((h) => h.id === hook.id) + }, [hooks?.enabledHooks, hook.id]) + + const selectedEvents = useMemo(() => { + const events = hooksForId.map((h) => h.event).filter(Boolean) + // Preserve stable order based on HOOK_EVENT_OPTIONS + return HOOK_EVENT_OPTIONS.filter((e) => events.includes(e)) + }, [hooksForId]) + + const matcherRaw = hook.matcher ?? "" + const { matcherGroups, matcherCustom } = useMemo(() => { + const parts = matcherRaw + .split("|") + .map((p) => p.trim()) + .filter(Boolean) + + const groups = parts.filter((p): p is ToolGroup => + (TOOL_GROUPS as readonly string[]).includes(p), + ) as ToolGroup[] + const customParts = parts.filter((p) => !(TOOL_GROUPS as readonly string[]).includes(p)) + + return { + matcherGroups: groups, + matcherCustom: customParts.join("|"), + } + }, [matcherRaw]) + + const [customMatcher, setCustomMatcher] = useState(matcherCustom) + useEffect(() => { + setCustomMatcher(matcherCustom) + }, [matcherCustom]) + + const timeoutSeconds = hook.timeout + const timeoutSelection = useMemo(() => { + const match = TIMEOUT_OPTIONS.find((o) => o.seconds === timeoutSeconds) + return match?.seconds ?? TIMEOUT_OPTIONS[1].seconds + }, [timeoutSeconds]) + + const postHookUpdate = useCallback( + (updates: { events?: HookEventOption[]; matcher?: string; timeout?: number }) => { + if (!hook.filePath) return + setIsUpdatingConfig(true) + vscode.postMessage({ + type: "hooksUpdateHook", + hookId: hook.id, + filePath: hook.filePath, + hookUpdates: updates, + }) + setTimeout(() => setIsUpdatingConfig(false), 500) + }, + [hook.filePath, hook.id], + ) + + const buildMatcherString = useCallback((nextGroups: ToolGroup[], nextCustom: string) => { + const parts: string[] = [...nextGroups] + const trimmedCustom = nextCustom.trim() + if (trimmedCustom.length > 0) { + parts.push(trimmedCustom) + } + return parts.join("|") + }, []) + + // Filter execution history for this specific hook + useEffect(() => { + const history = hooks?.executionHistory || [] + const filtered = history.filter((record) => record.hookId === hook.id) + setHookLogs(filtered) + }, [hooks?.executionHistory, hook.id]) + + // Listen for realtime hookExecutionStatus messages for this hook + useEffect(() => { + const handleMessage = (event: MessageEvent) => { + const message = event.data + if (message.type === "hookExecutionStatus") { + const payload: HookExecutionStatusPayload = message.hookExecutionStatus + + // Only process messages for this specific hook + if (payload.hookId === hook.id) { + if (payload.status === "completed" || payload.status === "failed" || payload.status === "blocked") { + const record: HookExecutionRecord = { + timestamp: new Date().toISOString(), + hookId: payload.hookId || "unknown", + event: payload.event, + toolName: payload.toolName, + exitCode: payload.status === "completed" ? 0 : 1, + duration: payload.duration || 0, + timedOut: false, + blocked: payload.status === "blocked", + error: payload.error, + blockMessage: payload.blockMessage, + } + + setHookLogs((prev) => [record, ...prev].slice(0, 20)) // Keep last 20 per hook + } + } + } + } + + window.addEventListener("message", handleMessage) + return () => window.removeEventListener("message", handleMessage) + }, [hook.id]) + + const handleToggleEnabled = () => { + onToggle(hook.id, !hook.enabled) + } + + const handleDeleteHook = () => { + vscode.postMessage({ + type: "hooksDeleteHook", + hookId: hook.id, + hooksSource: hook.source, + }) + } + + const handleOpenHookFile = () => { + if (!hook.filePath) return + vscode.postMessage({ + type: "hooksOpenHookFile", + filePath: hook.filePath, + }) + } + + const canEditConfig = Boolean(hook.filePath) + + const getEnabledDotColor = () => { + return hook.enabled ? "var(--vscode-testing-iconPassed)" : "var(--vscode-descriptionForeground)" + } + + return ( +
+ {/* Collapsed Header */} +
setIsExpanded(!isExpanded)}> + + ▶ + +
+ + {hook.id} + + {hook.source} + +
+
e.stopPropagation()}> + + + + +
+ +
+
+ + {/* Expanded Content */} + {isExpanded && ( +
+ + {t("settings:hooks.tabs.config")} + {t("settings:hooks.tabs.command")} + + {t("settings:hooks.tabs.logs")} + {hookLogs.length > 0 && ({hookLogs.length})} + + + +
+
+ + {t("settings:hooks.event")} + +
+ {HOOK_EVENT_OPTIONS.map((event) => ( + + ))} +
+ {!canEditConfig && ( +
+ {t("settings:hooks.openHookFileUnavailableTooltip")} +
+ )} +
+ +
+ + {t("settings:hooks.matcher")} + +
+ {TOOL_GROUPS.map((group) => ( + + ))} +
+
+ + setCustomMatcher(e.target.value)} + onBlur={() => { + const next = buildMatcherString(matcherGroups, customMatcher) + postHookUpdate({ matcher: next }) + }} + placeholder="file.*\\.ts" + /> +
+
+ +
+ + {t("settings:hooks.timeout")} + + { + const seconds = Number(e.target.value) + postHookUpdate({ timeout: seconds }) + }}> + {TIMEOUT_OPTIONS.map((opt) => ( + + {opt.label} + + ))} + +
+ + {hook.shell && ( +
+ + {t("settings:hooks.shell")} + + + {hook.shell} + +
+ )} + + {hook.description && ( +
+ + {t("settings:hooks.description")} + +

{hook.description}

+
+ )} +
+ + + +
+
+ + {hook.commandPreview} + +
+
+ + + +
+ {hookLogs.length === 0 ? ( +
+ {t("settings:hooks.noLogsForHook")} +
+ ) : ( +
+ {hookLogs.map((record, index) => ( + + ))} +
+ )} +
+ + +
+ )} +
+ ) +} + +interface HookLogItemProps { + record: HookExecutionRecord +} + +const HookLogItem: React.FC = ({ record }) => { + const { t } = useAppTranslation() + + const getStatusDisplay = () => { + if (record.blocked) { + return { + label: t("settings:hooks.status.blocked"), + className: "bg-red-500/20 text-red-500", + icon: , + } + } + if (record.error || record.exitCode !== 0) { + return { + label: t("settings:hooks.status.failed"), + className: "bg-red-500/20 text-red-500", + icon: , + } + } + if (record.timedOut) { + return { + label: t("settings:hooks.status.timeout"), + className: "bg-yellow-500/20 text-yellow-500", + icon: , + } + } + return { + label: t("settings:hooks.status.completed"), + className: "bg-green-500/20 text-green-500", + icon: , + } + } + + const status = getStatusDisplay() + const timestamp = new Date(record.timestamp) + const timeAgo = getTimeAgo(timestamp) + + return ( +
+
+
+ + {status.icon} + {status.label} + + {record.toolName && ( + + {record.toolName} + + )} +
+
+ {record.duration}ms + + {timeAgo} + +
+
+ + {(record.error || record.blockMessage) && ( +
+ {record.blockMessage || record.error} +
+ )} +
+ ) +} + +interface HookActivityLogProps { + executionHistory: HookExecutionRecord[] +} + +const HookActivityLog: React.FC = ({ executionHistory }) => { + const { t } = useAppTranslation() + const [isExpanded, setIsExpanded] = useState(false) + + if (executionHistory.length === 0) { + return null + } + + return ( +
+ + + {isExpanded && ( +
+ {executionHistory.map((record, index) => ( + + ))} +
+ )} +
+ ) +} + +interface ActivityLogItemProps { + record: HookExecutionRecord +} + +const ActivityLogItem: React.FC = ({ record }) => { + const { t } = useAppTranslation() + + const getStatusDisplay = () => { + if (record.blocked) { + return { + label: t("settings:hooks.status.blocked"), + className: "bg-red-500/20 text-red-500", + icon: , + } + } + if (record.error || record.exitCode !== 0) { + return { + label: t("settings:hooks.status.failed"), + className: "bg-red-500/20 text-red-500", + icon: , + } + } + if (record.timedOut) { + return { + label: t("settings:hooks.status.timeout"), + className: "bg-yellow-500/20 text-yellow-500", + icon: , + } + } + return { + label: t("settings:hooks.status.completed"), + className: "bg-green-500/20 text-green-500", + icon: , + } + } + + const status = getStatusDisplay() + const timestamp = new Date(record.timestamp) + const timeAgo = getTimeAgo(timestamp) + + return ( +
+
+
+ + {status.icon} + {status.label} + + + {record.hookId} + + · + + {record.event} + {record.toolName && ` (${record.toolName})`} + +
+
+ {record.duration}ms + + {timeAgo} + +
+
+ + {(record.error || record.blockMessage) && ( +
+ {record.blockMessage || record.error} +
+ )} +
+ ) +} + +function getTimeAgo(date: Date): string { + const seconds = Math.floor((Date.now() - date.getTime()) / 1000) + + if (seconds < 60) return `${seconds}s ago` + if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago` + if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago` + return `${Math.floor(seconds / 86400)}d ago` +} diff --git a/webview-ui/src/components/settings/SectionHeader.tsx b/webview-ui/src/components/settings/SectionHeader.tsx index 2b690f57110..bac0844099c 100644 --- a/webview-ui/src/components/settings/SectionHeader.tsx +++ b/webview-ui/src/components/settings/SectionHeader.tsx @@ -9,7 +9,12 @@ type SectionHeaderProps = HTMLAttributes & { export const SectionHeader = ({ description, children, className, ...props }: SectionHeaderProps) => { return ( -
+

{children}

{description &&

{description}

}
diff --git a/webview-ui/src/components/settings/SettingsView.tsx b/webview-ui/src/components/settings/SettingsView.tsx index 4f7499a1b10..9cc234c981c 100644 --- a/webview-ui/src/components/settings/SettingsView.tsx +++ b/webview-ui/src/components/settings/SettingsView.tsx @@ -28,6 +28,7 @@ import { Server, Users2, ArrowLeft, + FishingHook, } from "lucide-react" import { @@ -79,6 +80,7 @@ import { SlashCommandsSettings } from "./SlashCommandsSettings" import { UISettings } from "./UISettings" import ModesView from "../modes/ModesView" import McpView from "../mcp/McpView" +import { HooksSettings } from "./HooksSettings" import { SettingsSearch } from "./SettingsSearch" import { useSearchIndexRegistry, SearchIndexProvider } from "./useSettingsSearch" @@ -97,6 +99,7 @@ export const sectionNames = [ "providers", "autoApprove", "slashCommands", + "hooks", "browser", "checkpoints", "notifications", @@ -525,6 +528,7 @@ const SettingsView = forwardRef(({ onDone, t { id: "mcp", icon: Server }, { id: "autoApprove", icon: CheckCheck }, { id: "slashCommands", icon: SquareSlash }, + { id: "hooks", icon: FishingHook }, { id: "browser", icon: SquareMousePointer }, { id: "checkpoints", icon: GitBranch }, { id: "notifications", icon: Bell }, @@ -536,7 +540,7 @@ const SettingsView = forwardRef(({ onDone, t { id: "language", icon: Globe }, { id: "about", icon: Info }, ], - [], // No dependencies needed now + [], ) // Update target section logic to set active tab @@ -631,7 +635,7 @@ const SettingsView = forwardRef(({ onDone, t return ( - +
+ ), + ToggleSwitch: ({ checked, onChange, ...props }: any) => ( +
+ ), + StandardTooltip: ({ children, content }: any) =>
{children}
, +})) + +// Mock Section components +vi.mock("../SectionHeader", () => ({ + SectionHeader: ({ children }: any) =>

{children}

, +})) + +vi.mock("../Section", () => ({ + Section: ({ children }: any) =>
{children}
, +})) + +describe("HooksSettings", () => { + beforeEach(async () => { + vi.clearAllMocks() + // Reset to default state + currentHooksState = { + enabledHooks: [], + executionHistory: [], + hasProjectHooks: false, + snapshotTimestamp: undefined, + } + // Get fresh reference to mocked vscode + const { vscode } = await import("@src/utils/vscode") + vi.mocked(vscode.postMessage).mockClear() + }) + + it("renders with no hooks configured", () => { + render() + + expect(screen.getByText("settings:sections.hooks")).toBeInTheDocument() + expect(screen.getByText("settings:hooks.description")).toBeInTheDocument() + expect(screen.getByText("settings:hooks.noHooksConfigured")).toBeInTheDocument() + expect(screen.getByText("settings:hooks.noHooksHint")).toBeInTheDocument() + }) + + it("renders description paragraph at the top", () => { + render() + + expect(screen.getByText("settings:hooks.description")).toBeInTheDocument() + }) + + it("renders hooks list when hooks are configured", () => { + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + matcher: "git*", + commandPreview: "echo 'Before git command'", + enabled: true, + source: "project", + timeout: 30, + description: "Test hook", + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: true, + snapshotTimestamp: new Date().toISOString(), + } + + render() + + // Hook ID should be visible in collapsed state + expect(screen.getByText(mockHook.id)).toBeInTheDocument() + expect(screen.getByText(mockHook.source)).toBeInTheDocument() + }) + + it("expands and collapses hook accordion on click", () => { + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + matcher: "git*", + commandPreview: "echo 'Before git command'", + enabled: true, + source: "project", + timeout: 30, + description: "Test hook", + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + // Hook details should not be visible initially + expect(screen.queryByText(mockHook.event)).not.toBeInTheDocument() + expect(screen.queryByText(mockHook.matcher!)).not.toBeInTheDocument() + + // Click to expand + const hookHeader = screen.getByText(mockHook.id).closest("div") + fireEvent.click(hookHeader!) + + // Should show tabs + expect(screen.getByTestId("tab-config")).toBeInTheDocument() + expect(screen.getByTestId("tab-command")).toBeInTheDocument() + expect(screen.getByTestId("tab-logs")).toBeInTheDocument() + + // Check Config tab content (visible by default usually or we can check panels exist) + expect(screen.getByText(mockHook.event)).toBeInTheDocument() + expect(screen.getByText(mockHook.matcher!)).toBeInTheDocument() + + // Check Command tab content + expect(screen.getByText(mockHook.commandPreview)).toBeInTheDocument() + + // Click to collapse + fireEvent.click(hookHeader!) + + // Hook details should be hidden again + expect(screen.queryByText(mockHook.event)).not.toBeInTheDocument() + }) + + it("shows per-hook logs in Logs tab", () => { + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "global", + timeout: 30, + } + + const mockRecord: HookExecutionRecord = { + timestamp: new Date().toISOString(), + hookId: "hook-1", + event: "before_execute_command", + toolName: "write_to_file", + exitCode: 0, + duration: 150, + timedOut: false, + blocked: false, + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [mockRecord], + hasProjectHooks: false, + } + + render() + + // Expand hook + const hookHeader = screen.getByText(mockHook.id).closest("div") + fireEvent.click(hookHeader!) + + // Find Logs tab panel content + expect(screen.getByTestId("panel-view-logs")).toBeInTheDocument() + expect(screen.getByText(mockRecord.toolName!)).toBeInTheDocument() + expect(screen.getByText("settings:hooks.status.completed")).toBeInTheDocument() + }) + + it("renders command preview with wrapping enabled (no truncation)", () => { + const longCommand = "long_command_".repeat(20) + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + matcher: "git*", + commandPreview: longCommand, + enabled: true, + source: "project", + timeout: 30, + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + // Expand hook + const hookHeader = screen.getByText(mockHook.id).closest("div") + fireEvent.click(hookHeader!) + + const commandCode = screen.getByTestId(`command-preview-${mockHook.id}`) + expect(commandCode).toHaveClass("whitespace-pre-wrap") + expect(commandCode).toHaveClass("break-words") + expect(commandCode).not.toHaveClass("truncate") + expect(commandCode).toHaveTextContent(longCommand) + expect(commandCode.textContent).not.toContain("...") + }) + + it("renders log items with wrapping enabled (no truncation)", () => { + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "global", + timeout: 30, + } + + const mockRecord: HookExecutionRecord = { + timestamp: new Date().toISOString(), + hookId: "hook-1", + event: "before_execute_command", + toolName: "very_long_tool_name_that_should_not_be_truncated_" + "x".repeat(20), + exitCode: 0, + duration: 150, + timedOut: false, + blocked: false, + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [mockRecord], + hasProjectHooks: false, + } + + render() + + // Expand hook + const hookHeader = screen.getByText(mockHook.id).closest("div") + fireEvent.click(hookHeader!) + + const toolName = screen.getByTestId("log-tool-name") + expect(toolName).toHaveClass("break-words") + expect(toolName).not.toHaveClass("truncate") + }) + + it("filters logs per hook correctly", () => { + const mockHook1: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "global", + timeout: 30, + } + + const mockHook2: HookInfo = { + id: "hook-2", + event: "after_execute_command", + commandPreview: "echo after", + enabled: true, + source: "global", + timeout: 30, + } + + const record1: HookExecutionRecord = { + timestamp: new Date().toISOString(), + hookId: "hook-1", + event: "before_execute_command", + toolName: "write_to_file", + exitCode: 0, + duration: 100, + timedOut: false, + blocked: false, + } + + const record2: HookExecutionRecord = { + timestamp: new Date().toISOString(), + hookId: "hook-2", + event: "after_execute_command", + toolName: "read_file", + exitCode: 0, + duration: 50, + timedOut: false, + blocked: false, + } + + currentHooksState = { + enabledHooks: [mockHook1, mockHook2], + executionHistory: [record1, record2], + hasProjectHooks: false, + } + + render() + + // Expand first hook + const hook1Headers = screen.getAllByText("hook-1") + const hook1Header = hook1Headers[0].closest("div") + fireEvent.click(hook1Header!) + + // Should show only hook-1's log + expect(screen.getByText("write_to_file")).toBeInTheDocument() + expect(screen.queryByText("read_file")).not.toBeInTheDocument() + }) + + it("shows 'no logs' message when hook has no execution history", () => { + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "global", + timeout: 30, + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + // Expand hook + const hookHeader = screen.getByText(mockHook.id).closest("div") + fireEvent.click(hookHeader!) + + // Should show no logs message + expect(screen.getAllByText("settings:hooks.noLogsForHook")[0]).toBeInTheDocument() + }) + + it("shows project hooks warning when hasProjectHooks is true", () => { + currentHooksState = { + ...mockHooksState, + hasProjectHooks: true, + } + + render() + + expect(screen.getByText("settings:hooks.projectHooksWarningTitle")).toBeInTheDocument() + expect(screen.getByText("settings:hooks.projectHooksWarningMessage")).toBeInTheDocument() + }) + + it("sends hooksReloadConfig message when Reload button is clicked (bottom action)", async () => { + const { vscode } = await import("@src/utils/vscode") + render() + + // Reload button is now in bottom action area (mirroring MCP settings) + const reloadButton = screen.getByText("settings:hooks.reload") + fireEvent.click(reloadButton) + + expect(vscode.postMessage).toHaveBeenCalledWith({ type: "hooksReloadConfig" }) + }) + + it("sends hooksOpenConfigFolder message with 'global' when Global Folder button is clicked (bottom action)", async () => { + const { vscode } = await import("@src/utils/vscode") + + render() + + // Button is now in bottom action area (like MCP settings) + const globalFolderButton = screen.getByText("settings:hooks.openGlobalFolder") + fireEvent.click(globalFolderButton) + + expect(vscode.postMessage).toHaveBeenCalledWith({ + type: "hooksOpenConfigFolder", + hooksSource: "global", + }) + }) + + it("sends hooksOpenConfigFolder message with 'project' when Project Folder button is clicked (bottom action)", async () => { + const { vscode } = await import("@src/utils/vscode") + + render() + + // Button is now in bottom action area (like MCP settings) + const projectFolderButton = screen.getByText("settings:hooks.openProjectFolder") + fireEvent.click(projectFolderButton) + + expect(vscode.postMessage).toHaveBeenCalledWith({ + type: "hooksOpenConfigFolder", + hooksSource: "project", + }) + }) + + it("renders both Global and Project folder buttons in bottom action area regardless of hasProjectHooks state", () => { + currentHooksState = { + ...mockHooksState, + hasProjectHooks: false, + } + + render() + + // Both buttons should be present + expect(screen.getByText("settings:hooks.openGlobalFolder")).toBeInTheDocument() + expect(screen.getByText("settings:hooks.openProjectFolder")).toBeInTheDocument() + }) + + it("sends hooksSetEnabled message when hook toggle is changed", async () => { + const { vscode } = await import("@src/utils/vscode") + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "global", + timeout: 30, + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + fireEvent.click(screen.getByTestId("hook-enabled-toggle-hook-1")) + + expect(vscode.postMessage).toHaveBeenCalledWith({ + type: "hooksSetEnabled", + hookId: "hook-1", + hookEnabled: false, + }) + }) + + it("toggles hook enabled state in collapsed view without expanding accordion", async () => { + const { vscode } = await import("@src/utils/vscode") + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "global", + timeout: 30, + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + // Hook should be collapsed initially + expect(screen.queryByText(mockHook.event)).not.toBeInTheDocument() + + fireEvent.click(screen.getByTestId("hook-enabled-toggle-hook-1")) + + // Hook should still be collapsed after toggling + expect(screen.queryByText(mockHook.event)).not.toBeInTheDocument() + + // Toggle message should have been sent + expect(vscode.postMessage).toHaveBeenCalledWith({ + type: "hooksSetEnabled", + hookId: "hook-1", + hookEnabled: false, + }) + }) + + it("renders green status dot in collapsed row", () => { + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "global", + timeout: 30, + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + const dot = screen.getByTestId("hook-status-dot-hook-1") + expect(dot).toBeInTheDocument() + expect(dot).toHaveStyle({ background: "var(--vscode-testing-iconPassed)" }) + }) + + it("sends hooksDeleteHook message when trash button is clicked", async () => { + const { vscode } = await import("@src/utils/vscode") + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "project", + timeout: 30, + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + fireEvent.click(screen.getByTestId("hook-delete-hook-1")) + + expect(vscode.postMessage).toHaveBeenCalledWith({ + type: "hooksDeleteHook", + hookId: "hook-1", + hooksSource: "project", + }) + }) + + it("sends hooksOpenHookFile message when open file button is clicked", async () => { + const { vscode } = await import("@src/utils/vscode") + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "project", + timeout: 30, + filePath: "/path/to/hooks.json", + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + fireEvent.click(screen.getByTestId("hook-open-file-hook-1")) + + expect(vscode.postMessage).toHaveBeenCalledWith({ + type: "hooksOpenHookFile", + filePath: "/path/to/hooks.json", + }) + }) + + it("shows correct tooltip for open file button when file path is available", () => { + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "project", + timeout: 30, + filePath: "/path/to/hooks.json", + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + const button = screen.getByTestId("hook-open-file-hook-1") + // In the mock, StandardTooltip wraps the button with a div having the title + expect(button.parentElement).toHaveAttribute("title", "settings:hooks.openHookFileTooltip") + }) + + it("shows correct tooltip for open file button when file path is unavailable", () => { + const mockHook: HookInfo = { + id: "hook-1", + event: "before_execute_command", + commandPreview: "echo test", + enabled: true, + source: "project", + timeout: 30, + // No filePath + } + + currentHooksState = { + enabledHooks: [mockHook], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + const button = screen.getByTestId("hook-open-file-hook-1") + expect(button.parentElement).toHaveAttribute("title", "settings:hooks.openHookFileUnavailableTooltip") + }) + + it("sends hooksSetAllEnabled message when top-level Enable Hooks toggle is changed", async () => { + const { vscode } = await import("@src/utils/vscode") + + currentHooksState = { + enabledHooks: [ + { + id: "hook-1", + event: "event1", + commandPreview: "cmd1", + enabled: true, + source: "global", + timeout: 30, + }, + { + id: "hook-2", + event: "event2", + commandPreview: "cmd2", + enabled: true, + source: "project", + timeout: 30, + }, + ], + executionHistory: [], + hasProjectHooks: false, + } + + render() + + const checkboxes = screen.getAllByRole("checkbox") + fireEvent.click(checkboxes[0]) + + expect(vscode.postMessage).toHaveBeenCalledWith({ + type: "hooksSetAllEnabled", + hooksEnabled: false, + }) + }) + + it("renders execution history when available", () => { + const mockRecord: HookExecutionRecord = { + timestamp: new Date().toISOString(), + hookId: "hook-1", + event: "before_execute_command", + exitCode: 0, + duration: 150, + timedOut: false, + blocked: false, + } + + currentHooksState = { + enabledHooks: [], + executionHistory: [mockRecord], + hasProjectHooks: false, + } + + render() + + // Activity log should be present + expect(screen.getByText(/settings:hooks.activityLog/)).toBeInTheDocument() + }) + + it("updates execution history on realtime hookExecutionStatus message", async () => { + render() + + // Simulate receiving a hookExecutionStatus message + const event = new MessageEvent("message", { + data: { + type: "hookExecutionStatus", + hookExecutionStatus: { + status: "completed", + event: "before_execute_command", + hookId: "hook-1", + duration: 200, + }, + }, + }) + + window.dispatchEvent(event) + + // Wait for state update + await waitFor(() => { + // The activity log should now show the new execution + const activityLog = screen.getByText(/settings:hooks.activityLog/) + expect(activityLog).toBeInTheDocument() + }) + }) + + it("expands and collapses activity log on click", () => { + const mockRecord: HookExecutionRecord = { + timestamp: new Date().toISOString(), + hookId: "hook-1", + event: "before_execute_command", + exitCode: 0, + duration: 150, + timedOut: false, + blocked: false, + } + + currentHooksState = { + enabledHooks: [], + executionHistory: [mockRecord], + hasProjectHooks: false, + } + + render() + + const activityLogButton = screen.getByText(/settings:hooks.activityLog/) + + // Should start collapsed + expect(screen.queryByText(mockRecord.event)).not.toBeInTheDocument() + + // Click to expand + fireEvent.click(activityLogButton) + + // Should now show the record + expect(screen.getByText(mockRecord.event)).toBeInTheDocument() + }) + + it("displays different hook sources with appropriate styling", () => { + const hooks: HookInfo[] = [ + { + id: "hook-1", + event: "event1", + commandPreview: "cmd1", + enabled: true, + source: "project", + timeout: 30, + }, + { + id: "hook-2", + event: "event2", + commandPreview: "cmd2", + enabled: true, + source: "mode", + timeout: 30, + }, + { + id: "hook-3", + event: "event3", + commandPreview: "cmd3", + enabled: true, + source: "global", + timeout: 30, + }, + ] + + currentHooksState = { + enabledHooks: hooks, + executionHistory: [], + hasProjectHooks: false, + } + + render() + + // All three source types should be present + expect(screen.getByText("project")).toBeInTheDocument() + expect(screen.getByText("mode")).toBeInTheDocument() + expect(screen.getByText("global")).toBeInTheDocument() + }) + + it("displays activity log status pills correctly", () => { + const records: HookExecutionRecord[] = [ + { + timestamp: new Date().toISOString(), + hookId: "hook-1", + event: "event1", + exitCode: 0, + duration: 100, + timedOut: false, + blocked: false, + }, + { + timestamp: new Date().toISOString(), + hookId: "hook-2", + event: "event2", + exitCode: 1, + duration: 200, + timedOut: false, + blocked: false, + error: "Command failed", + }, + { + timestamp: new Date().toISOString(), + hookId: "hook-3", + event: "event3", + exitCode: null, + duration: 300, + timedOut: false, + blocked: true, + blockMessage: "Operation blocked", + }, + ] + + currentHooksState = { + enabledHooks: [], + executionHistory: records, + hasProjectHooks: false, + } + + render() + + // Expand activity log + const activityLogButton = screen.getByText(/settings:hooks.activityLog/) + fireEvent.click(activityLogButton) + + // Check for status labels + expect(screen.getByText("settings:hooks.status.completed")).toBeInTheDocument() + expect(screen.getByText("settings:hooks.status.failed")).toBeInTheDocument() + expect(screen.getByText("settings:hooks.status.blocked")).toBeInTheDocument() + }) +}) diff --git a/webview-ui/src/context/ExtensionStateContext.tsx b/webview-ui/src/context/ExtensionStateContext.tsx index d2ff79a8e02..8d199e1d985 100644 --- a/webview-ui/src/context/ExtensionStateContext.tsx +++ b/webview-ui/src/context/ExtensionStateContext.tsx @@ -279,6 +279,7 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode openRouterImageGenerationSelectedModel: "", includeCurrentTime: true, includeCurrentCost: true, + hooksEnabled: true, // Enable hooks by default }) const [didHydrateState, setDidHydrateState] = useState(false) diff --git a/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx b/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx index 292a8a74750..d525e65eb72 100644 --- a/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx +++ b/webview-ui/src/context/__tests__/ExtensionStateContext.spec.tsx @@ -220,6 +220,7 @@ describe("mergeExtensionState", () => { featureRoomoteControlEnabled: false, isBrowserSessionActive: false, checkpointTimeout: DEFAULT_CHECKPOINT_TIMEOUT_SECONDS, // Add the checkpoint timeout property + hooksEnabled: true, // Enable hooks by default } const prevState: ExtensionState = { @@ -245,6 +246,7 @@ describe("mergeExtensionState", () => { nativeToolCalling: false, multipleNativeToolCalls: false, customTools: false, + hooks: false, } as Record, checkpointTimeout: DEFAULT_CHECKPOINT_TIMEOUT_SECONDS + 5, } @@ -269,6 +271,7 @@ describe("mergeExtensionState", () => { nativeToolCalling: false, multipleNativeToolCalls: false, customTools: false, + hooks: false, }) }) }) diff --git a/webview-ui/src/i18n/locales/ca/settings.json b/webview-ui/src/i18n/locales/ca/settings.json index 8a0e94d2859..daf02a4fc03 100644 --- a/webview-ui/src/i18n/locales/ca/settings.json +++ b/webview-ui/src/i18n/locales/ca/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Context", "terminal": "Terminal", "slashCommands": "Comandes de barra", + "hooks": "Hooks", "prompts": "Indicacions", "ui": "UI", "experimental": "Experimental", "language": "Idioma", "about": "Sobre Roo Code" }, + "hooks": { + "description": "Els hooks executen ordres de shell personalitzades automàticament quan Roo utilitza eines específiques. Utilitza'ls per integrar-te amb sistemes externs, aplicar fluxos de treball o automatitzar tasques repetitives.", + "configuredHooks": "Hooks configurats", + "lastLoadedTooltip": "Última càrrega a les {{time}}", + "reloadTooltip": "Recarregar la configuració dels hooks des del disc", + "reload": "Recarregar", + "openProjectFolderTooltip": "Obrir la carpeta de configuració de hooks del projecte", + "openGlobalFolderTooltip": "Obrir la carpeta de configuració de hooks global", + "openProjectFolder": "Obrir carpeta del projecte", + "openGlobalFolder": "Obrir carpeta global", + "createNewHook": "Crear nou hook", + "deleteHook": "Eliminar hook", + "openHookFile": "Obrir fitxer de hook", + "projectHooksWarningTitle": "Hooks de projecte detectats", + "projectHooksWarningMessage": "Aquest projecte inclou configuracions de hooks que executaran ordres de shell. Només activa hooks de fonts en les quals confiïs.", + "reloadNote": "Els canvis en els fitxers de configuració de hooks requereixen fer clic a Recarregar per tenir efecte.", + "openHookFileTooltip": "Obrir fitxer de hook a l'editor", + "openHookFileUnavailableTooltip": "Ubicació del fitxer de hook no disponible", + "matcherNote": "Els matchers s'avaluen contra els IDs interns d'eines de Roo Code (p. ex. write_to_file, edit_file, apply_diff, apply_patch), no contra etiquetes de UI com Escriure/Editar.", + "matcherExamplesLabel": "Exemples:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "No hi ha hooks configurats", + "noHooksHint": "Crea fitxers de configuració de hooks per automatitzar accions en esdeveniments d'execució d'eines.", + "enableHooks": "Activar hooks", + "enableHooksDescription": "Activar o desactivar tots els hooks alhora", + "enabled": "Activat", + "event": "Esdeveniment", + "matcher": "Matcher", + "command": "Ordre", + "shell": "Shell", + "timeout": "Temps d'espera", + "logs": "Registres", + "noLogsForHook": "Encara no hi ha registres d'execució per aquest hook", + "activityLog": "Activitat de hooks", + "status": { + "running": "Executant", + "completed": "Completat", + "failed": "Fallat", + "blocked": "Bloquejat", + "timeout": "Temps esgotat" + }, + "tabs": { + "config": "Configuració", + "command": "Ordre", + "logs": "Registres" + } + }, "about": { "bugReport": { "label": "Has trobat un error?", @@ -843,6 +894,10 @@ "refreshSuccess": "Eines actualitzades correctament", "refreshError": "Error en actualitzar les eines", "toolParameters": "Paràmetres" + }, + "HOOKS": { + "name": "Habilitar Hooks", + "description": "Utilitza ordres de shell personalitzades per automatitzar accions abans o després de l'execució d'eines." } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/de/settings.json b/webview-ui/src/i18n/locales/de/settings.json index a559a18593f..d536d617ed4 100644 --- a/webview-ui/src/i18n/locales/de/settings.json +++ b/webview-ui/src/i18n/locales/de/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Kontext", "terminal": "Terminal", "slashCommands": "Slash-Befehle", + "hooks": "Hooks", "prompts": "Eingabeaufforderungen", "ui": "UI", "experimental": "Experimentell", "language": "Sprache", "about": "Über Roo Code" }, + "hooks": { + "description": "Hooks führen benutzerdefinierte Shell-Befehle automatisch aus, wenn Roo bestimmte Werkzeuge verwendet. Nutze sie zur Integration mit externen Systemen, zur Durchsetzung von Arbeitsabläufen oder zur Automatisierung wiederkehrender Aufgaben.", + "configuredHooks": "Konfigurierte Hooks", + "lastLoadedTooltip": "Zuletzt geladen um {{time}}", + "reloadTooltip": "Hook-Konfiguration von der Festplatte neu laden", + "reload": "Neu laden", + "openProjectFolderTooltip": "Projekt-Hook-Konfigurationsordner öffnen", + "openGlobalFolderTooltip": "Globalen Hook-Konfigurationsordner öffnen", + "openProjectFolder": "Projektordner öffnen", + "openGlobalFolder": "Globalen Ordner öffnen", + "createNewHook": "Neuen Hook erstellen", + "deleteHook": "Hook löschen", + "openHookFile": "Hook-Datei öffnen", + "projectHooksWarningTitle": "Projekt-Hooks erkannt", + "projectHooksWarningMessage": "Dieses Projekt enthält Hook-Konfigurationen, die Shell-Befehle ausführen. Aktiviere Hooks nur aus vertrauenswürdigen Quellen.", + "reloadNote": "Änderungen an Hook-Konfigurationsdateien erfordern das Klicken auf Neu laden, um wirksam zu werden.", + "openHookFileTooltip": "Hook-Datei im Editor öffnen", + "openHookFileUnavailableTooltip": "Hook-Dateispeicherort nicht verfügbar", + "matcherNote": "Matcher werden gegen die internen Tool-IDs von Roo Code ausgewertet (z.B. write_to_file, edit_file, apply_diff, apply_patch), nicht gegen UI-Bezeichnungen wie Schreiben/Bearbeiten.", + "matcherExamplesLabel": "Beispiele:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Keine Hooks konfiguriert", + "noHooksHint": "Erstelle Hook-Konfigurationsdateien, um Aktionen bei Werkzeugausführungsereignissen zu automatisieren.", + "enableHooks": "Hooks aktivieren", + "enableHooksDescription": "Alle Hooks gleichzeitig ein- oder ausschalten", + "enabled": "Aktiviert", + "event": "Ereignis", + "matcher": "Matcher", + "command": "Befehl", + "shell": "Shell", + "timeout": "Timeout", + "logs": "Protokolle", + "noLogsForHook": "Noch keine Ausführungsprotokolle für diesen Hook", + "activityLog": "Hook-Aktivität", + "status": { + "running": "Läuft", + "completed": "Abgeschlossen", + "failed": "Fehlgeschlagen", + "blocked": "Blockiert", + "timeout": "Zeitüberschreitung" + }, + "tabs": { + "config": "Konfiguration", + "command": "Befehl", + "logs": "Protokolle" + } + }, "about": { "bugReport": { "label": "Fehler gefunden?", @@ -843,6 +894,10 @@ "refreshSuccess": "Tools erfolgreich aktualisiert", "refreshError": "Fehler beim Aktualisieren der Tools", "toolParameters": "Parameter" + }, + "HOOKS": { + "name": "Hooks aktivieren", + "description": "Verwende benutzerdefinierte Shell-Befehle, um Aktionen vor oder nach der Tool-Ausführung zu automatisieren." } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/en/settings.json b/webview-ui/src/i18n/locales/en/settings.json index fc64ad18510..9822c0c85f3 100644 --- a/webview-ui/src/i18n/locales/en/settings.json +++ b/webview-ui/src/i18n/locales/en/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Context", "terminal": "Terminal", "slashCommands": "Slash Commands", + "hooks": "Hooks", "prompts": "Prompts", "ui": "UI", "experimental": "Experimental", "language": "Language", "about": "About Roo Code" }, + "hooks": { + "description": "Hooks execute custom shell commands automatically when Roo uses specific tools. Use them to integrate with external systems, enforce workflows, or automate repetitive tasks.", + "configuredHooks": "Configured Hooks", + "lastLoadedTooltip": "Last loaded at {{time}}", + "reloadTooltip": "Reload hooks configuration from disk", + "reload": "Reload", + "openProjectFolderTooltip": "Open project hooks configuration folder", + "openGlobalFolderTooltip": "Open global hooks configuration folder", + "openProjectFolder": "Open Project Folder", + "openGlobalFolder": "Open Global Folder", + "createNewHook": "Create New Hook", + "deleteHook": "Delete hook", + "openHookFile": "Open hook file", + "projectHooksWarningTitle": "Project-level hooks detected", + "projectHooksWarningMessage": "This project includes hook configurations that will execute shell commands. Only enable hooks from sources you trust.", + "reloadNote": "Changes to hook configuration files require clicking Reload to take effect.", + "openHookFileTooltip": "Open hook file in editor", + "openHookFileUnavailableTooltip": "Hook file location unavailable", + "matcherNote": "Matchers are evaluated against Roo Code's internal tool IDs (e.g. write_to_file, edit_file, apply_diff, apply_patch), not UI labels like Write/Edit.", + "matcherExamplesLabel": "Examples:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "No hooks configured", + "noHooksHint": "Create hook configuration files to automate actions on tool execution events.", + "enableHooks": "Enable Hooks", + "enableHooksDescription": "Toggle all hooks on or off at once", + "enabled": "Enabled", + "event": "Event", + "matcher": "Matcher", + "command": "Command", + "shell": "Shell", + "timeout": "Timeout", + "logs": "Logs", + "noLogsForHook": "No execution logs for this hook yet", + "activityLog": "Hook Activity", + "status": { + "running": "Running", + "completed": "Completed", + "failed": "Failed", + "blocked": "Blocked", + "timeout": "Timeout" + }, + "tabs": { + "config": "Config", + "command": "Command", + "logs": "Logs" + } + }, "about": { "bugReport": { "label": "Found a bug?", @@ -852,6 +903,10 @@ "refreshSuccess": "Tools refreshed successfully", "refreshError": "Failed to refresh tools", "toolParameters": "Parameters" + }, + "HOOKS": { + "name": "Enable Hooks", + "description": "Use custom shell commands to automate actions before or after tool execution." } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/es/settings.json b/webview-ui/src/i18n/locales/es/settings.json index 590fbcae20e..8c257bd0dab 100644 --- a/webview-ui/src/i18n/locales/es/settings.json +++ b/webview-ui/src/i18n/locales/es/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Contexto", "terminal": "Terminal", "slashCommands": "Comandos de Barra", + "hooks": "Hooks", "prompts": "Indicaciones", "ui": "UI", "experimental": "Experimental", "language": "Idioma", "about": "Acerca de Roo Code" }, + "hooks": { + "description": "Los hooks ejecutan comandos de shell personalizados automáticamente cuando Roo usa herramientas específicas. Úsalos para integrarte con sistemas externos, aplicar flujos de trabajo o automatizar tareas repetitivas.", + "configuredHooks": "Hooks configurados", + "lastLoadedTooltip": "Última carga a las {{time}}", + "reloadTooltip": "Recargar configuración de hooks desde el disco", + "reload": "Recargar", + "openProjectFolderTooltip": "Abrir carpeta de configuración de hooks del proyecto", + "openGlobalFolderTooltip": "Abrir carpeta de configuración de hooks global", + "openProjectFolder": "Abrir carpeta del proyecto", + "openGlobalFolder": "Abrir carpeta global", + "createNewHook": "Crear nuevo hook", + "deleteHook": "Eliminar hook", + "openHookFile": "Abrir archivo de hook", + "projectHooksWarningTitle": "Hooks de proyecto detectados", + "projectHooksWarningMessage": "Este proyecto incluye configuraciones de hooks que ejecutarán comandos de shell. Solo habilita hooks de fuentes en las que confíes.", + "reloadNote": "Los cambios en los archivos de configuración de hooks requieren hacer clic en Recargar para que surtan efecto.", + "openHookFileTooltip": "Abrir archivo de hook en el editor", + "openHookFileUnavailableTooltip": "Ubicación del archivo de hook no disponible", + "matcherNote": "Los matchers se evalúan contra los IDs internos de herramientas de Roo Code (p. ej. write_to_file, edit_file, apply_diff, apply_patch), no contra etiquetas de UI como Escribir/Editar.", + "matcherExamplesLabel": "Ejemplos:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "No hay hooks configurados", + "noHooksHint": "Crea archivos de configuración de hooks para automatizar acciones en eventos de ejecución de herramientas.", + "enableHooks": "Habilitar hooks", + "enableHooksDescription": "Activar o desactivar todos los hooks a la vez", + "enabled": "Habilitado", + "event": "Evento", + "matcher": "Matcher", + "command": "Comando", + "shell": "Shell", + "timeout": "Tiempo límite", + "logs": "Registros", + "noLogsForHook": "Aún no hay registros de ejecución para este hook", + "activityLog": "Actividad de hooks", + "status": { + "running": "Ejecutando", + "completed": "Completado", + "failed": "Fallido", + "blocked": "Bloqueado", + "timeout": "Tiempo agotado" + }, + "tabs": { + "config": "Configuración", + "command": "Comando", + "logs": "Registros" + } + }, "about": { "bugReport": { "label": "¿Encontraste un error?", @@ -843,6 +894,10 @@ "refreshSuccess": "Herramientas actualizadas correctamente", "refreshError": "Error al actualizar las herramientas", "toolParameters": "Parámetros" + }, + "HOOKS": { + "name": "Habilitar Hooks", + "description": "Usa comandos de shell personalizados para automatizar acciones antes o después de la ejecución de herramientas." } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/fr/settings.json b/webview-ui/src/i18n/locales/fr/settings.json index 8ad9f1791fc..50c6011d909 100644 --- a/webview-ui/src/i18n/locales/fr/settings.json +++ b/webview-ui/src/i18n/locales/fr/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Contexte", "terminal": "Terminal", "slashCommands": "Commandes Slash", + "hooks": "Hooks", "prompts": "Invites", "ui": "UI", "experimental": "Expérimental", "language": "Langue", "about": "À propos de Roo Code" }, + "hooks": { + "description": "Les hooks exécutent automatiquement des commandes shell personnalisées lorsque Roo utilise des outils spécifiques. Utilise-les pour t'intégrer à des systèmes externes, appliquer des workflows ou automatiser des tâches répétitives.", + "configuredHooks": "Hooks configurés", + "lastLoadedTooltip": "Dernière charge à {{time}}", + "reloadTooltip": "Recharger la configuration des hooks depuis le disque", + "reload": "Recharger", + "openProjectFolderTooltip": "Ouvrir le dossier de configuration des hooks du projet", + "openGlobalFolderTooltip": "Ouvrir le dossier de configuration des hooks global", + "openProjectFolder": "Ouvrir le dossier du projet", + "openGlobalFolder": "Ouvrir le dossier global", + "createNewHook": "Créer un nouveau hook", + "deleteHook": "Supprimer le hook", + "openHookFile": "Ouvrir le fichier de hook", + "projectHooksWarningTitle": "Hooks de projet détectés", + "projectHooksWarningMessage": "Ce projet inclut des configurations de hooks qui exécuteront des commandes shell. N'active les hooks que depuis des sources de confiance.", + "reloadNote": "Les modifications des fichiers de configuration des hooks nécessitent de cliquer sur Recharger pour prendre effet.", + "openHookFileTooltip": "Ouvrir le fichier de hook dans l'éditeur", + "openHookFileUnavailableTooltip": "Emplacement du fichier de hook non disponible", + "matcherNote": "Les matchers sont évalués par rapport aux IDs d'outils internes de Roo Code (ex. write_to_file, edit_file, apply_diff, apply_patch), pas par rapport aux libellés de l'UI comme Écrire/Éditer.", + "matcherExamplesLabel": "Exemples :", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Aucun hook configuré", + "noHooksHint": "Crée des fichiers de configuration de hooks pour automatiser des actions lors des événements d'exécution d'outils.", + "enableHooks": "Activer les hooks", + "enableHooksDescription": "Activer ou désactiver tous les hooks d'un coup", + "enabled": "Activé", + "event": "Événement", + "matcher": "Matcher", + "command": "Commande", + "shell": "Shell", + "timeout": "Délai d'expiration", + "logs": "Journaux", + "noLogsForHook": "Pas encore de journaux d'exécution pour ce hook", + "activityLog": "Activité des hooks", + "status": { + "running": "En cours", + "completed": "Terminé", + "failed": "Échoué", + "blocked": "Bloqué", + "timeout": "Délai dépassé" + }, + "tabs": { + "config": "Configuration", + "command": "Commande", + "logs": "Journaux" + } + }, "about": { "bugReport": { "label": "Vous avez trouvé un bug ?", @@ -843,6 +894,10 @@ "refreshSuccess": "Outils actualisés avec succès", "refreshError": "Échec de l'actualisation des outils", "toolParameters": "Paramètres" + }, + "HOOKS": { + "name": "Activer les Hooks", + "description": "Utilise des commandes shell personnalisées pour automatiser des actions avant ou après l'exécution des outils. (Redémarrage requis après l'enregistrement des paramètres)" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/hi/settings.json b/webview-ui/src/i18n/locales/hi/settings.json index 8260e9c24b1..aad6a2743c3 100644 --- a/webview-ui/src/i18n/locales/hi/settings.json +++ b/webview-ui/src/i18n/locales/hi/settings.json @@ -36,12 +36,63 @@ "contextManagement": "संदर्भ", "terminal": "टर्मिनल", "slashCommands": "स्लैश कमांड", + "hooks": "Hooks", "prompts": "प्रॉम्प्ट्स", "ui": "UI", "experimental": "प्रायोगिक", "language": "भाषा", "about": "परिचय" }, + "hooks": { + "description": "जब Roo विशिष्ट टूल्स का उपयोग करता है तो Hooks स्वचालित रूप से कस्टम शेल कमांड चलाते हैं। इन्हें बाहरी सिस्टम के साथ एकीकरण, वर्कफ़्लो लागू करने, या दोहराव वाले कार्यों को स्वचालित करने के लिए उपयोग करें।", + "configuredHooks": "कॉन्फ़िगर किए गए Hooks", + "lastLoadedTooltip": "आखिरी बार {{time}} पर लोड किया गया", + "reloadTooltip": "डिस्क से hooks कॉन्फ़िगरेशन पुनः लोड करें", + "reload": "पुनः लोड करें", + "openProjectFolderTooltip": "प्रोजेक्ट hooks कॉन्फ़िगरेशन फ़ोल्डर खोलें", + "openGlobalFolderTooltip": "ग्लोबल hooks कॉन्फ़िगरेशन फ़ोल्डर खोलें", + "openProjectFolder": "प्रोजेक्ट फ़ोल्डर खोलें", + "openGlobalFolder": "ग्लोबल फ़ोल्डर खोलें", + "createNewHook": "नया Hook बनाएं", + "deleteHook": "Hook हटाएं", + "openHookFile": "Hook फ़ाइल खोलें", + "projectHooksWarningTitle": "प्रोजेक्ट-स्तर hooks पाए गए", + "projectHooksWarningMessage": "इस प्रोजेक्ट में hook कॉन्फ़िगरेशन शामिल हैं जो शेल कमांड चलाएंगे। केवल विश्वसनीय स्रोतों से hooks सक्षम करें।", + "reloadNote": "Hook कॉन्फ़िगरेशन फ़ाइलों में बदलावों को प्रभावी करने के लिए पुनः लोड करें पर क्लिक करना आवश्यक है।", + "openHookFileTooltip": "एडिटर में hook फ़ाइल खोलें", + "openHookFileUnavailableTooltip": "Hook फ़ाइल स्थान उपलब्ध नहीं है", + "matcherNote": "Matchers का मूल्यांकन Roo Code के आंतरिक टूल IDs (जैसे write_to_file, edit_file, apply_diff, apply_patch) के विरुद्ध किया जाता है, न कि UI लेबल जैसे Write/Edit के विरुद्ध।", + "matcherExamplesLabel": "उदाहरण:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "कोई hooks कॉन्फ़िगर नहीं किए गए", + "noHooksHint": "टूल निष्पादन इवेंट्स पर क्रियाओं को स्वचालित करने के लिए hook कॉन्फ़िगरेशन फ़ाइलें बनाएं।", + "enableHooks": "Hooks सक्षम करें", + "enableHooksDescription": "सभी hooks को एक साथ चालू या बंद करें", + "enabled": "सक्षम", + "event": "इवेंट", + "matcher": "Matcher", + "command": "कमांड", + "shell": "Shell", + "timeout": "समय सीमा", + "logs": "लॉग्स", + "noLogsForHook": "इस hook के लिए अभी तक कोई निष्पादन लॉग नहीं है", + "activityLog": "Hook गतिविधि", + "status": { + "running": "चल रहा है", + "completed": "पूर्ण", + "failed": "विफल", + "blocked": "अवरुद्ध", + "timeout": "समय समाप्त" + }, + "tabs": { + "config": "कॉन्फ़िग", + "command": "कमांड", + "logs": "लॉग्स" + } + }, "about": { "bugReport": { "label": "बग मिला?", @@ -844,6 +895,10 @@ "refreshSuccess": "टूल्स सफलतापूर्वक रिफ्रेश हुए", "refreshError": "टूल्स रिफ्रेश करने में विफल", "toolParameters": "पैरामीटर्स" + }, + "HOOKS": { + "name": "Hooks सक्षम करें", + "description": "टूल निष्पादन से पहले या बाद में क्रियाओं को स्वचालित करने के लिए कस्टम शेल कमांड का उपयोग करें। (सेटिंग्स सहेजने के बाद पुनरारंभ आवश्यक)" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/id/settings.json b/webview-ui/src/i18n/locales/id/settings.json index 50850b74cca..9addea7b09e 100644 --- a/webview-ui/src/i18n/locales/id/settings.json +++ b/webview-ui/src/i18n/locales/id/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Konteks", "terminal": "Terminal", "slashCommands": "Perintah Slash", + "hooks": "Hooks", "prompts": "Prompt", "ui": "UI", "experimental": "Eksperimental", "language": "Bahasa", "about": "Tentang Roo Code" }, + "hooks": { + "description": "Hooks menjalankan perintah shell kustom secara otomatis ketika Roo menggunakan alat tertentu. Gunakan untuk integrasi dengan sistem eksternal, menerapkan alur kerja, atau mengotomatisasi tugas berulang.", + "configuredHooks": "Hooks yang Dikonfigurasi", + "lastLoadedTooltip": "Terakhir dimuat pada {{time}}", + "reloadTooltip": "Muat ulang konfigurasi hooks dari disk", + "reload": "Muat Ulang", + "openProjectFolderTooltip": "Buka folder konfigurasi hooks proyek", + "openGlobalFolderTooltip": "Buka folder konfigurasi hooks global", + "openProjectFolder": "Buka Folder Proyek", + "openGlobalFolder": "Buka Folder Global", + "createNewHook": "Buat Hook Baru", + "deleteHook": "Hapus hook", + "openHookFile": "Buka file hook", + "projectHooksWarningTitle": "Hooks tingkat proyek terdeteksi", + "projectHooksWarningMessage": "Proyek ini menyertakan konfigurasi hook yang akan menjalankan perintah shell. Hanya aktifkan hooks dari sumber yang Anda percaya.", + "reloadNote": "Perubahan pada file konfigurasi hook memerlukan klik Muat Ulang untuk diterapkan.", + "openHookFileTooltip": "Buka file hook di editor", + "openHookFileUnavailableTooltip": "Lokasi file hook tidak tersedia", + "matcherNote": "Matchers dievaluasi terhadap ID alat internal Roo Code (mis. write_to_file, edit_file, apply_diff, apply_patch), bukan label UI seperti Write/Edit.", + "matcherExamplesLabel": "Contoh:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Tidak ada hooks yang dikonfigurasi", + "noHooksHint": "Buat file konfigurasi hook untuk mengotomatisasi tindakan pada event eksekusi alat.", + "enableHooks": "Aktifkan Hooks", + "enableHooksDescription": "Aktifkan atau nonaktifkan semua hooks sekaligus", + "enabled": "Diaktifkan", + "event": "Event", + "matcher": "Matcher", + "command": "Perintah", + "shell": "Shell", + "timeout": "Batas Waktu", + "logs": "Log", + "noLogsForHook": "Belum ada log eksekusi untuk hook ini", + "activityLog": "Aktivitas Hook", + "status": { + "running": "Berjalan", + "completed": "Selesai", + "failed": "Gagal", + "blocked": "Diblokir", + "timeout": "Waktu Habis" + }, + "tabs": { + "config": "Konfigurasi", + "command": "Perintah", + "logs": "Log" + } + }, "about": { "bugReport": { "label": "Menemukan bug?", @@ -873,6 +924,10 @@ "refreshSuccess": "Tool berhasil direfresh", "refreshError": "Gagal merefresh tool", "toolParameters": "Parameter" + }, + "HOOKS": { + "name": "Aktifkan Hooks", + "description": "Gunakan perintah shell kustom untuk mengotomatiskan tindakan sebelum atau setelah eksekusi alat. (Perlu restart setelah menyimpan pengaturan)" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/it/settings.json b/webview-ui/src/i18n/locales/it/settings.json index d307ef1aee3..d6e87f5d9ea 100644 --- a/webview-ui/src/i18n/locales/it/settings.json +++ b/webview-ui/src/i18n/locales/it/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Contesto", "terminal": "Terminal", "slashCommands": "Comandi Slash", + "hooks": "Hooks", "prompts": "Prompt", "ui": "UI", "experimental": "Sperimentale", "language": "Lingua", "about": "Informazioni su Roo Code" }, + "hooks": { + "description": "Gli hooks eseguono automaticamente comandi shell personalizzati quando Roo utilizza strumenti specifici. Usali per integrarti con sistemi esterni, applicare workflow o automatizzare attività ripetitive.", + "configuredHooks": "Hooks configurati", + "lastLoadedTooltip": "Ultimo caricamento alle {{time}}", + "reloadTooltip": "Ricarica la configurazione degli hooks dal disco", + "reload": "Ricarica", + "openProjectFolderTooltip": "Apri la cartella di configurazione degli hooks del progetto", + "openGlobalFolderTooltip": "Apri la cartella di configurazione degli hooks globale", + "openProjectFolder": "Apri cartella progetto", + "openGlobalFolder": "Apri cartella globale", + "createNewHook": "Crea nuovo hook", + "deleteHook": "Elimina hook", + "openHookFile": "Apri file hook", + "projectHooksWarningTitle": "Rilevati hooks a livello di progetto", + "projectHooksWarningMessage": "Questo progetto include configurazioni di hooks che eseguiranno comandi shell. Abilita gli hooks solo da fonti affidabili.", + "reloadNote": "Le modifiche ai file di configurazione degli hooks richiedono di cliccare Ricarica per avere effetto.", + "openHookFileTooltip": "Apri file hook nell'editor", + "openHookFileUnavailableTooltip": "Posizione del file hook non disponibile", + "matcherNote": "I matcher vengono valutati rispetto agli ID degli strumenti interni di Roo Code (es. write_to_file, edit_file, apply_diff, apply_patch), non rispetto alle etichette UI come Scrivi/Modifica.", + "matcherExamplesLabel": "Esempi:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Nessun hook configurato", + "noHooksHint": "Crea file di configurazione degli hooks per automatizzare azioni sugli eventi di esecuzione degli strumenti.", + "enableHooks": "Abilita hooks", + "enableHooksDescription": "Attiva o disattiva tutti gli hooks contemporaneamente", + "enabled": "Abilitato", + "event": "Evento", + "matcher": "Matcher", + "command": "Comando", + "shell": "Shell", + "timeout": "Timeout", + "logs": "Log", + "noLogsForHook": "Ancora nessun log di esecuzione per questo hook", + "activityLog": "Attività hook", + "status": { + "running": "In esecuzione", + "completed": "Completato", + "failed": "Fallito", + "blocked": "Bloccato", + "timeout": "Timeout" + }, + "tabs": { + "config": "Configurazione", + "command": "Comando", + "logs": "Log" + } + }, "about": { "bugReport": { "label": "Hai trovato un bug?", @@ -844,6 +895,10 @@ "refreshSuccess": "Strumenti aggiornati con successo", "refreshError": "Impossibile aggiornare gli strumenti", "toolParameters": "Parametri" + }, + "HOOKS": { + "name": "Abilita Hooks", + "description": "Usa comandi shell personalizzati per automatizzare azioni prima o dopo l'esecuzione degli strumenti." } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/ja/settings.json b/webview-ui/src/i18n/locales/ja/settings.json index 8c8707caaa8..671c705ec9a 100644 --- a/webview-ui/src/i18n/locales/ja/settings.json +++ b/webview-ui/src/i18n/locales/ja/settings.json @@ -36,12 +36,63 @@ "contextManagement": "コンテキスト", "terminal": "ターミナル", "slashCommands": "スラッシュコマンド", + "hooks": "Hooks", "prompts": "プロンプト", "ui": "UI", "experimental": "実験的", "language": "言語", "about": "Roo Codeについて" }, + "hooks": { + "description": "Hooksは、Rooが特定のツールを使用するときにカスタムシェルコマンドを自動的に実行します。外部システムとの統合、ワークフローの適用、反復タスクの自動化に使用します。", + "configuredHooks": "設定済みHooks", + "lastLoadedTooltip": "最終読み込み: {{time}}", + "reloadTooltip": "ディスクからHooks設定を再読み込み", + "reload": "再読み込み", + "openProjectFolderTooltip": "プロジェクトのHooks設定フォルダを開く", + "openGlobalFolderTooltip": "グローバルHooks設定フォルダを開く", + "openProjectFolder": "プロジェクトフォルダを開く", + "openGlobalFolder": "グローバルフォルダを開く", + "createNewHook": "新しいHookを作成", + "deleteHook": "Hookを削除", + "openHookFile": "Hookファイルを開く", + "projectHooksWarningTitle": "プロジェクトレベルのHooksが検出されました", + "projectHooksWarningMessage": "このプロジェクトにはシェルコマンドを実行するHooks設定が含まれています。信頼できるソースからのHooksのみを有効にしてください。", + "reloadNote": "Hooks設定ファイルの変更を反映するには、再読み込みをクリックする必要があります。", + "openHookFileTooltip": "エディターでHookファイルを開く", + "openHookFileUnavailableTooltip": "Hookファイルの場所が利用できません", + "matcherNote": "MatcherはRoo Codeの内部ツールID（例: write_to_file、edit_file、apply_diff、apply_patch）に対して評価されます。Write/Editなどの表示ラベルに対してではありません。", + "matcherExamplesLabel": "例:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Hooksが設定されていません", + "noHooksHint": "Hooks設定ファイルを作成して、ツール実行イベントでアクションを自動化します。", + "enableHooks": "Hooksを有効化", + "enableHooksDescription": "すべてのHooksを一度に有効化または無効化", + "enabled": "有効", + "event": "イベント", + "matcher": "Matcher", + "command": "コマンド", + "shell": "シェル", + "timeout": "タイムアウト", + "logs": "ログ", + "noLogsForHook": "このHookの実行ログはまだありません", + "activityLog": "Hookアクティビティ", + "status": { + "running": "実行中", + "completed": "完了", + "failed": "失敗", + "blocked": "ブロック", + "timeout": "タイムアウト" + }, + "tabs": { + "config": "設定", + "command": "コマンド", + "logs": "ログ" + } + }, "about": { "bugReport": { "label": "バグを見つけましたか？", @@ -844,6 +895,10 @@ "refreshSuccess": "ツールが正常に更新されました", "refreshError": "ツールの更新に失敗しました", "toolParameters": "パラメーター" + }, + "HOOKS": { + "name": "Hooks を有効化", + "description": "カスタムシェルコマンドを使用して、ツール実行の前後にアクションを自動化します。（設定保存後に再起動が必要です）" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/ko/settings.json b/webview-ui/src/i18n/locales/ko/settings.json index 4ce757bfcbc..babbd9e62f8 100644 --- a/webview-ui/src/i18n/locales/ko/settings.json +++ b/webview-ui/src/i18n/locales/ko/settings.json @@ -36,12 +36,63 @@ "contextManagement": "컨텍스트", "terminal": "터미널", "slashCommands": "슬래시 명령", + "hooks": "Hooks", "prompts": "프롬프트", "ui": "UI", "experimental": "실험적", "language": "언어", "about": "Roo Code 정보" }, + "hooks": { + "description": "Hooks는 Roo가 특정 도구를 사용할 때 사용자 정의 셸 명령을 자동으로 실행합니다. 외부 시스템과 통합하거나, 워크플로우를 적용하거나, 반복적인 작업을 자동화하는 데 사용하세요.", + "configuredHooks": "구성된 Hooks", + "lastLoadedTooltip": "마지막 로드: {{time}}", + "reloadTooltip": "디스크에서 Hooks 구성 다시 로드", + "reload": "다시 로드", + "openProjectFolderTooltip": "프로젝트 Hooks 구성 폴더 열기", + "openGlobalFolderTooltip": "전역 Hooks 구성 폴더 열기", + "openProjectFolder": "프로젝트 폴더 열기", + "openGlobalFolder": "전역 폴더 열기", + "createNewHook": "새 Hook 만들기", + "deleteHook": "Hook 삭제", + "openHookFile": "Hook 파일 열기", + "projectHooksWarningTitle": "프로젝트 수준 Hooks 감지됨", + "projectHooksWarningMessage": "이 프로젝트에는 셸 명령을 실행하는 Hooks 구성이 포함되어 있습니다. 신뢰할 수 있는 소스의 Hooks만 활성화하세요.", + "reloadNote": "Hooks 구성 파일 변경 사항을 적용하려면 다시 로드를 클릭해야 합니다.", + "openHookFileTooltip": "편집기에서 Hook 파일 열기", + "openHookFileUnavailableTooltip": "Hook 파일 위치를 사용할 수 없음", + "matcherNote": "Matcher는 Roo Code의 내부 도구 ID(예: write_to_file, edit_file, apply_diff, apply_patch)에 대해 평가됩니다. Write/Edit과 같은 표시 레이블이 아닙니다.", + "matcherExamplesLabel": "예시:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "구성된 Hooks 없음", + "noHooksHint": "Hooks 구성 파일을 만들어 도구 실행 이벤트에서 작업을 자동화하세요.", + "enableHooks": "Hooks 활성화", + "enableHooksDescription": "모든 Hooks를 한 번에 활성화 또는 비활성화", + "enabled": "활성화됨", + "event": "이벤트", + "matcher": "Matcher", + "command": "명령", + "shell": "셸", + "timeout": "시간 초과", + "logs": "로그", + "noLogsForHook": "이 Hook의 실행 로그가 아직 없습니다", + "activityLog": "Hook 활동", + "status": { + "running": "실행 중", + "completed": "완료됨", + "failed": "실패", + "blocked": "차단됨", + "timeout": "시간 초과" + }, + "tabs": { + "config": "구성", + "command": "명령", + "logs": "로그" + } + }, "about": { "bugReport": { "label": "버그를 발견하셨나요?", @@ -844,6 +895,10 @@ "refreshSuccess": "도구가 성공적으로 새로고침되었습니다", "refreshError": "도구 새로고침에 실패했습니다", "toolParameters": "매개변수" + }, + "HOOKS": { + "name": "Hooks 활성화", + "description": "사용자 정의 셸 명령을 사용하여 도구 실행 전후에 작업을 자동화합니다. (설정 저장 후 재시작 필요)" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/nl/settings.json b/webview-ui/src/i18n/locales/nl/settings.json index d2988b8e04e..ca8dc4a322a 100644 --- a/webview-ui/src/i18n/locales/nl/settings.json +++ b/webview-ui/src/i18n/locales/nl/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Context", "terminal": "Terminal", "slashCommands": "Slash-opdrachten", + "hooks": "Hooks", "prompts": "Prompts", "ui": "UI", "experimental": "Experimenteel", "language": "Taal", "about": "Over Roo Code" }, + "hooks": { + "description": "Hooks voeren automatisch aangepaste shell-opdrachten uit wanneer Roo specifieke tools gebruikt. Gebruik ze om te integreren met externe systemen, workflows af te dwingen of repetitieve taken te automatiseren.", + "configuredHooks": "Geconfigureerde hooks", + "lastLoadedTooltip": "Laatst geladen om {{time}}", + "reloadTooltip": "Hooks-configuratie opnieuw laden van schijf", + "reload": "Herladen", + "openProjectFolderTooltip": "Project hooks configuratiemap openen", + "openGlobalFolderTooltip": "Globale hooks configuratiemap openen", + "openProjectFolder": "Projectmap openen", + "openGlobalFolder": "Globale map openen", + "createNewHook": "Nieuwe hook maken", + "deleteHook": "Hook verwijderen", + "openHookFile": "Hook-bestand openen", + "projectHooksWarningTitle": "Project-level hooks gedetecteerd", + "projectHooksWarningMessage": "Dit project bevat hooks-configuraties die shell-opdrachten uitvoeren. Schakel alleen hooks in van vertrouwde bronnen.", + "reloadNote": "Wijzigingen in hooks-configuratiebestanden vereisen het klikken op Herladen om van kracht te worden.", + "openHookFileTooltip": "Hook-bestand openen in editor", + "openHookFileUnavailableTooltip": "Hook-bestandslocatie niet beschikbaar", + "matcherNote": "Matchers worden geëvalueerd tegen Roo Code's interne tool-ID's (bijv. write_to_file, edit_file, apply_diff, apply_patch), niet tegen weergavelabels zoals Write/Edit.", + "matcherExamplesLabel": "Voorbeelden:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Geen hooks geconfigureerd", + "noHooksHint": "Maak hooks-configuratiebestanden aan om acties te automatiseren bij tool-uitvoeringsgebeurtenissen.", + "enableHooks": "Hooks inschakelen", + "enableHooksDescription": "Schakel alle hooks tegelijk in of uit", + "enabled": "Ingeschakeld", + "event": "Gebeurtenis", + "matcher": "Matcher", + "command": "Opdracht", + "shell": "Shell", + "timeout": "Time-out", + "logs": "Logs", + "noLogsForHook": "Nog geen uitvoerlogs voor deze hook", + "activityLog": "Hook-activiteit", + "status": { + "running": "Wordt uitgevoerd", + "completed": "Voltooid", + "failed": "Mislukt", + "blocked": "Geblokkeerd", + "timeout": "Time-out" + }, + "tabs": { + "config": "Configuratie", + "command": "Opdracht", + "logs": "Logs" + } + }, "about": { "bugReport": { "label": "Bug gevonden?", @@ -844,6 +895,10 @@ "refreshSuccess": "Tools succesvol vernieuwd", "refreshError": "Fout bij vernieuwen van tools", "toolParameters": "Parameters" + }, + "HOOKS": { + "name": "Hooks inschakelen", + "description": "Gebruik aangepaste shell-opdrachten om acties vóór of na tool-uitvoering te automatiseren. (Herstart vereist na opslaan van instellingen)" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/pl/settings.json b/webview-ui/src/i18n/locales/pl/settings.json index 380c7a895ce..a94ef89b33d 100644 --- a/webview-ui/src/i18n/locales/pl/settings.json +++ b/webview-ui/src/i18n/locales/pl/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Kontekst", "terminal": "Terminal", "slashCommands": "Polecenia Slash", + "hooks": "Hooks", "prompts": "Podpowiedzi", "ui": "UI", "experimental": "Eksperymentalne", "language": "Język", "about": "O Roo Code" }, + "hooks": { + "description": "Hooks automatycznie wykonują niestandardowe polecenia powłoki, gdy Roo używa określonych narzędzi. Używaj ich do integracji z systemami zewnętrznymi, wymuszania przepływów pracy lub automatyzacji powtarzalnych zadań.", + "configuredHooks": "Skonfigurowane hooki", + "lastLoadedTooltip": "Ostatnio załadowano o {{time}}", + "reloadTooltip": "Przeładuj konfigurację hooków z dysku", + "reload": "Przeładuj", + "openProjectFolderTooltip": "Otwórz folder konfiguracji hooków projektu", + "openGlobalFolderTooltip": "Otwórz folder globalnej konfiguracji hooków", + "openProjectFolder": "Otwórz folder projektu", + "openGlobalFolder": "Otwórz folder globalny", + "createNewHook": "Utwórz nowy hook", + "deleteHook": "Usuń hook", + "openHookFile": "Otwórz plik hooka", + "projectHooksWarningTitle": "Wykryto hooki na poziomie projektu", + "projectHooksWarningMessage": "Ten projekt zawiera konfiguracje hooków, które będą wykonywać polecenia powłoki. Włączaj tylko hooki z zaufanych źródeł.", + "reloadNote": "Zmiany w plikach konfiguracji hooków wymagają kliknięcia Przeładuj, aby weszły w życie.", + "openHookFileTooltip": "Otwórz plik hooka w edytorze", + "openHookFileUnavailableTooltip": "Lokalizacja pliku hooka niedostępna", + "matcherNote": "Matchery są oceniane względem wewnętrznych identyfikatorów narzędzi Roo Code (np. write_to_file, edit_file, apply_diff, apply_patch), a nie etykiet wyświetlanych jak Write/Edit.", + "matcherExamplesLabel": "Przykłady:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Brak skonfigurowanych hooków", + "noHooksHint": "Utwórz pliki konfiguracji hooków, aby automatyzować akcje przy zdarzeniach wykonania narzędzi.", + "enableHooks": "Włącz hooki", + "enableHooksDescription": "Włącz lub wyłącz wszystkie hooki jednocześnie", + "enabled": "Włączony", + "event": "Zdarzenie", + "matcher": "Matcher", + "command": "Polecenie", + "shell": "Powłoka", + "timeout": "Limit czasu", + "logs": "Logi", + "noLogsForHook": "Brak jeszcze logów wykonania dla tego hooka", + "activityLog": "Aktywność hooków", + "status": { + "running": "Wykonywanie", + "completed": "Ukończone", + "failed": "Niepowodzenie", + "blocked": "Zablokowane", + "timeout": "Limit czasu" + }, + "tabs": { + "config": "Konfiguracja", + "command": "Polecenie", + "logs": "Logi" + } + }, "about": { "bugReport": { "label": "Znalazłeś błąd?", @@ -844,6 +895,10 @@ "refreshSuccess": "Narzędzia odświeżone pomyślnie", "refreshError": "Nie udało się odświeżyć narzędzi", "toolParameters": "Parametry" + }, + "HOOKS": { + "name": "Włącz Hooks", + "description": "Użyj niestandardowych poleceń powłoki, aby zautomatyzować działania przed lub po wykonaniu narzędzia. (Wymagany restart po zapisaniu ustawień)" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/pt-BR/settings.json b/webview-ui/src/i18n/locales/pt-BR/settings.json index 387891910fd..527085e350e 100644 --- a/webview-ui/src/i18n/locales/pt-BR/settings.json +++ b/webview-ui/src/i18n/locales/pt-BR/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Contexto", "terminal": "Terminal", "slashCommands": "Comandos de Barra", + "hooks": "Hooks", "prompts": "Prompts", "ui": "UI", "experimental": "Experimental", "language": "Idioma", "about": "Sobre" }, + "hooks": { + "description": "Hooks executam automaticamente comandos shell personalizados quando o Roo usa ferramentas específicas. Use-os para integrar com sistemas externos, aplicar fluxos de trabalho ou automatizar tarefas repetitivas.", + "configuredHooks": "Hooks configurados", + "lastLoadedTooltip": "Último carregamento às {{time}}", + "reloadTooltip": "Recarregar configuração de hooks do disco", + "reload": "Recarregar", + "openProjectFolderTooltip": "Abrir pasta de configuração de hooks do projeto", + "openGlobalFolderTooltip": "Abrir pasta de configuração de hooks global", + "openProjectFolder": "Abrir pasta do projeto", + "openGlobalFolder": "Abrir pasta global", + "createNewHook": "Criar novo hook", + "deleteHook": "Excluir hook", + "openHookFile": "Abrir arquivo de hook", + "projectHooksWarningTitle": "Hooks em nível de projeto detectados", + "projectHooksWarningMessage": "Este projeto inclui configurações de hooks que executarão comandos shell. Habilite apenas hooks de fontes confiáveis.", + "reloadNote": "Alterações nos arquivos de configuração de hooks requerem clicar em Recarregar para ter efeito.", + "openHookFileTooltip": "Abrir arquivo de hook no editor", + "openHookFileUnavailableTooltip": "Localização do arquivo de hook indisponível", + "matcherNote": "Os matchers são avaliados contra os IDs internos de ferramentas do Roo Code (ex: write_to_file, edit_file, apply_diff, apply_patch), não contra rótulos de exibição como Write/Edit.", + "matcherExamplesLabel": "Exemplos:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Nenhum hook configurado", + "noHooksHint": "Crie arquivos de configuração de hooks para automatizar ações em eventos de execução de ferramentas.", + "enableHooks": "Habilitar hooks", + "enableHooksDescription": "Ativar ou desativar todos os hooks de uma vez", + "enabled": "Habilitado", + "event": "Evento", + "matcher": "Matcher", + "command": "Comando", + "shell": "Shell", + "timeout": "Tempo limite", + "logs": "Logs", + "noLogsForHook": "Ainda não há logs de execução para este hook", + "activityLog": "Atividade de hooks", + "status": { + "running": "Executando", + "completed": "Concluído", + "failed": "Falhou", + "blocked": "Bloqueado", + "timeout": "Tempo esgotado" + }, + "tabs": { + "config": "Configuração", + "command": "Comando", + "logs": "Logs" + } + }, "about": { "bugReport": { "label": "Encontrou um bug?", @@ -844,6 +895,10 @@ "refreshSuccess": "Ferramentas atualizadas com sucesso", "refreshError": "Falha ao atualizar ferramentas", "toolParameters": "Parâmetros" + }, + "HOOKS": { + "name": "Habilitar Hooks", + "description": "Use comandos shell personalizados para automatizar ações antes ou depois da execução de ferramentas. (Reinicialização necessária após salvar as configurações)" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/ru/settings.json b/webview-ui/src/i18n/locales/ru/settings.json index 430e0969a84..e610cbf1450 100644 --- a/webview-ui/src/i18n/locales/ru/settings.json +++ b/webview-ui/src/i18n/locales/ru/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Контекст", "terminal": "Терминал", "slashCommands": "Слэш-команды", + "hooks": "Hooks", "prompts": "Промпты", "ui": "UI", "experimental": "Экспериментальное", "language": "Язык", "about": "О Roo Code" }, + "hooks": { + "description": "Hooks автоматически выполняют пользовательские команды оболочки, когда Roo использует определённые инструменты. Используйте их для интеграции с внешними системами, применения рабочих процессов или автоматизации повторяющихся задач.", + "configuredHooks": "Настроенные hooks", + "lastLoadedTooltip": "Последняя загрузка в {{time}}", + "reloadTooltip": "Перезагрузить конфигурацию hooks с диска", + "reload": "Перезагрузить", + "openProjectFolderTooltip": "Открыть папку конфигурации hooks проекта", + "openGlobalFolderTooltip": "Открыть глобальную папку конфигурации hooks", + "openProjectFolder": "Открыть папку проекта", + "openGlobalFolder": "Открыть глобальную папку", + "createNewHook": "Создать новый hook", + "deleteHook": "Удалить hook", + "openHookFile": "Открыть файл hook", + "projectHooksWarningTitle": "Обнаружены hooks на уровне проекта", + "projectHooksWarningMessage": "Этот проект содержит конфигурации hooks, которые будут выполнять команды оболочки. Включайте только hooks из надёжных источников.", + "reloadNote": "Изменения в файлах конфигурации hooks требуют нажатия «Перезагрузить» для вступления в силу.", + "openHookFileTooltip": "Открыть файл hook в редакторе", + "openHookFileUnavailableTooltip": "Расположение файла hook недоступно", + "matcherNote": "Сопоставители оцениваются по внутренним идентификаторам инструментов Roo Code (например, write_to_file, edit_file, apply_diff, apply_patch), а не по отображаемым меткам, таким как Write/Edit.", + "matcherExamplesLabel": "Примеры:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Hooks не настроены", + "noHooksHint": "Создайте файлы конфигурации hooks для автоматизации действий при событиях выполнения инструментов.", + "enableHooks": "Включить hooks", + "enableHooksDescription": "Включить или отключить все hooks одновременно", + "enabled": "Включено", + "event": "Событие", + "matcher": "Сопоставитель", + "command": "Команда", + "shell": "Оболочка", + "timeout": "Тайм-аут", + "logs": "Логи", + "noLogsForHook": "Пока нет логов выполнения для этого hook", + "activityLog": "Активность hooks", + "status": { + "running": "Выполняется", + "completed": "Завершено", + "failed": "Ошибка", + "blocked": "Заблокировано", + "timeout": "Тайм-аут" + }, + "tabs": { + "config": "Конфигурация", + "command": "Команда", + "logs": "Логи" + } + }, "about": { "bugReport": { "label": "Нашли ошибку?", @@ -844,6 +895,10 @@ "refreshSuccess": "Инструменты успешно обновлены", "refreshError": "Не удалось обновить инструменты", "toolParameters": "Параметры" + }, + "HOOKS": { + "name": "Включить Hooks", + "description": "Используйте пользовательские shell-команды для автоматизации действий до или после выполнения инструментов. (Требуется перезапуск после сохранения настроек)" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/tr/settings.json b/webview-ui/src/i18n/locales/tr/settings.json index 3feb8e2a1ee..9a89abfc92b 100644 --- a/webview-ui/src/i18n/locales/tr/settings.json +++ b/webview-ui/src/i18n/locales/tr/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Bağlam", "terminal": "Terminal", "slashCommands": "Eğik Çizgi Komutları", + "hooks": "Hooks", "prompts": "Promptlar", "ui": "UI", "experimental": "Deneysel", "language": "Dil", "about": "Roo Code Hakkında" }, + "hooks": { + "description": "Hook'lar, Roo belirli araçları kullandığında otomatik olarak özel kabuk komutları çalıştırır. Harici sistemlerle entegrasyon, iş akışlarını uygulama veya tekrarlayan görevleri otomatikleştirmek için kullanın.", + "configuredHooks": "Yapılandırılmış hook'lar", + "lastLoadedTooltip": "Son yükleme: {{time}}", + "reloadTooltip": "Diskten hook yapılandırmasını yeniden yükle", + "reload": "Yeniden Yükle", + "openProjectFolderTooltip": "Proje hook yapılandırma klasörünü aç", + "openGlobalFolderTooltip": "Global hook yapılandırma klasörünü aç", + "openProjectFolder": "Proje Klasörünü Aç", + "openGlobalFolder": "Global Klasörü Aç", + "createNewHook": "Yeni hook oluştur", + "deleteHook": "Hook'u sil", + "openHookFile": "Hook dosyasını aç", + "projectHooksWarningTitle": "Proje düzeyinde hook'lar tespit edildi", + "projectHooksWarningMessage": "Bu proje, kabuk komutları çalıştıracak hook yapılandırmaları içeriyor. Yalnızca güvenilir kaynaklardan hook'ları etkinleştirin.", + "reloadNote": "Hook yapılandırma dosyalarındaki değişikliklerin etkili olması için Yeniden Yükle'ye tıklamanız gerekir.", + "openHookFileTooltip": "Hook dosyasını editörde aç", + "openHookFileUnavailableTooltip": "Hook dosya konumu mevcut değil", + "matcherNote": "Eşleştiriciler, Roo Code'un dahili araç kimliklerine (örn. write_to_file, edit_file, apply_diff, apply_patch) göre değerlendirilir, Write/Edit gibi görüntüleme etiketlerine göre değil.", + "matcherExamplesLabel": "Örnekler:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Yapılandırılmış hook yok", + "noHooksHint": "Araç yürütme olaylarında eylemleri otomatikleştirmek için hook yapılandırma dosyaları oluşturun.", + "enableHooks": "Hook'ları etkinleştir", + "enableHooksDescription": "Tüm hook'ları aynı anda etkinleştir veya devre dışı bırak", + "enabled": "Etkin", + "event": "Olay", + "matcher": "Eşleştirici", + "command": "Komut", + "shell": "Kabuk", + "timeout": "Zaman Aşımı", + "logs": "Günlükler", + "noLogsForHook": "Bu hook için henüz yürütme günlüğü yok", + "activityLog": "Hook etkinliği", + "status": { + "running": "Çalışıyor", + "completed": "Tamamlandı", + "failed": "Başarısız", + "blocked": "Engellendi", + "timeout": "Zaman Aşımı" + }, + "tabs": { + "config": "Yapılandırma", + "command": "Komut", + "logs": "Günlükler" + } + }, "about": { "bugReport": { "label": "Bir hata mı buldunuz?", @@ -844,6 +895,10 @@ "refreshSuccess": "Araçlar başarıyla yenilendi", "refreshError": "Araçlar yenilenemedi", "toolParameters": "Parametreler" + }, + "HOOKS": { + "name": "Hook'ları Etkinleştir", + "description": "Araç yürütmeden önce veya sonra eylemleri otomatikleştirmek için özel kabuk komutları kullanın." } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/vi/settings.json b/webview-ui/src/i18n/locales/vi/settings.json index 141ef12b87f..995a3dc6820 100644 --- a/webview-ui/src/i18n/locales/vi/settings.json +++ b/webview-ui/src/i18n/locales/vi/settings.json @@ -36,12 +36,63 @@ "contextManagement": "Ngữ cảnh", "terminal": "Terminal", "slashCommands": "Lệnh Gạch Chéo", + "hooks": "Hooks", "prompts": "Lời nhắc", "ui": "UI", "experimental": "Thử nghiệm", "language": "Ngôn ngữ", "about": "Giới thiệu" }, + "hooks": { + "description": "Hooks tự động thực thi các lệnh shell tùy chỉnh khi Roo sử dụng các công cụ cụ thể. Sử dụng chúng để tích hợp với hệ thống bên ngoài, áp dụng quy trình làm việc hoặc tự động hóa các tác vụ lặp đi lặp lại.", + "configuredHooks": "Hooks đã cấu hình", + "lastLoadedTooltip": "Lần tải cuối lúc {{time}}", + "reloadTooltip": "Tải lại cấu hình hooks từ đĩa", + "reload": "Tải lại", + "openProjectFolderTooltip": "Mở thư mục cấu hình hooks của dự án", + "openGlobalFolderTooltip": "Mở thư mục cấu hình hooks toàn cục", + "openProjectFolder": "Mở thư mục dự án", + "openGlobalFolder": "Mở thư mục toàn cục", + "createNewHook": "Tạo hook mới", + "deleteHook": "Xóa hook", + "openHookFile": "Mở tệp hook", + "projectHooksWarningTitle": "Phát hiện hooks cấp dự án", + "projectHooksWarningMessage": "Dự án này bao gồm các cấu hình hooks sẽ thực thi các lệnh shell. Chỉ bật hooks từ các nguồn đáng tin cậy.", + "reloadNote": "Các thay đổi đối với tệp cấu hình hooks yêu cầu nhấp Tải lại để có hiệu lực.", + "openHookFileTooltip": "Mở tệp hook trong trình soạn thảo", + "openHookFileUnavailableTooltip": "Vị trí tệp hook không khả dụng", + "matcherNote": "Các matcher được đánh giá dựa trên ID công cụ nội bộ của Roo Code (ví dụ: write_to_file, edit_file, apply_diff, apply_patch), không phải nhãn hiển thị như Write/Edit.", + "matcherExamplesLabel": "Ví dụ:", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "Chưa có hooks nào được cấu hình", + "noHooksHint": "Tạo tệp cấu hình hooks để tự động hóa các hành động khi công cụ thực thi.", + "enableHooks": "Bật hooks", + "enableHooksDescription": "Bật hoặc tắt tất cả hooks cùng một lúc", + "enabled": "Đã bật", + "event": "Sự kiện", + "matcher": "Matcher", + "command": "Lệnh", + "shell": "Shell", + "timeout": "Thời gian chờ", + "logs": "Nhật ký", + "noLogsForHook": "Chưa có nhật ký thực thi cho hook này", + "activityLog": "Hoạt động hooks", + "status": { + "running": "Đang chạy", + "completed": "Hoàn thành", + "failed": "Thất bại", + "blocked": "Bị chặn", + "timeout": "Hết thời gian" + }, + "tabs": { + "config": "Cấu hình", + "command": "Lệnh", + "logs": "Nhật ký" + } + }, "about": { "bugReport": { "label": "Tìm thấy lỗi?", @@ -844,6 +895,10 @@ "refreshSuccess": "Làm mới công cụ thành công", "refreshError": "Không thể làm mới công cụ", "toolParameters": "Thông số" + }, + "HOOKS": { + "name": "Bật Hooks", + "description": "Sử dụng các lệnh shell tùy chỉnh để tự động hóa các hành động trước hoặc sau khi thực thi công cụ. (Cần khởi động lại sau khi lưu cài đặt)" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/zh-CN/settings.json b/webview-ui/src/i18n/locales/zh-CN/settings.json index f301f17e08c..f9b94780df5 100644 --- a/webview-ui/src/i18n/locales/zh-CN/settings.json +++ b/webview-ui/src/i18n/locales/zh-CN/settings.json @@ -36,12 +36,63 @@ "contextManagement": "上下文", "terminal": "终端", "slashCommands": "斜杠命令", + "hooks": "Hooks", "prompts": "提示词", "ui": "UI", "experimental": "实验性", "language": "语言", "about": "关于 Roo Code" }, + "hooks": { + "description": "Hooks 在 Roo 使用特定工具时自动执行自定义 shell 命令。用于集成外部系统、执行工作流或自动化重复任务。", + "configuredHooks": "已配置的 Hooks", + "lastLoadedTooltip": "上次加载于 {{time}}", + "reloadTooltip": "从磁盘重新加载 hooks 配置", + "reload": "重新加载", + "openProjectFolderTooltip": "打开项目 hooks 配置文件夹", + "openGlobalFolderTooltip": "打开全局 hooks 配置文件夹", + "openProjectFolder": "打开项目文件夹", + "openGlobalFolder": "打开全局文件夹", + "createNewHook": "创建新 hook", + "deleteHook": "删除 hook", + "openHookFile": "打开 hook 文件", + "projectHooksWarningTitle": "检测到项目级 hooks", + "projectHooksWarningMessage": "此项目包含将执行 shell 命令的 hooks 配置。仅在信任来源时启用 hooks。", + "reloadNote": "对 hooks 配置文件的更改需要点击重新加载才能生效。", + "openHookFileTooltip": "在编辑器中打开 hook 文件", + "openHookFileUnavailableTooltip": "hook 文件位置不可用", + "matcherNote": "匹配器根据 Roo Code 的内部工具 ID（如 write_to_file、edit_file、apply_diff、apply_patch）进行评估，而非 Write/Edit 等显示标签。", + "matcherExamplesLabel": "示例：", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "尚未配置 hooks", + "noHooksHint": "创建 hooks 配置文件以在工具执行时自动化操作。", + "enableHooks": "启用 hooks", + "enableHooksDescription": "一次性启用或禁用所有 hooks", + "enabled": "已启用", + "event": "事件", + "matcher": "匹配器", + "command": "命令", + "shell": "Shell", + "timeout": "超时", + "logs": "日志", + "noLogsForHook": "此 hook 暂无执行日志", + "activityLog": "Hooks 活动", + "status": { + "running": "运行中", + "completed": "已完成", + "failed": "失败", + "blocked": "已阻止", + "timeout": "超时" + }, + "tabs": { + "config": "配置", + "command": "命令", + "logs": "日志" + } + }, "about": { "bugReport": { "label": "发现 Bug？", @@ -844,6 +895,10 @@ "refreshSuccess": "工具刷新成功", "refreshError": "工具刷新失败", "toolParameters": "参数" + }, + "HOOKS": { + "name": "启用 Hooks", + "description": "使用自定义 shell 命令在工具执行前后自动执行操作。（保存设置后需要重启）" } }, "promptCaching": { diff --git a/webview-ui/src/i18n/locales/zh-TW/settings.json b/webview-ui/src/i18n/locales/zh-TW/settings.json index d57b05d2f49..45b5d64d558 100644 --- a/webview-ui/src/i18n/locales/zh-TW/settings.json +++ b/webview-ui/src/i18n/locales/zh-TW/settings.json @@ -36,12 +36,63 @@ "contextManagement": "上下文", "terminal": "終端機", "slashCommands": "斜線命令", + "hooks": "Hooks", "prompts": "提示詞", "ui": "UI", "experimental": "實驗性", "language": "語言", "about": "關於 Roo Code" }, + "hooks": { + "description": "Hooks 會在 Roo 使用特定工具時自動執行自訂 shell 命令。用於整合外部系統、執行工作流程或自動化重複工作。", + "configuredHooks": "已設定的 Hooks", + "lastLoadedTooltip": "上次載入於 {{time}}", + "reloadTooltip": "從磁碟重新載入 hooks 設定", + "reload": "重新載入", + "openProjectFolderTooltip": "開啟專案 hooks 設定資料夾", + "openGlobalFolderTooltip": "開啟全域 hooks 設定資料夾", + "openProjectFolder": "開啟專案資料夾", + "openGlobalFolder": "開啟全域資料夾", + "createNewHook": "建立新 hook", + "deleteHook": "刪除 hook", + "openHookFile": "開啟 hook 檔案", + "projectHooksWarningTitle": "偵測到專案層級 hooks", + "projectHooksWarningMessage": "此專案包含將執行 shell 命令的 hooks 設定。僅在信任來源時啟用 hooks。", + "reloadNote": "對 hooks 設定檔的變更需要點擊重新載入才能生效。", + "openHookFileTooltip": "在編輯器中開啟 hook 檔案", + "openHookFileUnavailableTooltip": "hook 檔案位置不可用", + "matcherNote": "匹配器根據 Roo Code 的內部工具 ID（如 write_to_file、edit_file、apply_diff、apply_patch）進行評估，而非 Write/Edit 等顯示標籤。", + "matcherExamplesLabel": "範例：", + "matcherExamples": { + "writeOrEdit": "write_to_file|edit_file|apply_diff|apply_patch", + "readOnly": "read_file|list_files" + }, + "noHooksConfigured": "尚未設定 hooks", + "noHooksHint": "建立 hooks 設定檔以在工具執行時自動化操作。", + "enableHooks": "啟用 hooks", + "enableHooksDescription": "一次性啟用或停用所有 hooks", + "enabled": "已啟用", + "event": "事件", + "matcher": "匹配器", + "command": "命令", + "shell": "Shell", + "timeout": "逾時", + "logs": "日誌", + "noLogsForHook": "此 hook 暫無執行日誌", + "activityLog": "Hooks 活動", + "status": { + "running": "執行中", + "completed": "已完成", + "failed": "失敗", + "blocked": "已封鎖", + "timeout": "逾時" + }, + "tabs": { + "config": "設定", + "command": "命令", + "logs": "日誌" + } + }, "about": { "bugReport": { "label": "發現錯誤？", @@ -844,6 +895,10 @@ "refreshSuccess": "工具重新整理成功", "refreshError": "工具重新整理失敗", "toolParameters": "參數" + }, + "HOOKS": { + "name": "啟用 Hooks", + "description": "使用自訂 shell 指令在工具執行前後自動執行操作。（儲存設定後需要重新啟動）" } }, "promptCaching": {