overai 1.4.0

package/dist/cli/features/sandbox-executor.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * Sandbox Executor - Safe command execution with restrictions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxExecutor = exports.CommandValidator = exports.DEFAULT_BLOCKED_PATHS = exports.DEFAULT_BLOCKED_COMMANDS = void 0;
+exports.createSandboxExecutor = createSandboxExecutor;
+exports.sandboxExec = sandboxExec;
+/**
+ * Default blocked commands (dangerous operations)
+ */
+exports.DEFAULT_BLOCKED_COMMANDS = [
+    'rm -rf /',
+    'rm -rf /*',
+    'rm -rf ~',
+    'rm -rf ~/*',
+    'mkfs',
+    'dd if=/dev/zero',
+    'dd if=/dev/random',
+    ':(){ :|:& };:',
+    'chmod -R 777 /',
+    'chown -R',
+    'sudo rm',
+    'sudo dd',
+    'sudo mkfs',
+    'shutdown',
+    'reboot',
+    'halt',
+    'poweroff',
+    'init 0',
+    'init 6'
+];
+/**
+ * Default blocked paths
+ */
+exports.DEFAULT_BLOCKED_PATHS = [
+    '/etc/passwd',
+    '/etc/shadow',
+    '/etc/sudoers',
+    '/root',
+    '~/.ssh',
+    '~/.gnupg',
+    '~/.aws',
+    '~/.config/gcloud',
+    '/var/log',
+    '/boot',
+    '/sys',
+    '/proc'
+];
+/**
+ * Command validator
+ */
+class CommandValidator {
+    constructor(config = {}) {
+        this.blockedCommands = config.blockedCommands || exports.DEFAULT_BLOCKED_COMMANDS;
+        this.blockedPaths = config.blockedPaths || exports.DEFAULT_BLOCKED_PATHS;
+        this.allowedCommands = config.allowedCommands;
+    }
+    /**
+     * Validate a command
+     */
+    validate(command) {
+        const normalized = command.toLowerCase().trim();
+        // Check allowlist first if specified
+        if (this.allowedCommands) {
+            const baseCmd = normalized.split(/\s+/)[0];
+            if (!this.allowedCommands.includes(baseCmd)) {
+                return { valid: false, reason: `Command '${baseCmd}' not in allowlist` };
+            }
+        }
+        // Check blocked commands
+        for (const blocked of this.blockedCommands) {
+            if (normalized.includes(blocked.toLowerCase())) {
+                return { valid: false, reason: `Blocked command pattern: ${blocked}` };
+            }
+        }
+        // Check blocked paths
+        for (const blockedPath of this.blockedPaths) {
+            const expandedPath = blockedPath.replace('~', process.env.HOME || '');
+            if (normalized.includes(expandedPath.toLowerCase())) {
+                return { valid: false, reason: `Blocked path: ${blockedPath}` };
+            }
+        }
+        // Check for shell injection patterns
+        const dangerousPatterns = [
+            /;\s*rm\s/i,
+            /\|\s*rm\s/i,
+            /`.*`/,
+            /\$\(.*\)/,
+            />\s*\/dev\/sd/i,
+            />\s*\/dev\/null.*2>&1.*&/i
+        ];
+        for (const pattern of dangerousPatterns) {
+            if (pattern.test(command)) {
+                return { valid: false, reason: 'Potentially dangerous pattern detected' };
+            }
+        }
+        return { valid: true };
+    }
+}
+exports.CommandValidator = CommandValidator;
+/**
+ * Sandbox Executor class
+ */
+class SandboxExecutor {
+    constructor(config = {}) {
+        this.config = {
+            mode: 'basic',
+            timeout: 30000,
+            maxOutputSize: 1024 * 1024, // 1MB
+            cwd: process.cwd(),
+            ...config
+        };
+        this.validator = new CommandValidator(this.config);
+    }
+    /**
+     * Execute a command in the sandbox
+     */
+    async execute(command) {
+        const startTime = Date.now();
+        // Disabled mode - no execution
+        if (this.config.mode === 'disabled') {
+            return {
+                success: false,
+                stdout: '',
+                stderr: 'Sandbox execution is disabled',
+                exitCode: 1,
+                duration: 0
+            };
+        }
+        // Validate command
+        const validation = this.validator.validate(command);
+        if (!validation.valid) {
+            return {
+                success: false,
+                stdout: '',
+                stderr: `Command rejected: ${validation.reason}`,
+                exitCode: 1,
+                duration: 0
+            };
+        }
+        try {
+            const result = await this.spawn(command);
+            return {
+                ...result,
+                duration: Date.now() - startTime
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                stdout: '',
+                stderr: error.message,
+                exitCode: 1,
+                duration: Date.now() - startTime
+            };
+        }
+    }
+    /**
+     * Spawn the command
+     */
+    async spawn(command) {
+        const { spawn } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        return new Promise((resolve) => {
+            const env = this.buildEnv();
+            const proc = spawn('sh', ['-c', command], {
+                cwd: this.config.cwd,
+                env,
+                timeout: this.config.timeout,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            let truncated = false;
+            const maxSize = this.config.maxOutputSize || 1024 * 1024;
+            proc.stdout?.on('data', (data) => {
+                if (stdout.length < maxSize) {
+                    stdout += data.toString();
+                    if (stdout.length > maxSize) {
+                        stdout = stdout.slice(0, maxSize);
+                        truncated = true;
+                    }
+                }
+            });
+            proc.stderr?.on('data', (data) => {
+                if (stderr.length < maxSize) {
+                    stderr += data.toString();
+                    if (stderr.length > maxSize) {
+                        stderr = stderr.slice(0, maxSize);
+                        truncated = true;
+                    }
+                }
+            });
+            proc.on('close', (code) => {
+                resolve({
+                    success: code === 0,
+                    stdout,
+                    stderr,
+                    exitCode: code || 0,
+                    truncated
+                });
+            });
+            proc.on('error', (error) => {
+                resolve({
+                    success: false,
+                    stdout,
+                    stderr: error.message,
+                    exitCode: 1
+                });
+            });
+        });
+    }
+    /**
+     * Build environment variables based on sandbox mode
+     */
+    buildEnv() {
+        const baseEnv = { ...process.env, ...this.config.env };
+        switch (this.config.mode) {
+            case 'strict':
+                // Minimal environment
+                return {
+                    PATH: '/usr/local/bin:/usr/bin:/bin',
+                    HOME: process.env.HOME || '',
+                    USER: process.env.USER || '',
+                    SHELL: '/bin/sh',
+                    TERM: 'dumb',
+                    ...this.config.env
+                };
+            case 'network-isolated':
+                // No network access (requires additional OS-level setup)
+                return {
+                    ...baseEnv,
+                    http_proxy: 'http://localhost:0',
+                    https_proxy: 'http://localhost:0',
+                    HTTP_PROXY: 'http://localhost:0',
+                    HTTPS_PROXY: 'http://localhost:0',
+                    no_proxy: '',
+                    NO_PROXY: ''
+                };
+            case 'basic':
+            default:
+                return baseEnv;
+        }
+    }
+    /**
+     * Check if a command would be allowed
+     */
+    wouldAllow(command) {
+        if (this.config.mode === 'disabled') {
+            return { allowed: false, reason: 'Sandbox execution is disabled' };
+        }
+        const validation = this.validator.validate(command);
+        return { allowed: validation.valid, reason: validation.reason };
+    }
+    /**
+     * Get current sandbox mode
+     */
+    getMode() {
+        return this.config.mode;
+    }
+    /**
+     * Update sandbox mode
+     */
+    setMode(mode) {
+        this.config.mode = mode;
+    }
+}
+exports.SandboxExecutor = SandboxExecutor;
+/**
+ * Create a sandbox executor
+ */
+function createSandboxExecutor(config) {
+    return new SandboxExecutor(config);
+}
+/**
+ * Quick execute with default sandbox
+ */
+async function sandboxExec(command, config) {
+    const executor = createSandboxExecutor(config);
+    return executor.execute(command);
+}

package/dist/cli/features/scheduler.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Agent Scheduler - Cron-like scheduling for agent tasks
+ */
+export interface ScheduleConfig {
+    id?: string;
+    name: string;
+    cron?: string;
+    interval?: number;
+    task: () => Promise<any>;
+    enabled?: boolean;
+    maxRuns?: number;
+    onComplete?: (result: any) => void;
+    onError?: (error: Error) => void;
+}
+export interface ScheduledTask {
+    id: string;
+    name: string;
+    cron?: string;
+    interval?: number;
+    enabled: boolean;
+    lastRun?: Date;
+    nextRun?: Date;
+    runCount: number;
+    maxRuns?: number;
+    status: 'idle' | 'running' | 'completed' | 'error';
+    lastError?: string;
+}
+export interface SchedulerStats {
+    totalTasks: number;
+    activeTasks: number;
+    totalRuns: number;
+    errors: number;
+}
+/**
+ * Scheduler class
+ */
+export declare class Scheduler {
+    private tasks;
+    private running;
+    private stats;
+    /**
+     * Add a scheduled task
+     */
+    add(config: ScheduleConfig): string;
+    /**
+     * Remove a task
+     */
+    remove(id: string): boolean;
+    /**
+     * Enable a task
+     */
+    enable(id: string): boolean;
+    /**
+     * Disable a task
+     */
+    disable(id: string): boolean;
+    /**
+     * Start the scheduler
+     */
+    start(): void;
+    /**
+     * Stop the scheduler
+     */
+    stop(): void;
+    /**
+     * Schedule a task's next run
+     */
+    private scheduleTask;
+    /**
+     * Run a task
+     */
+    private runTask;
+    /**
+     * Run a task immediately
+     */
+    runNow(id: string): Promise<any>;
+    /**
+     * Get task info
+     */
+    getTask(id: string): ScheduledTask | undefined;
+    /**
+     * Get all tasks
+     */
+    getAllTasks(): ScheduledTask[];
+    /**
+     * Get scheduler stats
+     */
+    getStats(): SchedulerStats;
+    /**
+     * Check if scheduler is running
+     */
+    isRunning(): boolean;
+}
+/**
+ * Create a scheduler instance
+ */
+export declare function createScheduler(): Scheduler;
+/**
+ * Helper to create common cron expressions
+ */
+export declare const cronExpressions: {
+    everyMinute: string;
+    every5Minutes: string;
+    every15Minutes: string;
+    everyHour: string;
+    everyDay: string;
+    everyWeek: string;
+    everyMonth: string;
+    weekdays: string;
+    weekends: string;
+};