@crewx/sdk 0.8.0-rc.73 → 0.8.0-rc.75

package/dist/hooks/define.d.ts

@@ -0,0 +1,10 @@
+import { ToolObserverPlugin, type ObserverSubscription } from './observer';
+import type { ObserverContext, ObserverResult } from './types';
+export interface PluginDefinition {
+    name: string;
+    version: string;
+    on: ObserverSubscription;
+    run(ctx: ObserverContext): Promise<ObserverResult>;
+}
+export declare function definePlugin(def: PluginDefinition): ToolObserverPlugin;
+//# sourceMappingURL=define.d.ts.map

package/dist/hooks/define.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definePlugin = definePlugin;
+const observer_1 = require("./observer");
+function definePlugin(def) {
+    return new (class extends observer_1.ToolObserverPlugin {
+        name = def.name;
+        version = def.version;
+        on = def.on;
+        run = def.run;
+    })();
+}
+//# sourceMappingURL=define.js.map

package/dist/hooks/dispatch.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Security notes:
+ *
+ * (M1) Codex `systemMessage` is merged into the agent's system prompt directly.
+ *      Guide messages MUST NOT contain dynamic external input (tool_input,
+ *      external API results, etc.) to prevent prompt injection via hook inject.
+ *
+ * Provider matching: When `provider` is not specified in a hook definition,
+ * it applies to ALL providers (§4.1.1 2-Layer Selector design).
+ * This is intentional — allows catch-all safety rules.
+ */
+import type { HookContext } from '../hooks/types';
+import type { HookPlugin } from '../hooks/plugin';
+export interface ClaudeHookInput {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    hook_event_name: string;
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_use_id: string;
+}
+export interface ClaudeHookOutput {
+    hookSpecificOutput: {
+        hookEventName: string;
+        permissionDecision: 'allow' | 'deny' | 'ask';
+        permissionDecisionReason?: string;
+        additionalContext?: string;
+    };
+}
+export interface CodexHookOutput {
+    hookSpecificOutput: {
+        hookEventName: string;
+        permissionDecision: 'allow' | 'deny' | 'ask';
+        permissionDecisionReason?: string;
+        systemMessage?: string;
+    };
+}
+export interface ProviderHookOutput {
+    hookSpecificOutput: {
+        hookEventName: string;
+        permissionDecision: 'allow' | 'deny' | 'ask';
+        permissionDecisionReason?: string;
+        additionalContext?: string;
+        systemMessage?: string;
+    };
+}
+export type Provider = 'claude' | 'codex';
+export interface HookDispatchResult {
+    exitCode: number;
+    stdout: ProviderHookOutput;
+    injected: boolean;
+}
+export declare function sanitizeDenyReason(reason: string): string;
+export declare function sanitizeInjectMessage(message: string): string;
+export declare function isPathSafe(pluginPath: string, projectRoot: string): boolean;
+export declare function formatInjectOutput(provider: Provider, hookEventName: string, message: string): ProviderHookOutput;
+export declare function formatDenyOutput(_provider: Provider, hookEventName: string, reason: string): ProviderHookOutput;
+export declare function buildHookContext(input: ClaudeHookInput, cwd: string, provider?: string): HookContext;
+export declare function evaluateHook(plugin: HookPlugin, input: ClaudeHookInput, cwd: string, provider?: string): Promise<HookDispatchResult>;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/hooks/dispatch.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Security notes:
+ *
+ * (M1) Codex `systemMessage` is merged into the agent's system prompt directly.
+ *      Guide messages MUST NOT contain dynamic external input (tool_input,
+ *      external API results, etc.) to prevent prompt injection via hook inject.
+ *
+ * Provider matching: When `provider` is not specified in a hook definition,
+ * it applies to ALL providers (§4.1.1 2-Layer Selector design).
+ * This is intentional — allows catch-all safety rules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeDenyReason = sanitizeDenyReason;
+exports.sanitizeInjectMessage = sanitizeInjectMessage;
+exports.isPathSafe = isPathSafe;
+exports.formatInjectOutput = formatInjectOutput;
+exports.formatDenyOutput = formatDenyOutput;
+exports.buildHookContext = buildHookContext;
+exports.evaluateHook = evaluateHook;
+const path_1 = require("path");
+const tool_normalize_1 = require("./tool-normalize");
+const MAX_REASON_LENGTH = 200;
+const MAX_INJECT_LENGTH = 2000;
+function sanitizeDenyReason(reason) {
+    const cleaned = reason.replace(/[\x00-\x1f\x7f\u2028\u2029]/g, '');
+    if (cleaned.length <= MAX_REASON_LENGTH) {
+        return cleaned;
+    }
+    return cleaned.slice(0, MAX_REASON_LENGTH - 11) + ' [redacted]';
+}
+function sanitizeInjectMessage(message) {
+    const cleaned = message.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f\u2028\u2029]/g, '');
+    if (cleaned.length <= MAX_INJECT_LENGTH) {
+        return cleaned;
+    }
+    return cleaned.slice(0, MAX_INJECT_LENGTH - 11) + ' [redacted]';
+}
+function isPathSafe(pluginPath, projectRoot) {
+    const resolved = (0, path_1.resolve)(pluginPath);
+    const root = (0, path_1.resolve)(projectRoot);
+    const rel = (0, path_1.relative)(root, resolved);
+    if (rel.startsWith('..') || (0, path_1.resolve)(resolved).startsWith('/etc/') || (0, path_1.resolve)(resolved).startsWith('/usr/')) {
+        return false;
+    }
+    if (resolved.includes('node_modules')) {
+        return false;
+    }
+    return true;
+}
+function toProvider(provider) {
+    if (provider === 'codex')
+        return 'codex';
+    return 'claude';
+}
+function formatInjectOutput(provider, hookEventName, message) {
+    switch (provider) {
+        case 'codex':
+            return {
+                hookSpecificOutput: {
+                    hookEventName,
+                    permissionDecision: 'allow',
+                    systemMessage: message,
+                },
+            };
+        default:
+            return {
+                hookSpecificOutput: {
+                    hookEventName,
+                    permissionDecision: 'allow',
+                    additionalContext: message,
+                },
+            };
+    }
+}
+function formatDenyOutput(_provider, hookEventName, reason) {
+    return {
+        hookSpecificOutput: {
+            hookEventName,
+            permissionDecision: 'deny',
+            permissionDecisionReason: reason,
+        },
+    };
+}
+function buildHookContext(input, cwd, provider = 'cli/claude') {
+    const resolvedProvider = provider || process.env.CREWX_PROVIDER || 'cli/claude';
+    return {
+        event: 'beforeTool',
+        traceId: input.tool_use_id || '',
+        agent: {
+            id: process.env.CREWX_AGENT_ID || '',
+            role: process.env.CREWX_AGENT_ROLE || '',
+            team: process.env.CREWX_AGENT_TEAM || '',
+        },
+        provider: resolvedProvider,
+        thread: { id: process.env.CREWX_THREAD_ID || '' },
+        tool: {
+            name: (0, tool_normalize_1.normalizeToolName)(input.tool_name, resolvedProvider),
+            rawName: input.tool_name,
+            input: input.tool_input,
+        },
+        cwd: cwd || input.cwd,
+        sessionId: input.session_id || process.env.CREWX_SESSION_ID || '',
+        pass: () => ({ type: 'pass' }),
+        deny: (r) => ({ type: 'deny', reason: r }),
+        inject: (m) => ({ type: 'inject', message: m }),
+        modify: (p) => ({ type: 'modify', patch: p }),
+    };
+}
+async function evaluateHook(plugin, input, cwd, provider = 'cli/claude') {
+    const ctx = buildHookContext(input, cwd, provider);
+    const result = await plugin.run(ctx);
+    const simpleProvider = toProvider(provider);
+    const baseOutput = {
+        hookSpecificOutput: {
+            hookEventName: input.hook_event_name,
+            permissionDecision: 'allow',
+        },
+    };
+    switch (result.type) {
+        case 'pass':
+            return { exitCode: 0, stdout: baseOutput, injected: false };
+        case 'deny': {
+            const sanitizedReason = sanitizeDenyReason(result.reason);
+            return {
+                exitCode: 2,
+                stdout: formatDenyOutput(simpleProvider, input.hook_event_name, sanitizedReason),
+                injected: false,
+            };
+        }
+        case 'inject': {
+            const sanitizedMessage = sanitizeInjectMessage(result.message);
+            return {
+                exitCode: 0,
+                stdout: formatInjectOutput(simpleProvider, input.hook_event_name, sanitizedMessage),
+                injected: true,
+            };
+        }
+        case 'modify':
+            console.error(`[crewx] Hook result type '${result.type}' is not supported in Phase 0. ` +
+                `Plugin: ${plugin.name}. Treating as pass.`);
+            return { exitCode: 0, stdout: baseOutput, injected: false };
+        default:
+            return { exitCode: 0, stdout: baseOutput, injected: false };
+    }
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/hooks/index.d.ts

@@ -0,0 +1,13 @@
+export { ToolObserverPlugin } from './observer';
+export type { ObserverSubscription } from './observer';
+export { HookPlugin, defineHookPlugin } from './plugin';
+export type { HookPluginDefinition } from './plugin';
+export { definePlugin } from './define';
+export type { PluginDefinition } from './define';
+export { YamlHookPlugin, validateHooksSchema } from './yaml-plugin';
+export type { YamlHookConfig } from './yaml-plugin';
+export { Tools } from './types';
+export type { ObserverContext, ObserverResult, ObserverEvent, HookContext, HookResult, HookEvent, ToolName, ToolInputPatch, Capability, } from './types';
+export { evaluateHook, sanitizeDenyReason, sanitizeInjectMessage, isPathSafe, buildHookContext, formatInjectOutput, formatDenyOutput, } from './dispatch';
+export type { ClaudeHookInput, ClaudeHookOutput, CodexHookOutput, ProviderHookOutput, Provider, HookDispatchResult, } from './dispatch';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDenyOutput = exports.formatInjectOutput = exports.buildHookContext = exports.isPathSafe = exports.sanitizeInjectMessage = exports.sanitizeDenyReason = exports.evaluateHook = exports.Tools = exports.validateHooksSchema = exports.YamlHookPlugin = exports.definePlugin = exports.defineHookPlugin = exports.HookPlugin = exports.ToolObserverPlugin = void 0;
+var observer_1 = require("./observer");
+Object.defineProperty(exports, "ToolObserverPlugin", { enumerable: true, get: function () { return observer_1.ToolObserverPlugin; } });
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "HookPlugin", { enumerable: true, get: function () { return plugin_1.HookPlugin; } });
+Object.defineProperty(exports, "defineHookPlugin", { enumerable: true, get: function () { return plugin_1.defineHookPlugin; } });
+var define_1 = require("./define");
+Object.defineProperty(exports, "definePlugin", { enumerable: true, get: function () { return define_1.definePlugin; } });
+var yaml_plugin_1 = require("./yaml-plugin");
+Object.defineProperty(exports, "YamlHookPlugin", { enumerable: true, get: function () { return yaml_plugin_1.YamlHookPlugin; } });
+Object.defineProperty(exports, "validateHooksSchema", { enumerable: true, get: function () { return yaml_plugin_1.validateHooksSchema; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "Tools", { enumerable: true, get: function () { return types_1.Tools; } });
+var dispatch_1 = require("./dispatch");
+Object.defineProperty(exports, "evaluateHook", { enumerable: true, get: function () { return dispatch_1.evaluateHook; } });
+Object.defineProperty(exports, "sanitizeDenyReason", { enumerable: true, get: function () { return dispatch_1.sanitizeDenyReason; } });
+Object.defineProperty(exports, "sanitizeInjectMessage", { enumerable: true, get: function () { return dispatch_1.sanitizeInjectMessage; } });
+Object.defineProperty(exports, "isPathSafe", { enumerable: true, get: function () { return dispatch_1.isPathSafe; } });
+Object.defineProperty(exports, "buildHookContext", { enumerable: true, get: function () { return dispatch_1.buildHookContext; } });
+Object.defineProperty(exports, "formatInjectOutput", { enumerable: true, get: function () { return dispatch_1.formatInjectOutput; } });
+Object.defineProperty(exports, "formatDenyOutput", { enumerable: true, get: function () { return dispatch_1.formatDenyOutput; } });
+//# sourceMappingURL=index.js.map

package/dist/hooks/observer.d.ts

@@ -0,0 +1,20 @@
+import { CrewxPlugin } from '../plugin';
+import type { Crewx } from '../facade/Crewx';
+import type { ObserverContext, ObserverResult, ToolName } from './types';
+export interface ObserverSubscription {
+    beforeTool?: ToolName[] | true;
+    afterTool?: ToolName[] | true;
+    beforePrompt?: true;
+    sessionStart?: true;
+}
+export declare abstract class ToolObserverPlugin extends CrewxPlugin {
+    abstract readonly version: string;
+    abstract readonly on: ObserverSubscription;
+    private unsubs;
+    abstract run(ctx: ObserverContext): Promise<ObserverResult>;
+    attach(crewx: Crewx): void;
+    detach(_crewx: Crewx): Promise<void>;
+    private matchesTool;
+    private buildContext;
+}
+//# sourceMappingURL=observer.d.ts.map

package/dist/hooks/observer.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolObserverPlugin = void 0;
+const plugin_1 = require("../plugin");
+class ToolObserverPlugin extends plugin_1.CrewxPlugin {
+    unsubs = [];
+    attach(crewx) {
+        if (this.on.beforeTool) {
+            const unsub = crewx.on('tool:observed:before', async (e) => {
+                if (!this.matchesTool(this.on.beforeTool, e.tool.name))
+                    return;
+                const ctx = this.buildContext('beforeTool', e);
+                await this.run(ctx);
+            });
+            this.unsubs.push(unsub);
+        }
+        if (this.on.afterTool) {
+            const unsub = crewx.on('tool:observed:after', async (e) => {
+                if (!this.matchesTool(this.on.afterTool, e.tool.name))
+                    return;
+                const ctx = this.buildContext('afterTool', e);
+                await this.run(ctx);
+            });
+            this.unsubs.push(unsub);
+        }
+    }
+    async detach(_crewx) {
+        for (const unsub of this.unsubs)
+            unsub();
+        this.unsubs = [];
+    }
+    matchesTool(filter, toolName) {
+        if (filter === true)
+            return true;
+        return filter.includes(toolName);
+    }
+    buildContext(event, e) {
+        return {
+            event,
+            traceId: e.traceId,
+            agent: {
+                id: e.agentId || e.agentRef,
+                role: '',
+                team: '',
+            },
+            provider: e.provider,
+            thread: { id: e.threadId || '' },
+            tool: {
+                name: e.tool.name,
+                rawName: e.tool.rawName,
+                input: 'input' in e.tool ? e.tool.input : undefined,
+            },
+            cwd: process.cwd(),
+            sessionId: e.sessionId || '',
+            pass: () => ({ type: 'pass' }),
+        };
+    }
+}
+exports.ToolObserverPlugin = ToolObserverPlugin;
+//# sourceMappingURL=observer.js.map

package/dist/hooks/plugin.d.ts

@@ -0,0 +1,19 @@
+import type { HookContext, HookResult, Capability } from './types';
+export declare abstract class HookPlugin {
+    abstract readonly name: string;
+    abstract readonly version: string;
+    abstract run(ctx: HookContext): Promise<HookResult>;
+    readonly capabilities: {
+        required: readonly Capability[];
+    };
+}
+export interface HookPluginDefinition {
+    name: string;
+    version: string;
+    capabilities?: {
+        required: Capability[];
+    };
+    run(ctx: HookContext): Promise<HookResult>;
+}
+export declare function defineHookPlugin(def: HookPluginDefinition): HookPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/hooks/plugin.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookPlugin = void 0;
+exports.defineHookPlugin = defineHookPlugin;
+class HookPlugin {
+    capabilities = { required: [] };
+}
+exports.HookPlugin = HookPlugin;
+function defineHookPlugin(def) {
+    return new (class extends HookPlugin {
+        name = def.name;
+        version = def.version;
+        capabilities = def.capabilities ?? { required: [] };
+        run = def.run;
+    })();
+}
+//# sourceMappingURL=plugin.js.map

package/dist/hooks/tool-normalize.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Tool name normalization — 5-provider raw tool names → Tools.* enum.
+ *
+ * Design: docs/hook-설계서.md §8.1 Tools.* 정규화 enum.
+ *
+ * Raw tool names come from each provider's PreToolUse stdin payload:
+ *  - Claude:   "Read" / "Write" / "Edit" / "Bash" / "Grep" / "Glob" / ...
+ *  - Codex:    everything routed through "Bash" (shell command) — parsing optional
+ *  - Gemini:   "read_file" / "write_file" / "replace" / "run_shell_command" / ...
+ *  - Copilot:  "read" / "write" / "shell" / ...
+ *  - OpenCode: "file.read" / "file.write" / "file.edit" / "bash" / ...
+ *
+ * Unknown tools fall through to Tools.Other (still usable via `rawName` in rules).
+ */
+import { type ToolName } from './types';
+export type ProviderKey = 'claude' | 'codex' | 'gemini' | 'copilot' | 'opencode';
+/**
+ * Normalize a provider's raw tool name to the Tools.* enum.
+ *
+ * Matching priority:
+ *  1. Exact key lookup in the provider's table.
+ *  2. Fallback: if rawName already looks like a Tools.* value (contains a dot), accept it.
+ *  3. Otherwise → Tools.Other.
+ *
+ * @param rawName  provider-specific tool name (e.g. "Read", "read_file")
+ * @param provider provider key; accepts 'cli/claude' style prefix too.
+ */
+export declare function normalizeToolName(rawName: string, provider: string): ToolName;
+//# sourceMappingURL=tool-normalize.d.ts.map

package/dist/hooks/tool-normalize.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Tool name normalization — 5-provider raw tool names → Tools.* enum.
+ *
+ * Design: docs/hook-설계서.md §8.1 Tools.* 정규화 enum.
+ *
+ * Raw tool names come from each provider's PreToolUse stdin payload:
+ *  - Claude:   "Read" / "Write" / "Edit" / "Bash" / "Grep" / "Glob" / ...
+ *  - Codex:    everything routed through "Bash" (shell command) — parsing optional
+ *  - Gemini:   "read_file" / "write_file" / "replace" / "run_shell_command" / ...
+ *  - Copilot:  "read" / "write" / "shell" / ...
+ *  - OpenCode: "file.read" / "file.write" / "file.edit" / "bash" / ...
+ *
+ * Unknown tools fall through to Tools.Other (still usable via `rawName` in rules).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToolName = normalizeToolName;
+const types_1 = require("./types");
+const CLAUDE = {
+    Read: types_1.Tools.FileRead,
+    Write: types_1.Tools.FileWrite,
+    Edit: types_1.Tools.FileEdit,
+    MultiEdit: types_1.Tools.FileEdit,
+    NotebookEdit: types_1.Tools.FileEdit,
+    Bash: types_1.Tools.Shell,
+    Grep: types_1.Tools.Search,
+    Glob: types_1.Tools.Search,
+};
+const GEMINI = {
+    read_file: types_1.Tools.FileRead,
+    write_file: types_1.Tools.FileWrite,
+    replace: types_1.Tools.FileEdit,
+    edit: types_1.Tools.FileEdit,
+    run_shell_command: types_1.Tools.Shell,
+    search_file_content: types_1.Tools.Search,
+    glob: types_1.Tools.Search,
+};
+const COPILOT = {
+    read: types_1.Tools.FileRead,
+    write: types_1.Tools.FileWrite,
+    edit: types_1.Tools.FileEdit,
+    shell: types_1.Tools.Shell,
+    bash: types_1.Tools.Shell,
+    search: types_1.Tools.Search,
+    grep: types_1.Tools.Search,
+};
+const OPENCODE = {
+    'file.read': types_1.Tools.FileRead,
+    'file.write': types_1.Tools.FileWrite,
+    'file.edit': types_1.Tools.FileEdit,
+    read: types_1.Tools.FileRead,
+    write: types_1.Tools.FileWrite,
+    edit: types_1.Tools.FileEdit,
+    bash: types_1.Tools.Shell,
+    shell: types_1.Tools.Shell,
+    grep: types_1.Tools.Search,
+    glob: types_1.Tools.Search,
+};
+// Codex routes file ops through Bash — no direct file tools to map.
+// Users can still match on Tools.Shell or use `pattern`/`regex` against ctx.tool.input.command.
+const CODEX = {
+    Bash: types_1.Tools.Shell,
+    bash: types_1.Tools.Shell,
+};
+const TABLES = {
+    claude: CLAUDE,
+    codex: CODEX,
+    gemini: GEMINI,
+    copilot: COPILOT,
+    opencode: OPENCODE,
+};
+/**
+ * Normalize a provider's raw tool name to the Tools.* enum.
+ *
+ * Matching priority:
+ *  1. Exact key lookup in the provider's table.
+ *  2. Fallback: if rawName already looks like a Tools.* value (contains a dot), accept it.
+ *  3. Otherwise → Tools.Other.
+ *
+ * @param rawName  provider-specific tool name (e.g. "Read", "read_file")
+ * @param provider provider key; accepts 'cli/claude' style prefix too.
+ */
+function normalizeToolName(rawName, provider) {
+    const key = resolveProviderKey(provider);
+    if (key) {
+        const mapped = TABLES[key][rawName];
+        if (mapped)
+            return mapped;
+    }
+    // Already-normalized form passes through (e.g. OpenCode "file.read").
+    if (Object.values(types_1.Tools).includes(rawName)) {
+        return rawName;
+    }
+    return types_1.Tools.Other;
+}
+function resolveProviderKey(provider) {
+    const lower = provider.toLowerCase();
+    if (lower.includes('claude'))
+        return 'claude';
+    if (lower.includes('codex'))
+        return 'codex';
+    if (lower.includes('gemini'))
+        return 'gemini';
+    if (lower.includes('copilot'))
+        return 'copilot';
+    if (lower.includes('opencode'))
+        return 'opencode';
+    return null;
+}
+//# sourceMappingURL=tool-normalize.js.map

package/dist/hooks/types.d.ts

@@ -0,0 +1,79 @@
+export declare const Tools: {
+    readonly FileRead: "file.read";
+    readonly FileWrite: "file.write";
+    readonly FileEdit: "file.edit";
+    readonly Shell: "shell";
+    readonly Search: "search";
+    readonly Other: "other";
+};
+export type ToolName = typeof Tools[keyof typeof Tools];
+export type ObserverEvent = 'beforeTool' | 'afterTool' | 'beforePrompt' | 'sessionStart';
+export interface ObserverContext {
+    event: ObserverEvent;
+    traceId: string;
+    agent: {
+        id: string;
+        role: string;
+        team: string;
+    };
+    provider: string;
+    thread: {
+        id: string;
+    };
+    tool: {
+        name: ToolName | string;
+        rawName: string;
+        input: unknown;
+    };
+    cwd: string;
+    sessionId: string;
+    config?: Record<string, unknown>;
+    pass(): ObserverResult;
+}
+export type ObserverResult = {
+    type: 'pass';
+};
+export type HookEvent = 'beforeTool' | 'afterTool' | 'beforePrompt' | 'sessionStart';
+export interface HookContext {
+    event: HookEvent;
+    traceId: string;
+    agent: {
+        id: string;
+        role: string;
+        team: string;
+    };
+    provider: string;
+    thread: {
+        id: string;
+    };
+    tool: {
+        name: ToolName | string;
+        rawName: string;
+        input: unknown;
+    };
+    cwd: string;
+    sessionId: string;
+    config?: Record<string, unknown>;
+    pass(): HookResult;
+    deny(reason: string): HookResult;
+    inject(message: string): HookResult;
+    modify(patch: ToolInputPatch): HookResult;
+}
+export type HookResult = {
+    type: 'pass';
+} | {
+    type: 'deny';
+    reason: string;
+} | {
+    type: 'inject';
+    message: string;
+} | {
+    type: 'modify';
+    patch: ToolInputPatch;
+};
+export interface ToolInputPatch {
+    input?: Record<string, unknown>;
+    systemPromptPrepend?: string;
+}
+export type Capability = 'inject' | 'deny' | 'modify' | 'ask';
+//# sourceMappingURL=types.d.ts.map

package/dist/hooks/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tools = void 0;
+exports.Tools = {
+    FileRead: 'file.read',
+    FileWrite: 'file.write',
+    FileEdit: 'file.edit',
+    Shell: 'shell',
+    Search: 'search',
+    Other: 'other',
+};
+//# sourceMappingURL=types.js.map

package/dist/hooks/yaml-plugin.d.ts

@@ -0,0 +1,29 @@
+import { HookPlugin } from './plugin';
+import type { HookContext, HookResult } from './types';
+import type { YamlHookEntry, AgentConfig } from '../types';
+export interface YamlHookConfig {
+    hooks: YamlHookEntry[];
+    agents?: AgentConfig[];
+}
+export declare function validateHooksSchema(hooks: unknown[]): {
+    valid: YamlHookEntry[];
+    warnings: string[];
+};
+export declare class YamlHookPlugin extends HookPlugin {
+    readonly name = "@crewx/yaml-hook-plugin";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        required: readonly ["inject"];
+    };
+    private readonly hooks;
+    private readonly agentMap;
+    constructor(config: YamlHookConfig);
+    run(ctx: HookContext): Promise<HookResult>;
+    private appendHookLog;
+    private matchEntryLevel;
+    private matchRuleLevel;
+    private hasFired;
+    private markFired;
+    firedFilePath(sessionId: string): string;
+}
+//# sourceMappingURL=yaml-plugin.d.ts.map