@ebowwa/coder 0.7.63 → 0.7.64

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

@@ -0,0 +1,136 @@
+/**
+ * Cognitive Security Middleware
+ *
+ * Automatically integrates flow control into the agent loop.
+ * All tool inputs/outputs are classified, tracked, and validated.
+ */
+import { type ClassifiedData, type FlowValidationResult, type LeakCheckResult } from "./index.js";
+export interface SecurityConfig {
+    /** Enable automatic data classification */
+    enabled: boolean;
+    /** Enable flow policy enforcement */
+    enforcePolicies: boolean;
+    /** Enable taint tracking */
+    trackTaints: boolean;
+    /** Enable leak prevention on outputs */
+    preventLeaks: boolean;
+    /** Log security events */
+    logEvents: boolean;
+    /** Block on policy violations */
+    blockOnViolation: boolean;
+    /** Domains considered external (require stricter checks) */
+    externalDomains: string[];
+    /** Tools that transmit data externally */
+    externalTools: string[];
+    /** Tools that read from sensitive sources */
+    sensitiveSourceTools: string[];
+}
+export declare const DEFAULT_SECURITY_CONFIG: SecurityConfig;
+export interface SecurityEvent {
+    type: "classify" | "flow_check" | "leak_check" | "taint" | "block" | "allow";
+    timestamp: number;
+    toolName: string;
+    dataId?: string;
+    sensitivity?: string;
+    category?: string;
+    sourceDomain?: string;
+    targetDomain?: string;
+    allowed?: boolean;
+    reason?: string;
+}
+export interface ToolSecurityContext {
+    toolName: string;
+    input: Record<string, unknown>;
+    output?: unknown;
+    sourceDomain: string;
+    targetDomain: string;
+}
+export interface SecurityMiddlewareResult {
+    allowed: boolean;
+    reason: string;
+    classifiedInput?: ClassifiedData;
+    classifiedOutput?: ClassifiedData;
+    flowResult?: FlowValidationResult;
+    leakResult?: LeakCheckResult;
+    sanitizedOutput?: string;
+    events: SecurityEvent[];
+}
+/**
+ * Cognitive Security Middleware
+ *
+ * Wraps tool execution with automatic security checks.
+ */
+export declare class CognitiveSecurityMiddleware {
+    private config;
+    private policyEngine;
+    private flowTracker;
+    private leakPrevention;
+    private taintTracker;
+    private events;
+    private initialized;
+    constructor(config?: Partial<SecurityConfig>);
+    /**
+     * Initialize security components (lazy loading)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check tool input before execution
+     */
+    checkInput(toolName: string, input: Record<string, unknown>): Promise<SecurityMiddlewareResult>;
+    /**
+     * Check tool output after execution
+     */
+    checkOutput(toolName: string, input: Record<string, unknown>, output: string): Promise<SecurityMiddlewareResult>;
+    /**
+     * Wrap tool handler with security checks
+     */
+    wrapToolHandler<TInput extends Record<string, unknown>, TResult>(toolName: string, handler: (input: TInput, context: unknown) => Promise<{
+        content: string;
+        is_error?: boolean;
+    }>): (input: TInput, context: unknown) => Promise<{
+        content: string;
+        is_error?: boolean;
+    }>;
+    /**
+     * Get domain for a tool
+     */
+    private getToolDomain;
+    /**
+     * Check if tool transmits externally
+     */
+    private isExternalTool;
+    /**
+     * Extract content from tool input for classification
+     */
+    private extractContent;
+    /**
+     * Log security events
+     */
+    private logEvent;
+    /**
+     * Get all security events
+     */
+    getEvents(): SecurityEvent[];
+    /**
+     * Clear event history
+     */
+    clearEvents(): void;
+    /**
+     * Get security statistics
+     */
+    getStats(): {
+        totalEvents: number;
+        blockedCount: number;
+        allowedCount: number;
+        bySensitivity: Record<string, number>;
+    };
+}
+/**
+ * Get or create global security middleware
+ */
+export declare function getSecurityMiddleware(config?: Partial<SecurityConfig>): CognitiveSecurityMiddleware;
+/**
+ * Reset global middleware (for testing)
+ */
+export declare function resetSecurityMiddleware(): void;
+//# sourceMappingURL=middleware.d.ts.map

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

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

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

@@ -0,0 +1,376 @@
+/**
+ * Cognitive Security Middleware
+ *
+ * Automatically integrates flow control into the agent loop.
+ * All tool inputs/outputs are classified, tracked, and validated.
+ */
+import { classifyData, createFlowPolicyEngine, createFlowTracker, createLeakPrevention, createTaintTracker, } from "./index.js";
+export const DEFAULT_SECURITY_CONFIG = {
+    enabled: true,
+    enforcePolicies: true,
+    trackTaints: true,
+    preventLeaks: true,
+    logEvents: true,
+    blockOnViolation: true,
+    externalDomains: ["external", "network", "api", "web"],
+    externalTools: ["Bash", "Write", "Edit", "MultiEdit", "NotebookEdit"],
+    sensitiveSourceTools: ["Read", "Bash"],
+};
+/**
+ * Cognitive Security Middleware
+ *
+ * Wraps tool execution with automatic security checks.
+ */
+export class CognitiveSecurityMiddleware {
+    config;
+    policyEngine = null;
+    flowTracker = null;
+    leakPrevention = null;
+    taintTracker = null;
+    events = [];
+    initialized = false;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_SECURITY_CONFIG, ...config };
+    }
+    /**
+     * Initialize security components (lazy loading)
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            if (this.config.enforcePolicies) {
+                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;
+        }
+        catch (error) {
+            console.warn("[Security] Failed to initialize:", error);
+            // Continue without security if init fails
+        }
+    }
+    /**
+     * Check tool input before execution
+     */
+    async checkInput(toolName, input) {
+        await this.initialize();
+        const events = [];
+        const sourceDomain = this.getToolDomain(toolName);
+        const targetDomain = "agent";
+        // Extract input content for classification
+        const inputContent = this.extractContent(input);
+        // Classify input data
+        const classifiedInput = await classifyData(inputContent, sourceDomain, [toolName]);
+        events.push({
+            type: "classify",
+            timestamp: Date.now(),
+            toolName,
+            dataId: classifiedInput.id,
+            sensitivity: classifiedInput.sensitivity,
+            category: classifiedInput.category,
+            sourceDomain,
+            targetDomain,
+        });
+        // Check flow policy
+        let flowResult;
+        if (this.policyEngine && this.config.enforcePolicies) {
+            flowResult = this.policyEngine.evaluate(classifiedInput, sourceDomain, targetDomain);
+            events.push({
+                type: "flow_check",
+                timestamp: Date.now(),
+                toolName,
+                dataId: classifiedInput.id,
+                sourceDomain,
+                targetDomain,
+                allowed: flowResult.allowed,
+                reason: flowResult.reason,
+            });
+            if (!flowResult.allowed && this.config.blockOnViolation) {
+                events.push({
+                    type: "block",
+                    timestamp: Date.now(),
+                    toolName,
+                    reason: flowResult.reason,
+                });
+                this.logEvent(events);
+                return {
+                    allowed: false,
+                    reason: `Security policy blocked: ${flowResult.reason}`,
+                    classifiedInput,
+                    flowResult,
+                    events,
+                };
+            }
+        }
+        // Register taint for sensitive data
+        if (this.taintTracker && this.config.trackTaints) {
+            if (classifiedInput.sensitivity !== "public") {
+                const sourceId = this.taintTracker.registerSource(sourceDomain, classifiedInput.sensitivity, [classifiedInput.category]);
+                this.taintTracker.taint(sourceId, inputContent, "tool_input", toolName);
+                events.push({
+                    type: "taint",
+                    timestamp: Date.now(),
+                    toolName,
+                    sensitivity: classifiedInput.sensitivity,
+                });
+            }
+        }
+        events.push({
+            type: "allow",
+            timestamp: Date.now(),
+            toolName,
+            reason: "Input check passed",
+        });
+        this.logEvent(events);
+        return {
+            allowed: true,
+            reason: "Input check passed",
+            classifiedInput,
+            flowResult,
+            events,
+        };
+    }
+    /**
+     * Check tool output after execution
+     */
+    async checkOutput(toolName, input, output) {
+        await this.initialize();
+        const events = [];
+        const sourceDomain = "agent";
+        const targetDomain = this.isExternalTool(toolName)
+            ? "external"
+            : "internal";
+        // Classify output data
+        const classifiedOutput = await classifyData(output, sourceDomain, [toolName, "output"]);
+        events.push({
+            type: "classify",
+            timestamp: Date.now(),
+            toolName,
+            dataId: classifiedOutput.id,
+            sensitivity: classifiedOutput.sensitivity,
+            category: classifiedOutput.category,
+            sourceDomain,
+            targetDomain,
+        });
+        // Check flow policy for output
+        let flowResult;
+        if (this.policyEngine && this.config.enforcePolicies && this.isExternalTool(toolName)) {
+            flowResult = this.policyEngine.evaluate(classifiedOutput, sourceDomain, targetDomain);
+            events.push({
+                type: "flow_check",
+                timestamp: Date.now(),
+                toolName,
+                dataId: classifiedOutput.id,
+                sourceDomain,
+                targetDomain,
+                allowed: flowResult.allowed,
+                reason: flowResult.reason,
+            });
+            if (!flowResult.allowed && this.config.blockOnViolation) {
+                events.push({
+                    type: "block",
+                    timestamp: Date.now(),
+                    toolName,
+                    reason: flowResult.reason,
+                });
+                this.logEvent(events);
+                return {
+                    allowed: false,
+                    reason: `Security policy blocked output: ${flowResult.reason}`,
+                    classifiedOutput,
+                    flowResult,
+                    events,
+                };
+            }
+        }
+        // Check for leaks
+        let leakResult;
+        let sanitizedOutput = output;
+        if (this.leakPrevention && this.config.preventLeaks) {
+            leakResult = this.leakPrevention.check(output, targetDomain);
+            events.push({
+                type: "leak_check",
+                timestamp: Date.now(),
+                toolName,
+                allowed: leakResult.action !== "block",
+                reason: leakResult.action,
+            });
+            if (leakResult.action === "block") {
+                // Sanitize instead of blocking
+                sanitizedOutput = this.leakPrevention.sanitize(output);
+                if (this.config.blockOnViolation) {
+                    events.push({
+                        type: "block",
+                        timestamp: Date.now(),
+                        toolName,
+                        reason: `Leak detected: ${leakResult.detections.map(d => d.pattern_name).join(", ")}`,
+                    });
+                    this.logEvent(events);
+                    return {
+                        allowed: false,
+                        reason: `Potential data leak detected and blocked`,
+                        classifiedOutput,
+                        leakResult,
+                        sanitizedOutput,
+                        events,
+                    };
+                }
+            }
+        }
+        // Track flow
+        if (this.flowTracker && this.config.trackTaints && flowResult) {
+            this.flowTracker.record(classifiedOutput, sourceDomain, targetDomain, this.isExternalTool(toolName) ? "outbound" : "internal", flowResult, null, null);
+        }
+        events.push({
+            type: "allow",
+            timestamp: Date.now(),
+            toolName,
+            reason: "Output check passed",
+        });
+        this.logEvent(events);
+        return {
+            allowed: true,
+            reason: "Output check passed",
+            classifiedOutput,
+            flowResult,
+            leakResult,
+            sanitizedOutput,
+            events,
+        };
+    }
+    /**
+     * Wrap tool handler with security checks
+     */
+    wrapToolHandler(toolName, handler) {
+        return async (input, context) => {
+            if (!this.config.enabled) {
+                return handler(input, context);
+            }
+            // Check input
+            const inputCheck = await this.checkInput(toolName, input);
+            if (!inputCheck.allowed) {
+                return {
+                    content: `[Security] ${inputCheck.reason}`,
+                    is_error: true,
+                };
+            }
+            // Execute tool
+            const result = await handler(input, context);
+            // Check output
+            const outputCheck = await this.checkOutput(toolName, input, result.content);
+            if (!outputCheck.allowed) {
+                return {
+                    content: outputCheck.sanitizedOutput || `[Security] ${outputCheck.reason}`,
+                    is_error: true,
+                };
+            }
+            // Return sanitized output if needed
+            return {
+                content: outputCheck.sanitizedOutput || result.content,
+                is_error: result.is_error,
+            };
+        };
+    }
+    /**
+     * Get domain for a tool
+     */
+    getToolDomain(toolName) {
+        if (this.isExternalTool(toolName))
+            return "external";
+        if (this.config.sensitiveSourceTools.includes(toolName))
+            return "filesystem";
+        return "internal";
+    }
+    /**
+     * Check if tool transmits externally
+     */
+    isExternalTool(toolName) {
+        return this.config.externalTools.includes(toolName);
+    }
+    /**
+     * Extract content from tool input for classification
+     */
+    extractContent(input) {
+        const parts = [];
+        for (const [key, value] of Object.entries(input)) {
+            if (typeof value === "string") {
+                parts.push(`${key}=${value}`);
+            }
+            else if (typeof value === "object" && value !== null) {
+                parts.push(`${key}=${JSON.stringify(value)}`);
+            }
+        }
+        return parts.join(" ");
+    }
+    /**
+     * Log security events
+     */
+    logEvent(events) {
+        this.events.push(...events);
+        if (this.config.logEvents) {
+            for (const event of events) {
+                if (event.type === "block") {
+                    console.warn(`[Security] BLOCK: ${event.toolName} - ${event.reason}`);
+                }
+                else if (event.type === "allow" && event.sensitivity && event.sensitivity !== "public") {
+                    console.log(`[Security] ALLOW: ${event.toolName} (${event.sensitivity})`);
+                }
+            }
+        }
+    }
+    /**
+     * Get all security events
+     */
+    getEvents() {
+        return [...this.events];
+    }
+    /**
+     * Clear event history
+     */
+    clearEvents() {
+        this.events = [];
+    }
+    /**
+     * Get security statistics
+     */
+    getStats() {
+        const blockedCount = this.events.filter(e => e.type === "block").length;
+        const allowedCount = this.events.filter(e => e.type === "allow").length;
+        const bySensitivity = {};
+        for (const event of this.events) {
+            if (event.sensitivity) {
+                bySensitivity[event.sensitivity] = (bySensitivity[event.sensitivity] || 0) + 1;
+            }
+        }
+        return {
+            totalEvents: this.events.length,
+            blockedCount,
+            allowedCount,
+            bySensitivity,
+        };
+    }
+}
+// Singleton instance for global use
+let globalMiddleware = null;
+/**
+ * Get or create global security middleware
+ */
+export function getSecurityMiddleware(config) {
+    if (!globalMiddleware) {
+        globalMiddleware = new CognitiveSecurityMiddleware(config);
+    }
+    return globalMiddleware;
+}
+/**
+ * Reset global middleware (for testing)
+ */
+export function resetSecurityMiddleware() {
+    globalMiddleware = null;
+}

package/dist/core/config-loader.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Config Loader - Load Coder configuration files
+ *
+ * Loads from:
+ * 1. ~/.claude.json (MCP servers, project settings)
+ * 2. ~/.claude/settings.json (hooks, permissions)
+ * 3. ~/.claude/keybindings.json (keybindings)
+ * 4. .claude/settings.json (project-level overrides)
+ */
+import type { MCPServerConfig, PermissionMode, HookDefinition, HookEvent } from "../types/index.js";
+export interface ClaudeMainConfig {
+    numStartups?: number;
+    verbose?: boolean;
+    preferredNotifChannel?: "terminal_bell" | "notification";
+    projects?: Record<string, ProjectConfig>;
+    mcpServers?: Record<string, MCPServerConfig>;
+}
+export interface ProjectConfig {
+    allowedTools?: string[];
+    mcpServers?: Record<string, MCPServerConfig>;
+    enabledMcpjsonServers?: string[];
+    disabledMcpjsonServers?: string[];
+    hasTrustDialogAccepted?: boolean;
+    lastSessionId?: string;
+}
+export interface SettingsConfig {
+    hooks?: Partial<Record<HookEvent, HookMatcherConfig[]>>;
+    permissions?: {
+        defaultMode?: PermissionMode;
+        allowedTools?: string[];
+        disallowedTools?: string[];
+    };
+}
+export interface HookMatcherConfig {
+    matcher?: string;
+    hooks: Array<{
+        type: "command" | "prompt";
+        command?: string;
+        prompt?: string;
+        timeout?: number;
+    }>;
+}
+export interface KeybindingConfig {
+    bindings: Array<{
+        key: string;
+        command: string;
+        when?: string;
+    }>;
+}
+export interface LoadedConfig {
+    main: ClaudeMainConfig;
+    settings: SettingsConfig;
+    keybindings: KeybindingConfig;
+    projectSettings: SettingsConfig;
+    sources: string[];
+}
+export declare const CONFIG_PATHS: {
+    main: string;
+    settings: string;
+    keybindings: string;
+    projectSettings: (projectDir: string) => string;
+};
+/**
+ * Load main ~/.claude.json config
+ */
+export declare function loadMainConfig(): Promise<{
+    config: ClaudeMainConfig;
+    loaded: boolean;
+}>;
+/**
+ * Load settings from ~/.claude/settings.json
+ */
+export declare function loadSettings(): Promise<{
+    config: SettingsConfig;
+    loaded: boolean;
+}>;
+/**
+ * Load keybindings from ~/.claude/keybindings.json
+ */
+export declare function loadKeybindings(): Promise<{
+    config: KeybindingConfig;
+    loaded: boolean;
+}>;
+/**
+ * Load project-level settings
+ */
+export declare function loadProjectSettings(projectDir: string): Promise<{
+    config: SettingsConfig;
+    loaded: boolean;
+}>;
+/**
+ * Get project-specific config from main config
+ */
+export declare function getProjectConfig(mainConfig: ClaudeMainConfig, projectDir: string): ProjectConfig | undefined;
+/**
+ * Load all configs at once
+ */
+export declare function loadAllConfigs(projectDir?: string): Promise<LoadedConfig>;
+/**
+ * Get merged settings (global + project overrides)
+ */
+export declare function getMergedSettings(global: SettingsConfig, project: SettingsConfig): SettingsConfig;
+/**
+ * Get all MCP servers (global + project-specific)
+ */
+export declare function getAllMCPServers(mainConfig: ClaudeMainConfig, projectDir: string): Record<string, MCPServerConfig>;
+/**
+ * Get hooks for a specific event and tool
+ */
+export declare function getHooksForEvent(settings: SettingsConfig, event: HookEvent, toolName?: string): HookMatcherConfig["hooks"];
+/**
+ * Convert settings hooks to HookDefinitions for HookManager
+ */
+export declare function settingsToHookDefinitions(settings: SettingsConfig): Partial<Record<HookEvent, HookDefinition[]>>;
+/**
+ * Get permission mode from settings
+ */
+export declare function getPermissionMode(settings: SettingsConfig): PermissionMode;
+/**
+ * Get allowed tools from settings
+ */
+export declare function getAllowedTools(settings: SettingsConfig): Set<string>;
+/**
+ * Get disallowed tools from settings
+ */
+export declare function getDisallowedTools(settings: SettingsConfig): Set<string>;
+//# sourceMappingURL=config-loader.d.ts.map

package/dist/core/config-loader.d.ts.map

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