profclaw 0.0.1-beta.1

package/dist/chat/execution/secrets.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Secrets Detection & Redaction
+ *
+ * Scans output for potential secrets and redacts them.
+ * Detects: API keys, tokens, passwords, private keys, credentials.
+ */
+export interface SecretMatch {
+    type: string;
+    pattern: string;
+    start: number;
+    end: number;
+    preview: string;
+}
+export interface ScanResult {
+    hasSecrets: boolean;
+    matches: SecretMatch[];
+    redactedText: string;
+}
+/**
+ * Scan text for potential secrets
+ */
+export declare function scanForSecrets(text: string): ScanResult;
+/**
+ * Redact secrets from text (returns only the redacted text)
+ */
+export declare function redactSecrets(text: string): string;
+/**
+ * Check if text contains secrets (quick check without full scan)
+ */
+export declare function hasSecrets(text: string): boolean;
+/**
+ * Get statistics about secret types
+ */
+export declare function getSecretStats(matches: SecretMatch[]): Record<string, number>;
+export declare function isSecretsDetectionEnabled(): boolean;
+export declare function setSecretsDetectionEnabled(enabled: boolean): void;
+export declare const _internals: {
+    SECRET_PATTERNS: {
+        name: string;
+        pattern: RegExp;
+        preview: number;
+    }[];
+    REDACTION_PLACEHOLDER: string;
+};
+//# sourceMappingURL=secrets.d.ts.map

package/dist/chat/execution/secrets.js

@@ -0,0 +1,338 @@
+/**
+ * Secrets Detection & Redaction
+ *
+ * Scans output for potential secrets and redacts them.
+ * Detects: API keys, tokens, passwords, private keys, credentials.
+ */
+import { logger } from '../../utils/logger.js';
+// Secret Patterns
+// Pattern definitions with descriptions
+const SECRET_PATTERNS = [
+    // API Keys & Tokens
+    {
+        name: 'AWS Access Key',
+        pattern: /\b(AKIA[0-9A-Z]{16})\b/g,
+        preview: 8,
+    },
+    {
+        name: 'AWS Secret Key',
+        pattern: /\b([A-Za-z0-9/+=]{40})(?=\s|$|")/g,
+        preview: 8,
+    },
+    {
+        name: 'GitHub Token',
+        pattern: /\b(gh[pousr]_[A-Za-z0-9_]{36,255})\b/g,
+        preview: 8,
+    },
+    {
+        name: 'GitHub OAuth',
+        pattern: /\b(gho_[A-Za-z0-9]{36,255})\b/g,
+        preview: 8,
+    },
+    {
+        name: 'GitHub Personal Access Token (Classic)',
+        pattern: /\b(ghp_[A-Za-z0-9]{36,255})\b/g,
+        preview: 8,
+    },
+    {
+        name: 'GitLab Token',
+        pattern: /\b(glpat-[A-Za-z0-9\-_]{20,})\b/g,
+        preview: 10,
+    },
+    {
+        name: 'Slack Token',
+        pattern: /\b(xox[baprs]-[0-9]{10,13}-[0-9]{10,13}[a-zA-Z0-9-]*)\b/g,
+        preview: 10,
+    },
+    {
+        name: 'Slack Webhook',
+        pattern: /\b(https:\/\/hooks\.slack\.com\/services\/T[A-Z0-9]+\/B[A-Z0-9]+\/[a-zA-Z0-9]+)\b/g,
+        preview: 30,
+    },
+    {
+        name: 'Discord Token',
+        pattern: /\b([MN][A-Za-z\d]{23,}\.[\w-]{6}\.[\w-]{27})\b/g,
+        preview: 10,
+    },
+    {
+        name: 'Discord Webhook',
+        pattern: /\b(https:\/\/discord(?:app)?\.com\/api\/webhooks\/\d+\/[\w-]+)\b/g,
+        preview: 30,
+    },
+    {
+        name: 'Anthropic API Key',
+        pattern: /\b(sk-ant-[A-Za-z0-9\-_]{95,})\b/g,
+        preview: 12,
+    },
+    {
+        name: 'OpenAI API Key',
+        pattern: /\b(sk-[A-Za-z0-9]{20,}T3BlbkFJ[A-Za-z0-9]{20,})\b/g,
+        preview: 10,
+    },
+    {
+        name: 'OpenAI Project Key',
+        pattern: /\b(sk-proj-[A-Za-z0-9\-_]{40,})\b/g,
+        preview: 12,
+    },
+    {
+        name: 'Google API Key',
+        pattern: /\b(AIza[0-9A-Za-z\-_]{35})\b/g,
+        preview: 10,
+    },
+    {
+        name: 'Firebase Token',
+        pattern: /\b([0-9]+:[A-Za-z0-9_-]{140,})\b/g,
+        preview: 10,
+    },
+    {
+        name: 'Stripe API Key',
+        pattern: /\b(sk_live_[A-Za-z0-9]{24,})\b/g,
+        preview: 12,
+    },
+    {
+        name: 'Stripe Test Key',
+        pattern: /\b(sk_test_[A-Za-z0-9]{24,})\b/g,
+        preview: 12,
+    },
+    {
+        name: 'Stripe Publishable Key',
+        pattern: /\b(pk_(live|test)_[A-Za-z0-9]{24,})\b/g,
+        preview: 12,
+    },
+    {
+        name: 'Twilio API Key',
+        pattern: /\b(SK[a-f0-9]{32})\b/g,
+        preview: 10,
+    },
+    {
+        name: 'Sendgrid API Key',
+        pattern: /\b(SG\.[A-Za-z0-9\-_]{22}\.[A-Za-z0-9\-_]{43})\b/g,
+        preview: 10,
+    },
+    {
+        name: 'Mailchimp API Key',
+        pattern: /\b([a-f0-9]{32}-us\d{1,2})\b/g,
+        preview: 10,
+    },
+    {
+        name: 'NPM Token',
+        pattern: /\b(npm_[A-Za-z0-9]{36})\b/g,
+        preview: 8,
+    },
+    {
+        name: 'PyPI Token',
+        pattern: /\b(pypi-[A-Za-z0-9\-_]{50,})\b/g,
+        preview: 10,
+    },
+    {
+        name: 'Heroku API Key',
+        pattern: /\b([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\b/g,
+        preview: 12,
+    },
+    {
+        name: 'DigitalOcean Token',
+        pattern: /\b(dop_v1_[a-f0-9]{64})\b/g,
+        preview: 12,
+    },
+    {
+        name: 'Vercel Token',
+        pattern: /\b([A-Za-z0-9]{24})\b/g, // Too generic, check context
+        preview: 8,
+    },
+    {
+        name: 'Linear API Key',
+        pattern: /\b(lin_api_[A-Za-z0-9]{40,})\b/g,
+        preview: 12,
+    },
+    // Private Keys & Certificates
+    {
+        name: 'RSA Private Key',
+        pattern: /-----BEGIN RSA PRIVATE KEY-----[\s\S]*?-----END RSA PRIVATE KEY-----/g,
+        preview: 30,
+    },
+    {
+        name: 'OpenSSH Private Key',
+        pattern: /-----BEGIN OPENSSH PRIVATE KEY-----[\s\S]*?-----END OPENSSH PRIVATE KEY-----/g,
+        preview: 30,
+    },
+    {
+        name: 'EC Private Key',
+        pattern: /-----BEGIN EC PRIVATE KEY-----[\s\S]*?-----END EC PRIVATE KEY-----/g,
+        preview: 30,
+    },
+    {
+        name: 'Private Key (Generic)',
+        pattern: /-----BEGIN PRIVATE KEY-----[\s\S]*?-----END PRIVATE KEY-----/g,
+        preview: 30,
+    },
+    {
+        name: 'PGP Private Key',
+        pattern: /-----BEGIN PGP PRIVATE KEY BLOCK-----[\s\S]*?-----END PGP PRIVATE KEY BLOCK-----/g,
+        preview: 30,
+    },
+    // Database & Connection Strings
+    {
+        name: 'MongoDB Connection String',
+        pattern: /mongodb(?:\+srv)?:\/\/[^\s"']+/g,
+        preview: 20,
+    },
+    {
+        name: 'PostgreSQL Connection String',
+        pattern: /postgres(?:ql)?:\/\/[^\s"']+/g,
+        preview: 20,
+    },
+    {
+        name: 'MySQL Connection String',
+        pattern: /mysql:\/\/[^\s"']+/g,
+        preview: 20,
+    },
+    {
+        name: 'Redis Connection String',
+        pattern: /redis(?:s)?:\/\/[^\s"']+/g,
+        preview: 20,
+    },
+    {
+        name: 'JDBC Connection String',
+        pattern: /jdbc:[a-z]+:\/\/[^\s"']+/g,
+        preview: 20,
+    },
+    // Generic Patterns (more specific context needed)
+    {
+        name: 'Bearer Token',
+        pattern: /\b(Bearer\s+[A-Za-z0-9\-_.~+\/]+=*)\b/gi,
+        preview: 15,
+    },
+    {
+        name: 'Basic Auth Header',
+        pattern: /\b(Basic\s+[A-Za-z0-9+\/]+=*)\b/gi,
+        preview: 15,
+    },
+    {
+        name: 'JWT Token',
+        pattern: /\b(eyJ[A-Za-z0-9_-]*\.eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*)\b/g,
+        preview: 20,
+    },
+    // Password patterns in common formats
+    {
+        name: 'Password in URL',
+        pattern: /:\/\/[^:]+:([^@\s]{8,})@/g,
+        preview: 0, // Don't show password preview
+    },
+    {
+        name: 'Password Assignment',
+        pattern: /(?:password|passwd|pwd|secret|token|api[_-]?key)\s*[=:]\s*["']?([^"'\s]{8,})["']?/gi,
+        preview: 0,
+    },
+    {
+        name: 'Secret in Env',
+        pattern: /(?:SECRET|TOKEN|API_KEY|APIKEY|PASSWORD|PASSWD|CREDENTIALS?)\s*=\s*["']?([^"'\s\n]{8,})["']?/gi,
+        preview: 0,
+    },
+];
+// Redaction placeholder
+const REDACTION_PLACEHOLDER = '[REDACTED]';
+// Core Functions
+/**
+ * Scan text for potential secrets
+ */
+export function scanForSecrets(text) {
+    if (!text || typeof text !== 'string') {
+        return { hasSecrets: false, matches: [], redactedText: text };
+    }
+    const matches = [];
+    let redactedText = text;
+    // Track already-replaced positions to avoid double-replacement
+    const replacedRanges = [];
+    for (const { name, pattern, preview } of SECRET_PATTERNS) {
+        // Reset regex state for global patterns
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            const fullMatch = match[0];
+            const captured = match[1] || fullMatch;
+            const start = match.index;
+            const end = start + fullMatch.length;
+            // Skip if already replaced
+            const alreadyReplaced = replacedRanges.some((r) => (start >= r.start && start < r.end) || (end > r.start && end <= r.end));
+            if (alreadyReplaced)
+                continue;
+            // Generate preview (first N chars)
+            const previewText = preview > 0 ? captured.slice(0, preview) + '...' : '***';
+            matches.push({
+                type: name,
+                pattern: pattern.source.slice(0, 30) + '...',
+                start,
+                end,
+                preview: previewText,
+            });
+            replacedRanges.push({ start, end });
+        }
+    }
+    // Sort matches by position (descending) for safe replacement
+    matches.sort((a, b) => b.start - a.start);
+    // Apply redactions
+    for (const m of matches) {
+        redactedText =
+            redactedText.slice(0, m.start) + REDACTION_PLACEHOLDER + redactedText.slice(m.end);
+    }
+    // Re-sort by position (ascending) for reporting
+    matches.sort((a, b) => a.start - b.start);
+    const hasSecrets = matches.length > 0;
+    if (hasSecrets) {
+        logger.warn(`[Secrets] Detected ${matches.length} potential secrets in output`, {
+            types: [...new Set(matches.map((m) => m.type))],
+        });
+    }
+    return { hasSecrets, matches, redactedText };
+}
+/**
+ * Redact secrets from text (returns only the redacted text)
+ */
+export function redactSecrets(text) {
+    return scanForSecrets(text).redactedText;
+}
+/**
+ * Check if text contains secrets (quick check without full scan)
+ */
+export function hasSecrets(text) {
+    if (!text)
+        return false;
+    // Quick check with a subset of high-confidence patterns
+    const quickPatterns = [
+        /-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----/,
+        /\b(gh[pousr]_[A-Za-z0-9_]{36,})\b/,
+        /\b(sk-ant-[A-Za-z0-9\-_]{95,})\b/,
+        /\b(sk-[A-Za-z0-9]{20,}T3BlbkFJ)/,
+        /\b(AKIA[0-9A-Z]{16})\b/,
+        /\b(sk_(live|test)_[A-Za-z0-9]{24,})\b/,
+        /\beyJ[A-Za-z0-9_-]*\.eyJ[A-Za-z0-9_-]*\./,
+        /mongodb(?:\+srv)?:\/\/[^:]+:[^@]+@/,
+        /postgres(?:ql)?:\/\/[^:]+:[^@]+@/,
+    ];
+    return quickPatterns.some((p) => p.test(text));
+}
+/**
+ * Get statistics about secret types
+ */
+export function getSecretStats(matches) {
+    const stats = {};
+    for (const m of matches) {
+        stats[m.type] = (stats[m.type] || 0) + 1;
+    }
+    return stats;
+}
+// Configuration
+let secretsDetectionEnabled = process.env.SECRETS_DETECTION !== 'false';
+export function isSecretsDetectionEnabled() {
+    return secretsDetectionEnabled;
+}
+export function setSecretsDetectionEnabled(enabled) {
+    secretsDetectionEnabled = enabled;
+    logger.info(`[Secrets] Detection ${enabled ? 'enabled' : 'disabled'}`);
+}
+// Export for testing
+export const _internals = {
+    SECRET_PATTERNS,
+    REDACTION_PLACEHOLDER,
+};
+//# sourceMappingURL=secrets.js.map

package/dist/chat/execution/security.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Security Policy System
+ *
+ * Enforces security policies for tool execution.
+ * Handles allowlist matching, approval workflows, and sandboxing.
+ */
+import type { SecurityPolicy, AllowlistEntry, ToolDefinition, ApprovalRequest, ApprovalDecision, ApprovalResponse, DMPairingSession, ChannelAllowlistEntry, ExecApprovalPolicy, PluginAllowlistEntry, PluginPermission, ChannelPolicy, SecurityRiskAnalysis } from './types.js';
+interface SecurityCheckContext {
+    conversationId: string;
+    toolCallId: string;
+    userId?: string;
+    channelId?: string;
+}
+export declare class SecurityPolicyManager {
+    private policy;
+    private pendingApprovals;
+    private approvalResolvers;
+    private cleanupTimer;
+    constructor(policy?: Partial<SecurityPolicy>);
+    /**
+     * Check if a tool call is allowed based on security policy
+     */
+    checkPermission(tool: ToolDefinition, params: Record<string, unknown>, context: SecurityCheckContext): Promise<SecurityCheckResult>;
+    /**
+     * Create an approval request
+     */
+    createApprovalRequest(tool: ToolDefinition, params: Record<string, unknown>, context: {
+        conversationId: string;
+        toolCallId: string;
+    }, securityLevel: 'moderate' | 'dangerous'): ApprovalRequest;
+    /**
+     * Wait for user approval
+     */
+    waitForApproval(requestId: string): Promise<ApprovalDecision | null>;
+    /**
+     * Handle user's approval response
+     */
+    handleApprovalResponse(response: ApprovalResponse): boolean;
+    /**
+     * Get pending approval requests for a conversation
+     */
+    getPendingApprovals(conversationId?: string): ApprovalRequest[];
+    /**
+     * Get current security policy
+     */
+    getPolicy(): SecurityPolicy;
+    /**
+     * Update security policy
+     */
+    updatePolicy(updates: Partial<SecurityPolicy>): void;
+    /**
+     * Add entry to allowlist
+     */
+    addToAllowlist(entry: AllowlistEntry): void;
+    /**
+     * Remove entry from allowlist
+     */
+    removeFromAllowlist(pattern: string): boolean;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+    private pairingSessions;
+    /**
+     * Generate a pairing code for an unknown DM sender
+     */
+    generatePairingCode(senderId: string, channelProvider: string): DMPairingSession;
+    /**
+     * Verify a pairing code from a DM sender
+     */
+    verifyPairingCode(senderId: string, channelProvider: string, code: string): boolean;
+    /**
+     * Check if a DM sender is trusted
+     */
+    isDMSenderTrusted(senderId: string): boolean;
+    /**
+     * Add a channel to the allowlist
+     */
+    addChannelToAllowlist(entry: ChannelAllowlistEntry): void;
+    /**
+     * Remove a channel from the allowlist
+     */
+    removeChannelFromAllowlist(channelId: string, provider: string): boolean;
+    /**
+     * Check if a channel is allowed to send messages
+     */
+    isChannelAllowed(channelId: string, provider: string): boolean;
+    /**
+     * Get the channel allowlist
+     */
+    getChannelAllowlist(): ChannelAllowlistEntry[];
+    /**
+     * Add a granular exec approval policy
+     */
+    addExecPolicy(policy: ExecApprovalPolicy): void;
+    /**
+     * Remove an exec approval policy
+     */
+    removeExecPolicy(policyId: string): boolean;
+    /**
+     * Evaluate granular exec policies for a tool call
+     */
+    evaluateExecPolicies(toolName: string, command: string | null, context: {
+        userId?: string;
+        channelId?: string;
+    }): ExecApprovalPolicy | null;
+    /**
+     * Get all exec policies
+     */
+    getExecPolicies(): ExecApprovalPolicy[];
+    /**
+     * Add a plugin to the allowlist
+     */
+    addPluginToAllowlist(entry: PluginAllowlistEntry): void;
+    /**
+     * Remove a plugin from the allowlist
+     */
+    removePluginFromAllowlist(pluginId: string): boolean;
+    /**
+     * Check if a plugin is allowed and has a specific permission
+     */
+    isPluginAllowed(pluginId: string, permission?: PluginPermission): boolean;
+    /**
+     * Get the plugin allowlist
+     */
+    getPluginAllowlist(): PluginAllowlistEntry[];
+    /**
+     * Analyze the security risk of a tool call
+     * Rule-based (no LLM needed) with weighted scoring
+     */
+    analyzeRisk(tool: ToolDefinition, params: Record<string, unknown>): SecurityRiskAnalysis;
+    private buildRiskExplanation;
+    /**
+     * Set a per-channel policy
+     */
+    setChannelPolicy(policy: ChannelPolicy): void;
+    /**
+     * Get a per-channel policy
+     */
+    getChannelPolicy(channelId: string, provider: string): ChannelPolicy | null;
+    /**
+     * Remove a per-channel policy
+     */
+    removeChannelPolicy(channelId: string, provider: string): boolean;
+    /**
+     * Get all channel policies
+     */
+    getChannelPolicies(): ChannelPolicy[];
+    /**
+     * Get effective timeout for a channel (falls back to default)
+     */
+    getEffectiveTimeout(channelId: string, provider: string): number;
+    /**
+     * Get effective retry config for a channel
+     */
+    getEffectiveRetryConfig(channelId: string, provider: string): {
+        attempts: number;
+        delayMs: number;
+    };
+    private extractCommand;
+    private isDangerousCommand;
+    private isSafeCommand;
+    private isAllowlisted;
+    private normalizeCommandPattern;
+    private handleApprovalTimeout;
+    private cleanupExpiredApprovals;
+    private cleanupOldestApprovals;
+}
+export interface SecurityCheckResult {
+    allowed: boolean;
+    reason?: string;
+    requiresApproval: boolean;
+    securityLevel?: 'moderate' | 'dangerous';
+    sandboxRequired?: boolean;
+}
+export declare function getSecurityManager(): SecurityPolicyManager;
+export declare function initSecurityManager(policy?: Partial<SecurityPolicy>): SecurityPolicyManager;
+export {};
+//# sourceMappingURL=security.d.ts.map