profclaw 0.0.1-beta.3 → 2.3.0

package/dist/chat/auto-reply.js

@@ -1,272 +0,0 @@
-/**
- * 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

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

@@ -1,92 +0,0 @@
-/**
- * PTY (Pseudo-Terminal) Support
- *
- * Provides interactive terminal support for commands that require TTY.
- * Uses node-pty for cross-platform PTY handling.
- *
- * Use cases:
- * - Interactive installers (npm init, create-react-app)
- * - Text editors (vim, nano)
- * - Pagers (less, more)
- * - Password prompts
- * - SSH sessions
- */
-import { EventEmitter } from 'events';
-export interface PTYSession {
-    id: string;
-    pid: number;
-    command: string;
-    cols: number;
-    rows: number;
-    status: 'running' | 'exited';
-    exitCode?: number;
-    output: string;
-    createdAt: Date;
-    exitedAt?: Date;
-}
-export interface PTYOptions {
-    cols?: number;
-    rows?: number;
-    cwd?: string;
-    env?: Record<string, string>;
-    timeout?: number;
-    maxOutputChars?: number;
-}
-export interface PTYResult {
-    success: boolean;
-    exitCode: number;
-    output: string;
-    durationMs: number;
-    truncated: boolean;
-    secretsRedacted: boolean;
-}
-export declare class PTYManager extends EventEmitter {
-    private sessions;
-    private sessionCounter;
-    /**
-     * Spawn a new PTY session
-     */
-    spawn(command: string, args?: string[], options?: PTYOptions): PTYSession;
-    /**
-     * Execute a command and wait for completion
-     */
-    execute(command: string, args?: string[], options?: PTYOptions): Promise<PTYResult>;
-    /**
-     * Write input to PTY
-     */
-    write(sessionId: string, data: string): boolean;
-    /**
-     * Resize PTY dimensions
-     */
-    resize(sessionId: string, cols: number, rows: number): boolean;
-    /**
-     * Kill a PTY session
-     */
-    kill(sessionId: string, signal?: string): boolean;
-    /**
-     * Get session info
-     */
-    getSession(sessionId: string): PTYSession | null;
-    /**
-     * Get all active sessions
-     */
-    getActiveSessions(): PTYSession[];
-    /**
-     * Subscribe to session output
-     */
-    subscribe(sessionId: string, listener: (data: string) => void): () => void;
-    /**
-     * Clean up completed session
-     */
-    cleanup(sessionId: string): void;
-    /**
-     * Clean up all sessions
-     */
-    cleanupAll(): void;
-}
-export declare function getPTYManager(): PTYManager;
-/**
- * Check if a command likely requires PTY
- */
-export declare function commandNeedsPTY(command: string): boolean;
-//# sourceMappingURL=pty.d.ts.map

package/dist/chat/execution/pty.js

@@ -1,285 +0,0 @@
-/**
- * PTY (Pseudo-Terminal) Support
- *
- * Provides interactive terminal support for commands that require TTY.
- * Uses node-pty for cross-platform PTY handling.
- *
- * Use cases:
- * - Interactive installers (npm init, create-react-app)
- * - Text editors (vim, nano)
- * - Pagers (less, more)
- * - Password prompts
- * - SSH sessions
- */
-import * as pty from 'node-pty';
-import { EventEmitter } from 'events';
-import { logger } from '../../utils/logger.js';
-import { redactSecrets, isSecretsDetectionEnabled } from './secrets.js';
-// =============================================================================
-// Constants
-// =============================================================================
-const DEFAULT_COLS = 80;
-const DEFAULT_ROWS = 24;
-const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
-const DEFAULT_MAX_OUTPUT = 200_000;
-// =============================================================================
-// PTY Manager
-// =============================================================================
-export class PTYManager extends EventEmitter {
-    sessions = new Map();
-    sessionCounter = 0;
-    /**
-     * Spawn a new PTY session
-     */
-    spawn(command, args = [], options = {}) {
-        const id = `pty_${Date.now()}_${++this.sessionCounter}`;
-        const cols = options.cols ?? DEFAULT_COLS;
-        const rows = options.rows ?? DEFAULT_ROWS;
-        // Determine shell
-        const shell = process.platform === 'win32'
-            ? process.env.ComSpec || 'cmd.exe'
-            : process.env.SHELL || '/bin/bash';
-        // Build args
-        const shellArgs = process.platform === 'win32'
-            ? ['/c', command, ...args]
-            : ['-c', `${command} ${args.join(' ')}`];
-        logger.debug(`[PTY] Spawning: ${command}`, { id, cols, rows });
-        // Spawn PTY
-        const ptyProcess = pty.spawn(shell, shellArgs, {
-            name: 'xterm-256color',
-            cols,
-            rows,
-            cwd: options.cwd ?? process.cwd(),
-            env: {
-                ...process.env,
-                ...options.env,
-                TERM: 'xterm-256color',
-                COLORTERM: 'truecolor',
-            },
-        });
-        const session = {
-            id,
-            pid: ptyProcess.pid,
-            command,
-            cols,
-            rows,
-            status: 'running',
-            output: '',
-            createdAt: new Date(),
-        };
-        const entry = {
-            pty: ptyProcess,
-            session,
-            outputBuffer: '',
-            listeners: new Set(),
-        };
-        this.sessions.set(id, entry);
-        // Handle data
-        ptyProcess.onData((data) => {
-            entry.outputBuffer += data;
-            session.output = entry.outputBuffer;
-            // Truncate if needed
-            const maxChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT;
-            if (entry.outputBuffer.length > maxChars) {
-                entry.outputBuffer = `[...truncated...]\n${entry.outputBuffer.slice(-maxChars)}`;
-                session.output = entry.outputBuffer;
-            }
-            // Notify listeners
-            for (const listener of entry.listeners) {
-                listener(data);
-            }
-            this.emit('data', id, data);
-        });
-        // Handle exit
-        ptyProcess.onExit(({ exitCode }) => {
-            session.status = 'exited';
-            session.exitCode = exitCode;
-            session.exitedAt = new Date();
-            logger.debug(`[PTY] Exited: ${id}`, { exitCode });
-            this.emit('exit', id, exitCode);
-        });
-        return session;
-    }
-    /**
-     * Execute a command and wait for completion
-     */
-    async execute(command, args = [], options = {}) {
-        const startTime = Date.now();
-        const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
-        const maxOutput = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT;
-        const session = this.spawn(command, args, options);
-        const entry = this.sessions.get(session.id);
-        if (!entry) {
-            throw new Error('Failed to create PTY session');
-        }
-        return new Promise((resolve) => {
-            let timedOut = false;
-            // Timeout handler
-            const timeoutId = setTimeout(() => {
-                timedOut = true;
-                this.kill(session.id);
-            }, timeout);
-            // Wait for exit
-            const exitHandler = (id, exitCode) => {
-                if (id !== session.id)
-                    return;
-                clearTimeout(timeoutId);
-                this.off('exit', exitHandler);
-                const durationMs = Date.now() - startTime;
-                let output = entry.outputBuffer;
-                let secretsRedacted = false;
-                // Redact secrets if enabled
-                if (isSecretsDetectionEnabled()) {
-                    output = redactSecrets(output);
-                    secretsRedacted = output !== entry.outputBuffer;
-                }
-                // Clean up session after a delay
-                setTimeout(() => this.cleanup(session.id), 5000);
-                resolve({
-                    success: !timedOut && exitCode === 0,
-                    exitCode: timedOut ? -1 : exitCode,
-                    output: output.trim() || '(no output)',
-                    durationMs,
-                    truncated: entry.outputBuffer.length >= maxOutput,
-                    secretsRedacted,
-                });
-            };
-            this.on('exit', exitHandler);
-        });
-    }
-    /**
-     * Write input to PTY
-     */
-    write(sessionId, data) {
-        const entry = this.sessions.get(sessionId);
-        if (!entry || entry.session.status !== 'running') {
-            return false;
-        }
-        entry.pty.write(data);
-        return true;
-    }
-    /**
-     * Resize PTY dimensions
-     */
-    resize(sessionId, cols, rows) {
-        const entry = this.sessions.get(sessionId);
-        if (!entry || entry.session.status !== 'running') {
-            return false;
-        }
-        entry.pty.resize(cols, rows);
-        entry.session.cols = cols;
-        entry.session.rows = rows;
-        return true;
-    }
-    /**
-     * Kill a PTY session
-     */
-    kill(sessionId, signal = 'SIGTERM') {
-        const entry = this.sessions.get(sessionId);
-        if (!entry || entry.session.status !== 'running') {
-            return false;
-        }
-        try {
-            entry.pty.kill(signal);
-            return true;
-        }
-        catch (error) {
-            logger.warn(`[PTY] Failed to kill session ${sessionId}`, { error });
-            return false;
-        }
-    }
-    /**
-     * Get session info
-     */
-    getSession(sessionId) {
-        return this.sessions.get(sessionId)?.session ?? null;
-    }
-    /**
-     * Get all active sessions
-     */
-    getActiveSessions() {
-        return Array.from(this.sessions.values())
-            .filter((e) => e.session.status === 'running')
-            .map((e) => e.session);
-    }
-    /**
-     * Subscribe to session output
-     */
-    subscribe(sessionId, listener) {
-        const entry = this.sessions.get(sessionId);
-        if (!entry) {
-            return () => { };
-        }
-        entry.listeners.add(listener);
-        return () => entry.listeners.delete(listener);
-    }
-    /**
-     * Clean up completed session
-     */
-    cleanup(sessionId) {
-        const entry = this.sessions.get(sessionId);
-        if (entry) {
-            if (entry.session.status === 'running') {
-                this.kill(sessionId);
-            }
-            entry.listeners.clear();
-            this.sessions.delete(sessionId);
-            logger.debug(`[PTY] Cleaned up session: ${sessionId}`);
-        }
-    }
-    /**
-     * Clean up all sessions
-     */
-    cleanupAll() {
-        for (const sessionId of this.sessions.keys()) {
-            this.cleanup(sessionId);
-        }
-    }
-}
-// =============================================================================
-// Singleton Instance
-// =============================================================================
-let _ptyManager = null;
-export function getPTYManager() {
-    if (!_ptyManager) {
-        _ptyManager = new PTYManager();
-    }
-    return _ptyManager;
-}
-// =============================================================================
-// Helper: Check if command needs PTY
-// =============================================================================
-const PTY_REQUIRED_COMMANDS = new Set([
-    'vim', 'vi', 'nvim', 'nano', 'emacs',
-    'less', 'more', 'man',
-    'top', 'htop', 'btop',
-    'ssh', 'telnet',
-    'ftp', 'sftp',
-    'mysql', 'psql', 'mongo', 'redis-cli',
-    'python', 'python3', 'node', 'irb', 'rails',
-    'bash', 'zsh', 'sh', 'fish',
-]);
-const PTY_HINT_PATTERNS = [
-    /npm\s+init/i,
-    /yarn\s+init/i,
-    /npx\s+create-/i,
-    /\bpassword\b/i,
-    /\bsudo\b/,
-    /--interactive/i,
-    /-i\b/,
-];
-/**
- * Check if a command likely requires PTY
- */
-export function commandNeedsPTY(command) {
-    // Extract base command
-    const parts = command.trim().split(/\s+/);
-    const baseCmd = parts[0]?.split('/').pop() ?? '';
-    // Check known PTY-required commands
-    if (PTY_REQUIRED_COMMANDS.has(baseCmd)) {
-        return true;
-    }
-    // Check hint patterns
-    return PTY_HINT_PATTERNS.some((p) => p.test(command));
-}
-//# sourceMappingURL=pty.js.map