neuro-cli 4.1.0

package/dist/core/sandbox.d.ts

@@ -0,0 +1,127 @@
+export interface SandboxConfig {
+    /** Whether sandbox mode is enabled */
+    enabled: boolean;
+    /** Root directory - only files under this dir can be modified */
+    rootDir: string;
+    /** Allowed directories (in addition to rootDir) */
+    allowedDirs: string[];
+    /** Denied directories (even under rootDir) */
+    deniedDirs: string[];
+    /** Denied file patterns (glob) */
+    deniedPatterns: string[];
+    /** Whether to allow command execution */
+    allowCommands: boolean;
+    /** Allowed commands (whitelist) */
+    allowedCommands: string[];
+    /** Denied commands (blacklist) */
+    deniedCommands: string[];
+    /** Whether to create backups before modifications */
+    backupOnModify: boolean;
+    /** Backup directory */
+    backupDir: string;
+    /** Maximum file size that can be written (bytes) */
+    maxFileSize: number;
+    /** Whether to allow network access */
+    allowNetwork: boolean;
+    /** Whether to allow environment variable access */
+    allowEnvAccess: boolean;
+    /** Read-only mode (no modifications at all) */
+    readOnly: boolean;
+}
+export interface SandboxViolation {
+    type: 'file_write' | 'file_delete' | 'file_read' | 'command' | 'network' | 'env';
+    path?: string;
+    command?: string;
+    reason: string;
+    timestamp: number;
+}
+export declare const DEFAULT_SANDBOX_CONFIG: SandboxConfig;
+export declare class Sandbox {
+    private config;
+    private violations;
+    private backups;
+    private originalContents;
+    constructor(config?: Partial<SandboxConfig>);
+    /**
+     * Check if a file path is allowed for reading
+     */
+    canRead(filePath: string): boolean;
+    /**
+     * Check if a file path is allowed for writing
+     */
+    canWrite(filePath: string, contentSize?: number): boolean;
+    /**
+     * Check if a file can be deleted
+     */
+    canDelete(filePath: string): boolean;
+    /**
+     * Check if a command is allowed
+     */
+    canRunCommand(command: string): boolean;
+    /**
+     * Check if network access is allowed
+     */
+    canAccessNetwork(): boolean;
+    /**
+     * Check if environment variable access is allowed
+     */
+    canAccessEnv(): boolean;
+    /**
+     * Create a backup of a file before modification
+     */
+    backupFile(filePath: string): boolean;
+    /**
+     * Undo a file modification by restoring from backup
+     */
+    undoFile(filePath: string): boolean;
+    /**
+     * Undo all modifications made in this session
+     */
+    undoAll(): number;
+    /**
+     * Get all violations recorded
+     */
+    getViolations(): SandboxViolation[];
+    /**
+     * Get the number of violations
+     */
+    getViolationCount(): number;
+    /**
+     * Clear all violations
+     */
+    clearViolations(): void;
+    /**
+     * Enable sandbox mode
+     */
+    enable(): void;
+    /**
+     * Disable sandbox mode
+     */
+    disable(): void;
+    /**
+     * Check if sandbox is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Toggle sandbox mode
+     */
+    toggle(): boolean;
+    /**
+     * Get current sandbox configuration
+     */
+    getConfig(): SandboxConfig;
+    /**
+     * Update sandbox configuration
+     */
+    updateConfig(updates: Partial<SandboxConfig>): void;
+    /**
+     * Print sandbox status
+     */
+    printStatus(): void;
+    private resolvePath;
+    private isUnderRootDir;
+    private isInDeniedDir;
+    private matchesDeniedPattern;
+    private recordViolation;
+}
+//# sourceMappingURL=sandbox.d.ts.map

package/dist/core/sandbox.js

@@ -0,0 +1,369 @@
+// ============================================================
+// NeuroCLI - Sandbox Mode
+// File isolation and safe execution environment
+// Prevents modifications outside the project directory
+// ============================================================
+import { join, resolve, relative, normalize } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from 'fs';
+import chalk from 'chalk';
+export const DEFAULT_SANDBOX_CONFIG = {
+    enabled: false,
+    rootDir: process.cwd(),
+    allowedDirs: [],
+    deniedDirs: [
+        'node_modules',
+        '.git',
+        '__pycache__',
+        '.env',
+    ],
+    deniedPatterns: [
+        '**/.env',
+        '**/.env.*',
+        '**/id_rsa*',
+        '**/id_ed25519*',
+        '**/*.pem',
+        '**/*.key',
+        '**/credentials.json',
+        '**/secrets.*',
+    ],
+    allowCommands: true,
+    allowedCommands: [],
+    deniedCommands: [
+        'rm -rf /',
+        'sudo rm',
+        'mkfs',
+        'dd if=',
+        ':(){ :|:& };:', // fork bomb
+        'chmod 777 /',
+        'curl | sh',
+        'wget | sh',
+    ],
+    backupOnModify: true,
+    backupDir: '.neuro/backups',
+    maxFileSize: 10 * 1024 * 1024, // 10MB
+    allowNetwork: true,
+    allowEnvAccess: false,
+    readOnly: false,
+};
+export class Sandbox {
+    config;
+    violations = [];
+    backups = new Map(); // original path -> backup path
+    originalContents = new Map(); // for undo
+    constructor(config) {
+        this.config = { ...DEFAULT_SANDBOX_CONFIG, ...config };
+        if (!this.config.rootDir)
+            this.config.rootDir = process.cwd();
+        this.config.rootDir = resolve(this.config.rootDir);
+    }
+    /**
+     * Check if a file path is allowed for reading
+     */
+    canRead(filePath) {
+        if (!this.config.enabled)
+            return true;
+        const absPath = this.resolvePath(filePath);
+        // Check denied dirs
+        if (this.isInDeniedDir(absPath)) {
+            this.recordViolation('file_read', absPath, 'Access denied: path is in a denied directory');
+            return false;
+        }
+        // Check denied patterns
+        if (this.matchesDeniedPattern(absPath)) {
+            this.recordViolation('file_read', absPath, 'Access denied: path matches a denied pattern');
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if a file path is allowed for writing
+     */
+    canWrite(filePath, contentSize) {
+        if (!this.config.enabled)
+            return true;
+        if (this.config.readOnly) {
+            this.recordViolation('file_write', this.resolvePath(filePath), 'Write denied: sandbox is in read-only mode');
+            return false;
+        }
+        const absPath = this.resolvePath(filePath);
+        // Must be under rootDir
+        if (!this.isUnderRootDir(absPath)) {
+            this.recordViolation('file_write', absPath, `Write denied: path is outside project directory (${this.config.rootDir})`);
+            return false;
+        }
+        // Check denied dirs
+        if (this.isInDeniedDir(absPath)) {
+            this.recordViolation('file_write', absPath, 'Write denied: path is in a denied directory');
+            return false;
+        }
+        // Check denied patterns
+        if (this.matchesDeniedPattern(absPath)) {
+            this.recordViolation('file_write', absPath, 'Write denied: path matches a denied pattern');
+            return false;
+        }
+        // Check file size
+        if (contentSize !== undefined && contentSize > this.config.maxFileSize) {
+            this.recordViolation('file_write', absPath, `Write denied: file size (${contentSize} bytes) exceeds maximum (${this.config.maxFileSize} bytes)`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if a file can be deleted
+     */
+    canDelete(filePath) {
+        if (!this.config.enabled)
+            return true;
+        if (this.config.readOnly) {
+            this.recordViolation('file_delete', this.resolvePath(filePath), 'Delete denied: sandbox is in read-only mode');
+            return false;
+        }
+        const absPath = this.resolvePath(filePath);
+        if (!this.isUnderRootDir(absPath)) {
+            this.recordViolation('file_delete', absPath, 'Delete denied: path is outside project directory');
+            return false;
+        }
+        if (this.isInDeniedDir(absPath)) {
+            this.recordViolation('file_delete', absPath, 'Delete denied: path is in a denied directory');
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if a command is allowed
+     */
+    canRunCommand(command) {
+        if (!this.config.enabled)
+            return true;
+        if (!this.config.allowCommands) {
+            this.recordViolation('command', undefined, `Command denied: command execution is disabled`);
+            return false;
+        }
+        // Check denied commands
+        const cmdBase = command.trim().split(/\s+/)[0];
+        for (const denied of this.config.deniedCommands) {
+            if (command.includes(denied) || cmdBase === denied.split(' ')[0]) {
+                this.recordViolation('command', undefined, `Command denied: matches denied pattern "${denied}"`);
+                return false;
+            }
+        }
+        // Check allowed commands whitelist (if set)
+        if (this.config.allowedCommands.length > 0) {
+            const isAllowed = this.config.allowedCommands.some(allowed => cmdBase === allowed || command.startsWith(allowed));
+            if (!isAllowed) {
+                this.recordViolation('command', undefined, `Command denied: "${cmdBase}" is not in the allowed commands list`);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if network access is allowed
+     */
+    canAccessNetwork() {
+        if (!this.config.enabled)
+            return true;
+        if (!this.config.allowNetwork) {
+            this.recordViolation('network', undefined, 'Network access denied');
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if environment variable access is allowed
+     */
+    canAccessEnv() {
+        if (!this.config.enabled)
+            return true;
+        if (!this.config.allowEnvAccess) {
+            this.recordViolation('env', undefined, 'Environment variable access denied');
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Create a backup of a file before modification
+     */
+    backupFile(filePath) {
+        if (!this.config.backupOnModify)
+            return true;
+        const absPath = this.resolvePath(filePath);
+        if (!existsSync(absPath))
+            return true;
+        try {
+            const backupDir = join(this.config.rootDir, this.config.backupDir);
+            if (!existsSync(backupDir))
+                mkdirSync(backupDir, { recursive: true });
+            const relPath = relative(this.config.rootDir, absPath);
+            const backupPath = join(backupDir, `${Date.now()}_${relPath.replace(/\//g, '_')}`);
+            copyFileSync(absPath, backupPath);
+            this.backups.set(absPath, backupPath);
+            // Store original content for undo
+            const content = readFileSync(absPath, 'utf-8');
+            this.originalContents.set(absPath, content);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Undo a file modification by restoring from backup
+     */
+    undoFile(filePath) {
+        const absPath = this.resolvePath(filePath);
+        const originalContent = this.originalContents.get(absPath);
+        if (originalContent === undefined)
+            return false;
+        try {
+            writeFileSync(absPath, originalContent, 'utf-8');
+            this.originalContents.delete(absPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Undo all modifications made in this session
+     */
+    undoAll() {
+        let undone = 0;
+        for (const [path] of this.originalContents) {
+            if (this.undoFile(path))
+                undone++;
+        }
+        return undone;
+    }
+    /**
+     * Get all violations recorded
+     */
+    getViolations() {
+        return [...this.violations];
+    }
+    /**
+     * Get the number of violations
+     */
+    getViolationCount() {
+        return this.violations.length;
+    }
+    /**
+     * Clear all violations
+     */
+    clearViolations() {
+        this.violations = [];
+    }
+    /**
+     * Enable sandbox mode
+     */
+    enable() {
+        this.config.enabled = true;
+    }
+    /**
+     * Disable sandbox mode
+     */
+    disable() {
+        this.config.enabled = false;
+    }
+    /**
+     * Check if sandbox is enabled
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Toggle sandbox mode
+     */
+    toggle() {
+        this.config.enabled = !this.config.enabled;
+        return this.config.enabled;
+    }
+    /**
+     * Get current sandbox configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update sandbox configuration
+     */
+    updateConfig(updates) {
+        Object.assign(this.config, updates);
+    }
+    /**
+     * Print sandbox status
+     */
+    printStatus() {
+        const status = this.config.enabled ? chalk.green('ENABLED') : chalk.gray('DISABLED');
+        console.log(chalk.bold(`\n  Sandbox: ${status}`));
+        if (this.config.enabled) {
+            console.log(`  Root: ${chalk.cyan(this.config.rootDir)}`);
+            console.log(`  Read-only: ${this.config.readOnly ? chalk.red('YES') : chalk.green('NO')}`);
+            console.log(`  Commands: ${this.config.allowCommands ? chalk.green('allowed') : chalk.red('denied')}`);
+            console.log(`  Network: ${this.config.allowNetwork ? chalk.green('allowed') : chalk.red('denied')}`);
+            console.log(`  Backups: ${this.config.backupOnModify ? chalk.green('enabled') : chalk.gray('disabled')}`);
+            console.log(`  Denied dirs: ${this.config.deniedDirs.length > 0 ? chalk.yellow(this.config.deniedDirs.join(', ')) : chalk.gray('none')}`);
+            console.log(`  Denied patterns: ${this.config.deniedPatterns.length > 0 ? chalk.yellow(this.config.deniedPatterns.length + ' patterns') : chalk.gray('none')}`);
+            if (this.violations.length > 0) {
+                console.log(`  Violations: ${chalk.red(String(this.violations.length))}`);
+            }
+        }
+        console.log();
+    }
+    // --- Private Helpers ---
+    resolvePath(filePath) {
+        if (filePath.startsWith('/'))
+            return normalize(filePath);
+        if (filePath.startsWith('~/'))
+            return normalize(join(require('os').homedir(), filePath.slice(2)));
+        return normalize(resolve(this.config.rootDir, filePath));
+    }
+    isUnderRootDir(absPath) {
+        const relativePath = relative(this.config.rootDir, absPath);
+        return !relativePath.startsWith('..') && !relativePath.startsWith('/');
+    }
+    isInDeniedDir(absPath) {
+        const relativePath = relative(this.config.rootDir, absPath);
+        // Check built-in denied dirs
+        for (const deniedDir of this.config.deniedDirs) {
+            if (relativePath.startsWith(deniedDir + '/') || relativePath === deniedDir) {
+                return true;
+            }
+        }
+        // Check custom allowed dirs (everything else is under rootDir)
+        // If allowedDirs is set, deny anything not in those dirs
+        if (this.config.allowedDirs.length > 0) {
+            const inAllowed = this.config.allowedDirs.some(allowedDir => {
+                const absAllowed = resolve(this.config.rootDir, allowedDir);
+                return absPath.startsWith(absAllowed);
+            });
+            if (!inAllowed && this.isUnderRootDir(absPath))
+                return false; // Under root but not in allowed
+        }
+        return false;
+    }
+    matchesDeniedPattern(absPath) {
+        const relativePath = relative(this.config.rootDir, absPath);
+        for (const pattern of this.config.deniedPatterns) {
+            const globPattern = pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*');
+            try {
+                const regex = new RegExp('^' + globPattern + '$');
+                if (regex.test(relativePath) || regex.test(absPath))
+                    return true;
+            }
+            catch {
+                // Invalid pattern, skip
+            }
+        }
+        return false;
+    }
+    recordViolation(type, path, reason) {
+        this.violations.push({
+            type,
+            path,
+            reason: reason || 'Access denied by sandbox',
+            timestamp: Date.now(),
+        });
+    }
+}
+//# sourceMappingURL=sandbox.js.map

package/dist/core/scheduled-tasks.d.ts

@@ -0,0 +1,151 @@
+export type TaskStatus = 'scheduled' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+export type IntervalUnit = 'minutes' | 'hours' | 'days';
+export interface ScheduledTaskConfig {
+    /** Unique identifier (auto-generated if not provided) */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** The prompt / task description to execute each run */
+    prompt: string;
+    /** Interval value (used together with intervalUnit) */
+    interval: number;
+    /** Unit for the interval */
+    intervalUnit: IntervalUnit;
+    /** Maximum number of runs – 0 = unlimited */
+    maxRuns: number;
+    /** Optional model override */
+    model?: string;
+    /** Whether to auto-approve tool calls during execution */
+    autoApprove: boolean;
+    /** Whether to notify on completion (platform-dependent) */
+    notifyOnComplete: boolean;
+    /** Whether to save results to a file */
+    saveResults: boolean;
+    /** Working directory for the task */
+    workingDirectory: string;
+}
+export interface TaskExecution {
+    /** Unique execution ID */
+    id: string;
+    /** The task this execution belongs to */
+    taskId: string;
+    /** ISO timestamp when execution started */
+    startedAt: string;
+    /** ISO timestamp when execution ended */
+    endedAt?: string;
+    /** Duration in ms */
+    durationMs?: number;
+    /** Execution status */
+    status: 'success' | 'error' | 'timeout' | 'aborted';
+    /** The prompt that was executed (may differ from task if templated) */
+    prompt: string;
+    /** Result text */
+    result?: string;
+    /** Error message if status is error */
+    error?: string;
+    /** Number of iterations used */
+    iterations: number;
+    /** Cost in USD */
+    cost: number;
+    /** Files modified during this execution */
+    filesChanged: number;
+    /** Commands run during this execution */
+    commandsRun: number;
+}
+export interface ScheduledTaskState {
+    config: ScheduledTaskConfig;
+    status: TaskStatus;
+    /** Number of completed runs so far */
+    runCount: number;
+    /** Number of failed runs */
+    failCount: number;
+    /** ISO timestamp of last successful run */
+    lastRunAt?: string;
+    /** ISO timestamp of next scheduled run */
+    nextRunAt?: string;
+    /** ISO timestamp when the task was created */
+    createdAt: string;
+    /** ISO timestamp when the task was last updated */
+    updatedAt: string;
+    /** Execution history (most recent first, capped at 100) */
+    history: TaskExecution[];
+    /** Accumulated cost across all runs */
+    totalCost: number;
+    /** Accumulated iterations across all runs */
+    totalIterations: number;
+}
+export interface ScheduledTaskEngine {
+    /** Run a prompt and return structured results */
+    runPrompt(prompt: string, model?: string, workingDir?: string): Promise<{
+        text: string;
+        inputTokens: number;
+        outputTokens: number;
+        cost: number;
+        filesChanged: number;
+        commandsRun: number;
+        iterations: number;
+        error?: string;
+    }>;
+}
+export declare class ScheduledTaskManager {
+    private tasks;
+    private timers;
+    private engine;
+    private shuttingDown;
+    constructor(engine?: ScheduledTaskEngine);
+    /** Set or replace the execution engine */
+    setEngine(engine: ScheduledTaskEngine): void;
+    /**
+     * Schedule a new recurring task.
+     * Returns the full task state including its generated ID.
+     */
+    scheduleTask(config: Omit<ScheduledTaskConfig, 'id'> & {
+        id?: string;
+    }): ScheduledTaskState;
+    /** Cancel a scheduled task permanently */
+    cancelTask(taskId: string): boolean;
+    /** List all tasks, optionally filtered by status */
+    listTasks(status?: TaskStatus): ScheduledTaskState[];
+    /** Temporarily pause a task */
+    pauseTask(taskId: string): boolean;
+    /** Resume a paused task */
+    resumeTask(taskId: string): boolean;
+    /** Get execution status and history for a task */
+    getTaskStatus(taskId: string): ScheduledTaskState | undefined;
+    /** Update a task's configuration (resets timer) */
+    updateTask(taskId: string, updates: Partial<Omit<ScheduledTaskConfig, 'id'>>): boolean;
+    /** Delete a task entirely (removes from memory and persistence) */
+    deleteTask(taskId: string): boolean;
+    /** Manually trigger a task run (outside its schedule) */
+    runTaskNow(taskId: string): Promise<TaskExecution | null>;
+    /** Pause all scheduled tasks */
+    pauseAll(): number;
+    /** Resume all paused tasks */
+    resumeAll(): number;
+    /** Cancel all tasks */
+    cancelAll(): number;
+    /** Get aggregate stats across all tasks */
+    getAggregateStats(): {
+        totalTasks: number;
+        activeTasks: number;
+        pausedTasks: number;
+        totalRuns: number;
+        totalFailures: number;
+        totalCost: number;
+    };
+    /** Get recent executions across all tasks, sorted by time (most recent first) */
+    getRecentExecutions(limit?: number): TaskExecution[];
+    /** Gracefully shut down – cancels all timers */
+    shutdown(): void;
+    private scheduleTimer;
+    private clearTimer;
+    private onTimerFire;
+    private executeTask;
+    private intervalToMs;
+    private saveResultToFile;
+    private notifyCompletion;
+    private persistTasks;
+    private loadTasks;
+    private registerShutdownHooks;
+}
+//# sourceMappingURL=scheduled-tasks.d.ts.map