profclaw 0.0.1-beta.1

package/dist/chat/api-key-detector.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Smart API Key Detection
+ *
+ * Detects API keys in chat messages and extracts provider information.
+ * Inspired by OpenClaw's configure wizard - users can naturally say
+ * "here's my OpenAI key: sk-..." and we auto-configure.
+ */
+export interface DetectedApiKey {
+    provider: 'openai' | 'anthropic' | 'azure' | 'google' | 'groq' | 'openrouter' | 'ollama';
+    apiKey: string;
+    confidence: 'high' | 'medium' | 'low';
+    matchedPattern: string;
+    baseUrl?: string;
+}
+export interface ApiKeyDetectionResult {
+    detected: boolean;
+    keys: DetectedApiKey[];
+    sanitizedMessage: string;
+}
+/**
+ * Detect API keys in a message
+ */
+export declare function detectApiKeys(message: string): ApiKeyDetectionResult;
+/**
+ * Check if a message likely contains an API key
+ * (quick check without full detection)
+ */
+export declare function mightContainApiKey(message: string): boolean;
+/**
+ * Generate a system prompt addition for API key handling
+ */
+export declare function getApiKeyHandlingPrompt(): string;
+/**
+ * Create tool invocation suggestion for detected keys
+ */
+export declare function createConfigureToolCall(key: DetectedApiKey): {
+    name: string;
+    arguments: Record<string, unknown>;
+};
+export declare function logDetection(result: ApiKeyDetectionResult): void;
+//# sourceMappingURL=api-key-detector.d.ts.map

package/dist/chat/api-key-detector.js

@@ -0,0 +1,290 @@
+/**
+ * Smart API Key Detection
+ *
+ * Detects API keys in chat messages and extracts provider information.
+ * Inspired by OpenClaw's configure wizard - users can naturally say
+ * "here's my OpenAI key: sk-..." and we auto-configure.
+ */
+import { logger } from '../utils/logger.js';
+const API_KEY_PATTERNS = [
+    {
+        provider: 'openai',
+        keyPattern: /sk-[a-zA-Z0-9_-]{20,}/g,
+        contextPatterns: [
+            /openai\s*(api)?\s*key/i,
+            /gpt\s*(api)?\s*key/i,
+            /chatgpt\s*key/i,
+            /OPENAI_API_KEY/i,
+        ],
+        keyPrefix: 'sk-',
+        minLength: 40,
+        maxLength: 200,
+    },
+    {
+        provider: 'anthropic',
+        keyPattern: /sk-ant-[a-zA-Z0-9_-]{20,}/g,
+        contextPatterns: [
+            /anthropic\s*(api)?\s*key/i,
+            /claude\s*(api)?\s*key/i,
+            /ANTHROPIC_API_KEY/i,
+        ],
+        keyPrefix: 'sk-ant-',
+        minLength: 50,
+        maxLength: 200,
+    },
+    {
+        provider: 'groq',
+        keyPattern: /gsk_[a-zA-Z0-9]{20,}/g,
+        contextPatterns: [
+            /groq\s*(api)?\s*key/i,
+            /GROQ_API_KEY/i,
+        ],
+        keyPrefix: 'gsk_',
+        minLength: 40,
+        maxLength: 100,
+    },
+    {
+        provider: 'openrouter',
+        keyPattern: /sk-or-[a-zA-Z0-9_-]{20,}/g,
+        contextPatterns: [
+            /openrouter\s*(api)?\s*key/i,
+            /OPENROUTER_API_KEY/i,
+        ],
+        keyPrefix: 'sk-or-',
+        minLength: 40,
+        maxLength: 100,
+    },
+    {
+        provider: 'google',
+        // Google API keys are typically 39 chars, alphanumeric with underscores
+        keyPattern: /AIza[a-zA-Z0-9_-]{35}/g,
+        contextPatterns: [
+            /google\s*(ai)?\s*(api)?\s*key/i,
+            /gemini\s*(api)?\s*key/i,
+            /GOOGLE_API_KEY/i,
+            /GOOGLE_GENERATIVE_AI_API_KEY/i,
+        ],
+        keyPrefix: 'AIza',
+        minLength: 39,
+        maxLength: 45,
+    },
+    {
+        provider: 'azure',
+        // Azure keys are typically 32 hex chars
+        keyPattern: /[a-fA-F0-9]{32}/g,
+        contextPatterns: [
+            /azure\s*(openai)?\s*(api)?\s*key/i,
+            /AZURE_OPENAI_API_KEY/i,
+            /AZURE_API_KEY/i,
+        ],
+        minLength: 32,
+        maxLength: 40,
+    },
+];
+// URL/Endpoint Patterns
+const ENDPOINT_PATTERNS = [
+    {
+        provider: 'ollama',
+        patterns: [
+            /(?:ollama\s*(?:url|endpoint|base\s*url|server)?:?\s*)(https?:\/\/[^\s]+)/i,
+            /(?:OLLAMA_BASE_URL|OLLAMA_HOST)\s*[=:]\s*['"]?(https?:\/\/[^\s'"]+)/i,
+            /(https?:\/\/localhost:\d+)(?:\/|$)/i,
+            /(https?:\/\/127\.0\.0\.1:\d+)(?:\/|$)/i,
+        ],
+        defaultPort: 11434,
+    },
+    {
+        provider: 'azure',
+        patterns: [
+            /(?:azure\s*(?:openai)?\s*(?:url|endpoint|base\s*url)?:?\s*)(https:\/\/[^\s]+\.openai\.azure\.com)/i,
+            /AZURE_OPENAI_ENDPOINT\s*[=:]\s*['"]?(https:\/\/[^\s'"]+)/i,
+        ],
+    },
+];
+// Detection Functions
+/**
+ * Detect API keys in a message
+ */
+export function detectApiKeys(message) {
+    const keys = [];
+    let sanitizedMessage = message;
+    // First, try to detect provider from context
+    const detectedProviders = detectProviderContext(message);
+    // Then, look for API key patterns
+    for (const pattern of API_KEY_PATTERNS) {
+        const matches = message.matchAll(pattern.keyPattern);
+        for (const match of matches) {
+            const apiKey = match[0];
+            // Validate key length
+            if (apiKey.length < pattern.minLength || apiKey.length > pattern.maxLength) {
+                continue;
+            }
+            // Determine confidence based on context
+            let confidence = 'low';
+            // High confidence if we have explicit context
+            if (detectedProviders.includes(pattern.provider)) {
+                confidence = 'high';
+            }
+            // Medium confidence if key has distinctive prefix
+            else if (pattern.keyPrefix && apiKey.startsWith(pattern.keyPrefix)) {
+                confidence = 'medium';
+            }
+            // Check for Azure endpoint in message
+            let baseUrl;
+            if (pattern.provider === 'azure') {
+                const endpoint = detectEndpoint(message, 'azure');
+                if (endpoint) {
+                    baseUrl = endpoint;
+                    confidence = 'high'; // Higher confidence with endpoint
+                }
+            }
+            keys.push({
+                provider: pattern.provider,
+                apiKey,
+                confidence,
+                matchedPattern: pattern.keyPattern.source,
+                baseUrl,
+            });
+            // Redact key in sanitized message
+            sanitizedMessage = sanitizedMessage.replace(apiKey, `[${pattern.provider.toUpperCase()}_KEY_REDACTED]`);
+        }
+    }
+    // Check for Ollama endpoint (doesn't need API key)
+    const ollamaEndpoint = detectEndpoint(message, 'ollama');
+    if (ollamaEndpoint) {
+        keys.push({
+            provider: 'ollama',
+            apiKey: '', // Ollama doesn't need an API key
+            confidence: 'high',
+            matchedPattern: 'ollama_endpoint',
+            baseUrl: ollamaEndpoint,
+        });
+        sanitizedMessage = sanitizedMessage.replace(ollamaEndpoint, '[OLLAMA_ENDPOINT_REDACTED]');
+    }
+    // De-duplicate by provider (keep highest confidence)
+    const uniqueKeys = deduplicateKeys(keys);
+    return {
+        detected: uniqueKeys.length > 0,
+        keys: uniqueKeys,
+        sanitizedMessage,
+    };
+}
+/**
+ * Detect provider context from message
+ */
+function detectProviderContext(message) {
+    const providers = [];
+    for (const pattern of API_KEY_PATTERNS) {
+        for (const contextPattern of pattern.contextPatterns) {
+            if (contextPattern.test(message)) {
+                providers.push(pattern.provider);
+                break;
+            }
+        }
+    }
+    return providers;
+}
+/**
+ * Detect endpoint URL for a provider
+ */
+function detectEndpoint(message, provider) {
+    const endpointPattern = ENDPOINT_PATTERNS.find(p => p.provider === provider);
+    if (!endpointPattern)
+        return undefined;
+    for (const pattern of endpointPattern.patterns) {
+        const match = message.match(pattern);
+        if (match && match[1]) {
+            return match[1];
+        }
+    }
+    // For Ollama, also check for localhost mentions without full URL
+    if (provider === 'ollama') {
+        const localhostMatch = message.match(/localhost:(\d+)/i);
+        if (localhostMatch) {
+            return `http://localhost:${localhostMatch[1]}`;
+        }
+        // Check for just "ollama" mentioned with no key - user might want local
+        if (/\bollama\b/i.test(message) && !/key|api/i.test(message)) {
+            return 'http://localhost:11434';
+        }
+    }
+    return undefined;
+}
+/**
+ * De-duplicate keys, keeping highest confidence per provider
+ */
+function deduplicateKeys(keys) {
+    const byProvider = new Map();
+    const confidenceRank = { high: 3, medium: 2, low: 1 };
+    for (const key of keys) {
+        const existing = byProvider.get(key.provider);
+        if (!existing || confidenceRank[key.confidence] > confidenceRank[existing.confidence]) {
+            byProvider.set(key.provider, key);
+        }
+    }
+    return Array.from(byProvider.values());
+}
+/**
+ * Check if a message likely contains an API key
+ * (quick check without full detection)
+ */
+export function mightContainApiKey(message) {
+    // Quick patterns to check
+    const quickPatterns = [
+        /sk-[a-zA-Z0-9]/, // OpenAI, OpenRouter, Anthropic prefixes
+        /gsk_[a-zA-Z0-9]/, // Groq prefix
+        /AIza[a-zA-Z0-9]/, // Google prefix
+        /api.?key/i, // "api key" mentions
+        /API_KEY/, // Environment variable style
+        /\b(openai|anthropic|claude|gemini|groq|azure)\b.*\b(key|token|secret)\b/i,
+    ];
+    return quickPatterns.some(p => p.test(message));
+}
+/**
+ * Generate a system prompt addition for API key handling
+ */
+export function getApiKeyHandlingPrompt() {
+    return `
+When users provide API keys in their messages, you should:
+1. Immediately use the configureProvider tool to save the key
+2. Confirm which provider was configured
+3. Never repeat the full API key back to the user
+4. Suggest they test the connection
+
+Supported providers:
+- OpenAI (keys start with sk-)
+- Anthropic/Claude (keys start with sk-ant-)
+- Google/Gemini (keys start with AIza)
+- Groq (keys start with gsk_)
+- OpenRouter (keys start with sk-or-)
+- Azure OpenAI (32 character hex keys, needs endpoint)
+- Ollama (local, no key needed, just endpoint URL)
+
+If the user mentions wanting to use a local model or Ollama, configure Ollama with the appropriate endpoint (default: http://localhost:11434).
+`.trim();
+}
+/**
+ * Create tool invocation suggestion for detected keys
+ */
+export function createConfigureToolCall(key) {
+    return {
+        name: 'configureProvider',
+        arguments: {
+            provider: key.provider,
+            apiKey: key.apiKey,
+            baseUrl: key.baseUrl,
+            setAsDefault: true, // Default to setting as default when user provides key
+        },
+    };
+}
+// Log detection for debugging (without exposing keys)
+export function logDetection(result) {
+    if (result.detected) {
+        logger.info(`[ApiKeyDetector] Detected ${result.keys.length} API key(s)`, {
+            component: 'ApiKeyDetector',
+            providers: result.keys.map(k => k.provider),
+            confidences: result.keys.map(k => k.confidence),
+        });
+    }
+}
+//# sourceMappingURL=api-key-detector.js.map

package/dist/chat/auto-reply.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Auto-Reply System
+ *
+ * Template-based automatic responses for chat messages.
+ * Supports:
+ * - Out-of-office / away mode
+ * - Busy/DND mode with queue position
+ * - Keyword-triggered quick replies
+ * - Rate-limited to prevent spam
+ * - Per-channel configuration
+ */
+export interface AutoReplyTemplate {
+    id: string;
+    name: string;
+    trigger: AutoReplyTrigger;
+    message: string;
+    enabled: boolean;
+    channels?: string[];
+    cooldownMs: number;
+    maxPerHour?: number;
+    priority: number;
+    variables?: Record<string, string>;
+}
+export type AutoReplyTrigger = {
+    type: 'always';
+} | {
+    type: 'keyword';
+    keywords: string[];
+} | {
+    type: 'regex';
+    pattern: string;
+} | {
+    type: 'no_agent';
+} | {
+    type: 'after_hours';
+    schedule: WeeklySchedule;
+};
+export interface WeeklySchedule {
+    timezone: string;
+    hours: {
+        start: number;
+        end: number;
+    };
+    days: number[];
+}
+export interface AutoReplyConfig {
+    enabled: boolean;
+    templates: AutoReplyTemplate[];
+    globalCooldownMs: number;
+    maxRepliesPerHour: number;
+}
+export interface AutoReplyResult {
+    shouldReply: boolean;
+    templateId?: string;
+    message?: string;
+    reason?: string;
+}
+/**
+ * Load auto-reply configuration
+ */
+export declare function configureAutoReply(newConfig: Partial<AutoReplyConfig>): void;
+/**
+ * Get current auto-reply configuration
+ */
+export declare function getAutoReplyConfig(): AutoReplyConfig;
+/**
+ * Check if a message should trigger an auto-reply
+ */
+export declare function checkAutoReply(message: string, userId: string, channelId?: string): AutoReplyResult;
+/**
+ * Add or replace a template by ID
+ */
+export declare function addTemplate(template: AutoReplyTemplate): void;
+/**
+ * Remove a template by ID
+ */
+export declare function removeTemplate(id: string): boolean;
+/**
+ * Get built-in template presets
+ */
+export declare function getTemplatePresets(): AutoReplyTemplate[];
+/**
+ * Cleanup stale tracking entries (call periodically)
+ */
+export declare function cleanupAutoReplyState(): void;
+/**
+ * Reset all state (for testing)
+ */
+export declare function resetAutoReply(): void;
+//# sourceMappingURL=auto-reply.d.ts.map

package/dist/chat/auto-reply.js

@@ -0,0 +1,272 @@
+/**
+ * Auto-Reply System
+ *
+ * Template-based automatic responses for chat messages.
+ * Supports:
+ * - Out-of-office / away mode
+ * - Busy/DND mode with queue position
+ * - Keyword-triggered quick replies
+ * - Rate-limited to prevent spam
+ * - Per-channel configuration
+ */
+import { logger } from '../utils/logger.js';
+// --- State ---
+const DEFAULT_CONFIG = {
+    enabled: false,
+    templates: [],
+    globalCooldownMs: 30_000, // 30 seconds between replies to same user
+    maxRepliesPerHour: 10,
+};
+let config = { ...DEFAULT_CONFIG };
+// Track last reply time per user to enforce cooldowns
+const lastReplyMap = new Map();
+// --- Core Functions ---
+/**
+ * Load auto-reply configuration
+ */
+export function configureAutoReply(newConfig) {
+    config = { ...config, ...newConfig };
+    if (newConfig.templates) {
+        // Sort by priority descending
+        config.templates.sort((a, b) => b.priority - a.priority);
+    }
+    logger.info('[AutoReply] Configuration updated', {
+        enabled: config.enabled,
+        templates: config.templates.length,
+    });
+}
+/**
+ * Get current auto-reply configuration
+ */
+export function getAutoReplyConfig() {
+    return { ...config };
+}
+/**
+ * Check if a message should trigger an auto-reply
+ */
+export function checkAutoReply(message, userId, channelId) {
+    if (!config.enabled || config.templates.length === 0) {
+        return { shouldReply: false, reason: 'disabled' };
+    }
+    // Check global cooldown
+    const userState = lastReplyMap.get(userId);
+    const now = Date.now();
+    if (userState) {
+        // Reset hourly counter if hour has passed
+        if (now - userState.hourStart > 3_600_000) {
+            userState.count = 0;
+            userState.hourStart = now;
+        }
+        // Check cooldown
+        if (now - userState.time < config.globalCooldownMs) {
+            return { shouldReply: false, reason: 'cooldown' };
+        }
+        // Check rate limit
+        if (userState.count >= config.maxRepliesPerHour) {
+            return { shouldReply: false, reason: 'rate_limited' };
+        }
+    }
+    // Find matching template (sorted by priority)
+    for (const template of config.templates) {
+        if (!template.enabled)
+            continue;
+        // Check channel filter
+        if (template.channels && template.channels.length > 0 && channelId) {
+            if (!template.channels.includes(channelId))
+                continue;
+        }
+        // Check per-template cooldown
+        const templateKey = `${userId}:${template.id}`;
+        const templateState = lastReplyMap.get(templateKey);
+        if (templateState && now - templateState.time < template.cooldownMs) {
+            continue;
+        }
+        // Check trigger
+        if (matchesTrigger(template.trigger, message)) {
+            // Update global user state
+            const existing = lastReplyMap.get(userId);
+            const updatedState = existing
+                ? { ...existing, time: now, count: existing.count + 1 }
+                : { time: now, count: 1, hourStart: now };
+            lastReplyMap.set(userId, updatedState);
+            // Update per-template state
+            lastReplyMap.set(templateKey, { time: now, count: 1, hourStart: now });
+            // Render message with variables
+            const rendered = renderTemplate(template.message, {
+                ...template.variables,
+                user: userId,
+                channel: channelId ?? 'unknown',
+                time: new Date().toLocaleTimeString(),
+                date: new Date().toLocaleDateString(),
+            });
+            logger.debug('[AutoReply] Triggered', { templateId: template.id, userId, channelId });
+            return {
+                shouldReply: true,
+                templateId: template.id,
+                message: rendered,
+            };
+        }
+    }
+    return { shouldReply: false, reason: 'no_match' };
+}
+/**
+ * Check if a trigger matches the message
+ */
+function matchesTrigger(trigger, message) {
+    switch (trigger.type) {
+        case 'always':
+            return true;
+        case 'keyword': {
+            const lower = message.toLowerCase();
+            return trigger.keywords.some(kw => lower.includes(kw.toLowerCase()));
+        }
+        case 'regex': {
+            try {
+                const re = new RegExp(trigger.pattern, 'i');
+                return re.test(message);
+            }
+            catch {
+                return false;
+            }
+        }
+        case 'no_agent':
+            // This is checked externally - always matches when the trigger is selected
+            return true;
+        case 'after_hours':
+            return isAfterHours(trigger.schedule);
+        default:
+            return false;
+    }
+}
+/**
+ * Check if current time is outside business hours
+ */
+function isAfterHours(schedule) {
+    try {
+        const now = new Date();
+        // Use Intl to get time in the specified timezone
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone: schedule.timezone,
+            hour: 'numeric',
+            minute: 'numeric',
+            hour12: false,
+            weekday: 'short',
+        });
+        const parts = formatter.formatToParts(now);
+        const hour = Number(parts.find(p => p.type === 'hour')?.value ?? 0);
+        const weekday = parts.find(p => p.type === 'weekday')?.value ?? '';
+        // Map weekday names to numbers
+        const dayMap = {
+            Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6,
+        };
+        const dayNum = dayMap[weekday] ?? -1;
+        // Check if today is a business day
+        if (!schedule.days.includes(dayNum))
+            return true;
+        // Check if current hour is outside business hours
+        return hour < schedule.hours.start || hour >= schedule.hours.end;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Render template variables: {{variable}} -> value
+ */
+function renderTemplate(template, vars) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+        return vars[key] ?? `{{${key}}}`;
+    });
+}
+/**
+ * Add or replace a template by ID
+ */
+export function addTemplate(template) {
+    // Remove existing with same ID
+    config.templates = config.templates.filter(t => t.id !== template.id);
+    config.templates.push(template);
+    config.templates.sort((a, b) => b.priority - a.priority);
+}
+/**
+ * Remove a template by ID
+ */
+export function removeTemplate(id) {
+    const before = config.templates.length;
+    config.templates = config.templates.filter(t => t.id !== id);
+    return config.templates.length < before;
+}
+/**
+ * Get built-in template presets
+ */
+export function getTemplatePresets() {
+    return [
+        {
+            id: 'away',
+            name: 'Away / Out of Office',
+            trigger: { type: 'always' },
+            message: "I'm currently away and will respond when I return. For urgent matters, please contact the team directly.",
+            enabled: false,
+            cooldownMs: 300_000, // 5 min
+            maxPerHour: 5,
+            priority: 100,
+        },
+        {
+            id: 'after-hours',
+            name: 'After Hours',
+            trigger: {
+                type: 'after_hours',
+                schedule: {
+                    timezone: 'America/New_York',
+                    hours: { start: 9, end: 17 },
+                    days: [1, 2, 3, 4, 5], // Mon-Fri
+                },
+            },
+            message: "Thanks for your message! I'm currently outside business hours (Mon-Fri 9AM-5PM ET). I'll respond during the next business day.",
+            enabled: false,
+            cooldownMs: 600_000, // 10 min
+            maxPerHour: 3,
+            priority: 90,
+        },
+        {
+            id: 'help',
+            name: 'Help / FAQ',
+            trigger: { type: 'keyword', keywords: ['help', 'faq', 'how to', 'getting started'] },
+            message: "Need help? Here are some commands:\n- `/help` - Show all commands\n- `/status` - System status\n- `/skills` - Available skills\n\nOr just ask me anything!",
+            enabled: false,
+            cooldownMs: 60_000,
+            maxPerHour: 10,
+            priority: 50,
+        },
+        {
+            id: 'no-agent',
+            name: 'No Agent Available',
+            trigger: { type: 'no_agent' },
+            message: "All agents are currently busy. Your message has been queued and will be processed shortly. Current wait time: approximately {{waitTime}}.",
+            enabled: false,
+            cooldownMs: 120_000,
+            maxPerHour: 5,
+            priority: 80,
+            variables: { waitTime: '1-2 minutes' },
+        },
+    ];
+}
+/**
+ * Cleanup stale tracking entries (call periodically)
+ */
+export function cleanupAutoReplyState() {
+    const now = Date.now();
+    const staleThreshold = 3_600_000; // 1 hour
+    for (const [key, state] of lastReplyMap) {
+        if (now - state.time > staleThreshold) {
+            lastReplyMap.delete(key);
+        }
+    }
+}
+/**
+ * Reset all state (for testing)
+ */
+export function resetAutoReply() {
+    config = { ...DEFAULT_CONFIG };
+    lastReplyMap.clear();
+}
+//# sourceMappingURL=auto-reply.js.map