@ebowwa/coder 0.7.63 → 0.7.65

package/dist/core/cognitive-security/hooks.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Cognitive Security Hooks
+ *
+ * Automatic security checks integrated into the agent lifecycle.
+ * No manual calls needed - hooks intercept all operations.
+ */
+import type { HookInput, HookOutput } from "../../types/index.js";
+import { type AgentIntent } from "./index.js";
+/**
+ * Security configuration for hooks
+ */
+export interface SecurityHookConfig {
+    /** Enable all security checks */
+    enabled: boolean;
+    /** Check intent alignment before actions */
+    checkIntentAlignment: boolean;
+    /** Enforce flow policies */
+    enforceFlowPolicies: boolean;
+    /** Check for data leaks */
+    preventLeaks: boolean;
+    /** Track taint propagation */
+    trackTaints: boolean;
+    /** Log security events */
+    logEvents: boolean;
+    /** Block on violations (false = log only) */
+    blockOnViolation: boolean;
+    /** Minimum alignment score to allow (0-1) */
+    minAlignmentScore: number;
+    /** Sensitivities that require approval */
+    approvalRequiredSensitivities: string[];
+    /** Domains that require signed actions (every action cryptographically signed) */
+    requireSignedActions: string[];
+    /** Threshold for drift detection (0-1, higher = more strict) */
+    driftThreshold: number;
+    /** Enable immutable directives (cryptographically signed rules outside AI context) */
+    enableImmutableDirectives: boolean;
+    /** Require approval for operations above this sensitivity level */
+    approvalSensitivityLevel: string;
+}
+export declare const DEFAULT_SECURITY_CONFIG: SecurityHookConfig;
+/**
+ * Security event for logging
+ */
+export interface SecurityEvent {
+    timestamp: number;
+    hook: string;
+    tool?: string;
+    action: "check" | "allow" | "deny" | "sanitize";
+    reason?: string;
+    sensitivity?: string;
+    category?: string;
+    alignmentScore?: number;
+    dataId?: string;
+}
+/**
+ * Cognitive Security Hook Handler
+ *
+ * Maintains state across hooks and provides security check methods.
+ */
+export declare class CognitiveSecurityHooks {
+    private config;
+    private intent;
+    private policyEngine;
+    private flowTracker;
+    private leakPrevention;
+    private taintTracker;
+    private events;
+    private initialized;
+    private sessionId;
+    constructor(config?: Partial<SecurityHookConfig>);
+    /**
+     * Initialize security components (called on SessionStart)
+     */
+    private initialize;
+    /**
+     * Set the agent intent for alignment checking
+     */
+    setIntent(intent: AgentIntent): void;
+    /**
+     * SessionStart hook - Initialize security and load intent
+     */
+    onSessionStart(input: HookInput): Promise<HookOutput>;
+    /**
+     * PreToolUse hook - Check intent, classify action, enforce policies
+     */
+    onPreToolUse(input: HookInput): Promise<HookOutput>;
+    /**
+     * PostToolUse hook - Check output for leaks, track flows
+     */
+    onPostToolUse(input: HookInput): Promise<HookOutput>;
+    /**
+     * UserPromptSubmit hook - Check user input for injection attempts
+     */
+    onUserPromptSubmit(input: HookInput): Promise<HookOutput>;
+    /**
+     * SessionEnd hook - Generate security report
+     */
+    onSessionEnd(_input: HookInput): Promise<HookOutput>;
+    private inferActionType;
+    private inferDomain;
+    private isExternalTool;
+    private extractContent;
+    private log;
+    /**
+     * Get all security events
+     */
+    getEvents(): SecurityEvent[];
+    /**
+     * Get security statistics
+     */
+    getStats(): {
+        totalEvents: number;
+        allowedCount: number;
+        deniedCount: number;
+        sanitizedCount: number;
+        bySensitivity: Record<string, number>;
+        avgAlignmentScore: number;
+    };
+    /**
+     * Clear event history
+     */
+    clearEvents(): void;
+}
+/**
+ * Get global security hooks instance
+ */
+export declare function getSecurityHooks(config?: Partial<SecurityHookConfig>): CognitiveSecurityHooks;
+/**
+ * Create hook handlers for HookManager
+ */
+export declare function createSecurityHookHandlers(config?: Partial<SecurityHookConfig>): {
+    SessionStart: (input: HookInput) => Promise<HookOutput>;
+    PreToolUse: (input: HookInput) => Promise<HookOutput>;
+    PostToolUse: (input: HookInput) => Promise<HookOutput>;
+    UserPromptSubmit: (input: HookInput) => Promise<HookOutput>;
+    SessionEnd: (input: HookInput) => Promise<HookOutput>;
+};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/core/cognitive-security/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../packages/src/core/cognitive-security/hooks.ts"],"names":[],"mappings":"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"}

package/dist/core/cognitive-security/hooks.js

@@ -0,0 +1,389 @@
+/**
+ * Cognitive Security Hooks
+ *
+ * Automatic security checks integrated into the agent lifecycle.
+ * No manual calls needed - hooks intercept all operations.
+ */
+import { classifyData, classifyOperation, scoreAlignment, createFlowPolicyEngine, createFlowTracker, createLeakPrevention, createTaintTracker, } from "./index.js";
+export const DEFAULT_SECURITY_CONFIG = {
+    enabled: true,
+    checkIntentAlignment: true,
+    enforceFlowPolicies: true,
+    preventLeaks: true,
+    trackTaints: true,
+    logEvents: true,
+    blockOnViolation: true,
+    minAlignmentScore: 0.5,
+    approvalRequiredSensitivities: ["secret", "top_secret"],
+    // Domains requiring cryptographic action signing
+    requireSignedActions: ["financial", "external", "credentials"],
+    // Drift detection threshold - flag when behavior deviates > 30%
+    driftThreshold: 0.3,
+    // Enable immutable directives from secure storage
+    enableImmutableDirectives: true,
+    // Sensitivity level requiring explicit user approval
+    approvalSensitivityLevel: "confidential",
+};
+/**
+ * Cognitive Security Hook Handler
+ *
+ * Maintains state across hooks and provides security check methods.
+ */
+export class CognitiveSecurityHooks {
+    config;
+    intent = null;
+    policyEngine = null;
+    flowTracker = null;
+    leakPrevention = null;
+    taintTracker = null;
+    events = [];
+    initialized = false;
+    sessionId = null;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_SECURITY_CONFIG, ...config };
+    }
+    /**
+     * Initialize security components (called on SessionStart)
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            if (this.config.enforceFlowPolicies) {
+                this.policyEngine = await createFlowPolicyEngine();
+            }
+            if (this.config.trackTaints) {
+                this.flowTracker = await createFlowTracker();
+                this.taintTracker = await createTaintTracker();
+            }
+            if (this.config.preventLeaks) {
+                this.leakPrevention = await createLeakPrevention();
+            }
+            this.initialized = true;
+            this.log("SessionStart", undefined, "check", "Security hooks initialized");
+        }
+        catch (error) {
+            this.log("SessionStart", undefined, "check", `Init failed: ${error}`);
+        }
+    }
+    /**
+     * Set the agent intent for alignment checking
+     */
+    setIntent(intent) {
+        this.intent = intent;
+        this.log("SessionStart", undefined, "check", `Intent loaded: ${intent.identity.name}`);
+    }
+    /**
+     * SessionStart hook - Initialize security and load intent
+     */
+    async onSessionStart(input) {
+        await this.initialize();
+        this.sessionId = input.session_id || null;
+        // Intent should be set externally before session starts
+        // This is just initialization
+        return { decision: "allow" };
+    }
+    /**
+     * PreToolUse hook - Check intent, classify action, enforce policies
+     */
+    async onPreToolUse(input) {
+        if (!this.config.enabled) {
+            return { decision: "allow" };
+        }
+        await this.initialize();
+        const toolName = input.tool_name || "unknown";
+        const toolInput = input.tool_input || {};
+        // 1. Classify the operation
+        const actionContext = {
+            actionType: this.inferActionType(toolName),
+            domain: this.inferDomain(toolName),
+            operation: toolName,
+            target: typeof toolInput.file_path === "string" ? toolInput.file_path : undefined,
+            params: toolInput,
+            reasoning: `Tool: ${toolName}`,
+        };
+        try {
+            const classifiedAction = await classifyOperation(toolName, actionContext.domain, actionContext.target, actionContext.reasoning);
+            // 2. Check intent alignment
+            if (this.config.checkIntentAlignment && this.intent) {
+                const alignment = await scoreAlignment(actionContext, this.intent);
+                this.log("PreToolUse", toolName, "check", `Alignment: ${alignment.score.toFixed(2)}`, undefined, undefined, alignment.score);
+                if (alignment.shouldBlock || alignment.score < this.config.minAlignmentScore) {
+                    const reason = alignment.boundaryConcerns.length > 0
+                        ? `Boundary concerns: ${alignment.boundaryConcerns.join(", ")}`
+                        : `Low alignment score: ${alignment.score.toFixed(2)}`;
+                    this.log("PreToolUse", toolName, "deny", reason);
+                    if (this.config.blockOnViolation) {
+                        return {
+                            decision: "deny",
+                            reason: `[Security] ${reason}`,
+                        };
+                    }
+                }
+            }
+            // 3. Check flow policy
+            if (this.config.enforceFlowPolicies && this.policyEngine) {
+                // Extract content for classification
+                const content = this.extractContent(toolInput);
+                const classified = await classifyData(content, actionContext.domain, [toolName]);
+                this.log("PreToolUse", toolName, "check", `Classified: ${classified.sensitivity}/${classified.category}`, classified.sensitivity, classified.category);
+                // Determine target domain
+                const targetDomain = this.isExternalTool(toolName) ? "external" : "internal";
+                const flowResult = this.policyEngine.evaluate(classified, actionContext.domain, targetDomain);
+                if (!flowResult.allowed) {
+                    this.log("PreToolUse", toolName, "deny", flowResult.reason);
+                    if (this.config.blockOnViolation) {
+                        return {
+                            decision: "deny",
+                            reason: `[Security] Flow policy violation: ${flowResult.reason}`,
+                        };
+                    }
+                }
+                // Check if approval required
+                if (flowResult.requireApproval ||
+                    this.config.approvalRequiredSensitivities.includes(classified.sensitivity)) {
+                    // For now, just log - in full implementation would prompt user
+                    this.log("PreToolUse", toolName, "check", "Approval recommended");
+                }
+            }
+            this.log("PreToolUse", toolName, "allow", "Checks passed");
+            return { decision: "allow" };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.log("PreToolUse", toolName, "check", `Error: ${msg}`);
+            // On error, allow but log
+            return { decision: "allow" };
+        }
+    }
+    /**
+     * PostToolUse hook - Check output for leaks, track flows
+     */
+    async onPostToolUse(input) {
+        if (!this.config.enabled) {
+            return { decision: "allow" };
+        }
+        await this.initialize();
+        const toolName = input.tool_name || "unknown";
+        const toolResult = input.tool_result || "";
+        const toolIsError = input.tool_result_is_error || false;
+        // Skip error results
+        if (toolIsError) {
+            return { decision: "allow" };
+        }
+        try {
+            // 1. Classify output
+            const content = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult);
+            const classified = await classifyData(content, "agent", [toolName, "output"]);
+            this.log("PostToolUse", toolName, "check", `Output: ${classified.sensitivity}/${classified.category}`, classified.sensitivity, classified.category);
+            // 2. Check for leaks
+            if (this.config.preventLeaks && this.leakPrevention) {
+                const channel = this.isExternalTool(toolName) ? "external" : "internal";
+                const leakCheck = this.leakPrevention.check(content, channel);
+                if (leakCheck.action === "block") {
+                    const patterns = leakCheck.detections.map(d => d.pattern_name).join(", ");
+                    this.log("PostToolUse", toolName, "sanitize", `Leaks detected: ${patterns}`);
+                    if (this.config.blockOnViolation) {
+                        // Sanitize the output
+                        const sanitized = this.leakPrevention.sanitize(content);
+                        this.log("PostToolUse", toolName, "sanitize", "Output sanitized");
+                        return {
+                            decision: "allow",
+                            modified_input: {
+                                tool_result: sanitized,
+                            },
+                        };
+                    }
+                }
+            }
+            // 3. Track flow
+            if (this.config.trackTaints && this.flowTracker && this.policyEngine) {
+                const sourceDomain = "agent";
+                const targetDomain = this.isExternalTool(toolName) ? "external" : "internal";
+                const flowResult = this.policyEngine.evaluate(classified, sourceDomain, targetDomain);
+                this.flowTracker.record(classified, sourceDomain, targetDomain, this.isExternalTool(toolName) ? "outbound" : "internal", flowResult, this.sessionId, null);
+                this.log("PostToolUse", toolName, "check", "Flow tracked");
+            }
+            this.log("PostToolUse", toolName, "allow", "Output checks passed");
+            return { decision: "allow" };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.log("PostToolUse", toolName, "check", `Error: ${msg}`);
+            return { decision: "allow" };
+        }
+    }
+    /**
+     * UserPromptSubmit hook - Check user input for injection attempts
+     */
+    async onUserPromptSubmit(input) {
+        if (!this.config.enabled) {
+            return { decision: "allow" };
+        }
+        const prompt = input.prompt || "";
+        await this.initialize();
+        try {
+            // Check for potential injection patterns
+            const suspiciousPatterns = [
+                /ignore (all )?(previous|above) instructions/i,
+                /you are now/i,
+                /disregard (all )?(rules|policies)/i,
+                /system:? prompt/i,
+                /\[system\]/i,
+                /<\|.*?\|>/,
+            ];
+            for (const pattern of suspiciousPatterns) {
+                if (pattern.test(prompt)) {
+                    this.log("UserPromptSubmit", undefined, "check", "Suspicious pattern detected");
+                    if (this.config.blockOnViolation) {
+                        return {
+                            decision: "deny",
+                            reason: "[Security] Prompt contains potentially unsafe patterns",
+                        };
+                    }
+                }
+            }
+            // Classify user input
+            const classified = await classifyData(prompt, "user_input", []);
+            this.log("UserPromptSubmit", undefined, "check", `Input: ${classified.sensitivity}`, classified.sensitivity);
+            return { decision: "allow" };
+        }
+        catch (error) {
+            return { decision: "allow" };
+        }
+    }
+    /**
+     * SessionEnd hook - Generate security report
+     */
+    async onSessionEnd(_input) {
+        const stats = this.getStats();
+        this.log("SessionEnd", undefined, "check", `Session ended - ${stats.totalEvents} events, ${stats.deniedCount} denied`);
+        return { decision: "allow" };
+    }
+    // ============================================
+    // Utility Methods
+    // ============================================
+    inferActionType(toolName) {
+        const typeMap = {
+            Read: "observe",
+            Glob: "observe",
+            Grep: "observe",
+            Write: "modify",
+            Edit: "modify",
+            MultiEdit: "modify",
+            Bash: "execute",
+            NotebookEdit: "modify",
+        };
+        return typeMap[toolName] || "observe";
+    }
+    inferDomain(toolName) {
+        const domainMap = {
+            Read: "filesystem",
+            Write: "filesystem",
+            Edit: "filesystem",
+            Glob: "filesystem",
+            Grep: "filesystem",
+            Bash: "shell",
+            MultiEdit: "filesystem",
+        };
+        return domainMap[toolName] || "agent";
+    }
+    isExternalTool(toolName) {
+        const externalTools = ["Bash", "Write", "Edit", "MultiEdit", "NotebookEdit"];
+        return externalTools.includes(toolName);
+    }
+    extractContent(input) {
+        const parts = [];
+        for (const [key, value] of Object.entries(input)) {
+            if (typeof value === "string") {
+                parts.push(value);
+            }
+            else if (typeof value === "object" && value !== null) {
+                parts.push(JSON.stringify(value));
+            }
+        }
+        return parts.join(" ");
+    }
+    log(hook, tool, action, reason, sensitivity, category, alignmentScore) {
+        const event = {
+            timestamp: Date.now(),
+            hook,
+            tool,
+            action,
+            reason,
+            sensitivity,
+            category,
+            alignmentScore,
+        };
+        this.events.push(event);
+        if (this.config.logEvents) {
+            const prefix = action === "deny" ? "\x1b[31m[Security]\x1b[0m" : "\x1b[90m[Security]\x1b[0m";
+            const toolStr = tool ? ` ${tool}:` : "";
+            console.log(`${prefix}${toolStr} ${reason}`);
+        }
+    }
+    /**
+     * Get all security events
+     */
+    getEvents() {
+        return [...this.events];
+    }
+    /**
+     * Get security statistics
+     */
+    getStats() {
+        const allowedCount = this.events.filter(e => e.action === "allow").length;
+        const deniedCount = this.events.filter(e => e.action === "deny").length;
+        const sanitizedCount = this.events.filter(e => e.action === "sanitize").length;
+        const bySensitivity = {};
+        for (const event of this.events) {
+            if (event.sensitivity) {
+                bySensitivity[event.sensitivity] = (bySensitivity[event.sensitivity] || 0) + 1;
+            }
+        }
+        const alignmentScores = this.events
+            .filter(e => e.alignmentScore !== undefined)
+            .map(e => e.alignmentScore);
+        const avgAlignmentScore = alignmentScores.length > 0
+            ? alignmentScores.reduce((a, b) => a + b, 0) / alignmentScores.length
+            : 0;
+        return {
+            totalEvents: this.events.length,
+            allowedCount,
+            deniedCount,
+            sanitizedCount,
+            bySensitivity,
+            avgAlignmentScore,
+        };
+    }
+    /**
+     * Clear event history
+     */
+    clearEvents() {
+        this.events = [];
+    }
+}
+// Singleton instance
+let globalHooks = null;
+/**
+ * Get global security hooks instance
+ */
+export function getSecurityHooks(config) {
+    if (!globalHooks) {
+        globalHooks = new CognitiveSecurityHooks(config);
+    }
+    return globalHooks;
+}
+/**
+ * Create hook handlers for HookManager
+ */
+export function createSecurityHookHandlers(config) {
+    const hooks = new CognitiveSecurityHooks(config);
+    return {
+        SessionStart: (input) => hooks.onSessionStart(input),
+        PreToolUse: (input) => hooks.onPreToolUse(input),
+        PostToolUse: (input) => hooks.onPostToolUse(input),
+        UserPromptSubmit: (input) => hooks.onUserPromptSubmit(input),
+        SessionEnd: (input) => hooks.onSessionEnd(input),
+    };
+}