praisonai 1.2.2 → 1.2.3

package/dist/cli/commands/run.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Run command - Run an agent with a task
+ */
+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.execute = execute;
+const agent_1 = require("../../agent");
+const resolve_1 = require("../config/resolve");
+const json_1 = require("../output/json");
+const pretty = __importStar(require("../output/pretty"));
+const cli_spec_1 = require("../spec/cli-spec");
+const errors_1 = require("../output/errors");
+async function execute(args, options) {
+    const task = args[0];
+    if (!task) {
+        if (options.json || options.output === 'json') {
+            (0, json_1.printError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a task');
+        }
+        else {
+            await pretty.error('Please provide a task');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    // Resolve config with precedence
+    const config = (0, resolve_1.resolveConfig)({
+        configPath: options.config,
+        profile: options.profile,
+        model: options.model,
+        verbose: options.verbose
+    });
+    const startTime = Date.now();
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        // Parse tools if provided
+        const tools = options.tools ? options.tools.split(',').map(t => t.trim()) : [];
+        // Create agent
+        const agent = new agent_1.Agent({
+            name: 'CLI Agent',
+            instructions: 'You are a helpful AI assistant.',
+            llm: config.model,
+            verbose: config.verbose
+        });
+        // Execute task
+        const result = await agent.start(task);
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                result: result,
+                agent: 'CLI Agent',
+                task: task
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else {
+            if (typeof result === 'string') {
+                console.log(result);
+            }
+            else {
+                console.log(JSON.stringify(result, null, 2));
+            }
+        }
+    }
+    catch (error) {
+        const cliError = (0, errors_1.normalizeError)(error);
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(cliError.code, cliError.message, cliError.details));
+        }
+        else {
+            await pretty.error(cliError.message);
+            if (config.verbose && error instanceof Error && error.stack) {
+                await pretty.dim(error.stack);
+            }
+        }
+        process.exit(cliError.exitCode);
+    }
+}

package/dist/cli/commands/sandbox.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CLI command: sandbox
+ * Safe command execution with restrictions
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/sandbox.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * CLI command: sandbox
+ * Safe command execution with restrictions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const sandbox_executor_1 = require("../features/sandbox-executor");
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'exec':
+            await handleExec(args.slice(1), options, isJson);
+            break;
+        case 'check':
+            await handleCheck(args.slice(1), isJson);
+            break;
+        case 'mode':
+            await handleMode(args.slice(1), isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleExec(args, options, isJson) {
+    const command = args.join(' ');
+    if (!command) {
+        console.error('Error: Command is required');
+        process.exit(1);
+    }
+    const mode = options.mode || 'basic';
+    const timeout = options.timeout || 30000;
+    const executor = (0, sandbox_executor_1.createSandboxExecutor)({ mode, timeout });
+    const result = await executor.execute(command);
+    if (isJson) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        if (result.success) {
+            console.log('✓ Command executed successfully');
+            console.log(`Duration: ${result.duration}ms`);
+            if (result.stdout) {
+                console.log('\nOutput:');
+                console.log(result.stdout);
+            }
+        }
+        else {
+            console.error('✗ Command failed');
+            if (result.stderr)
+                console.error(result.stderr);
+        }
+    }
+    if (!result.success)
+        process.exit(result.exitCode || 1);
+}
+async function handleCheck(args, isJson) {
+    const command = args.join(' ');
+    if (!command) {
+        console.error('Error: Command is required');
+        process.exit(1);
+    }
+    const validator = new sandbox_executor_1.CommandValidator();
+    const result = validator.validate(command);
+    if (isJson) {
+        console.log(JSON.stringify({ command, ...result }, null, 2));
+    }
+    else {
+        if (result.valid) {
+            console.log(`✓ Command is allowed: ${command}`);
+        }
+        else {
+            console.log(`✗ Command blocked: ${command}`);
+            console.log(`  Reason: ${result.reason}`);
+        }
+    }
+}
+async function handleMode(args, isJson) {
+    const modes = {
+        disabled: 'No execution allowed',
+        basic: 'Basic validation, blocks dangerous patterns',
+        strict: 'Minimal environment, restricted PATH',
+        'network-isolated': 'No network access (proxy blocked)'
+    };
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, modes }, null, 2));
+    }
+    else {
+        console.log('Sandbox Modes:\n');
+        for (const [mode, desc] of Object.entries(modes)) {
+            console.log(`  ${mode.padEnd(18)} ${desc}`);
+        }
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'sandbox',
+        description: 'Safe command execution with restrictions',
+        subcommands: {
+            exec: 'Execute a command in sandbox',
+            check: 'Check if a command would be allowed',
+            mode: 'List available sandbox modes'
+        },
+        flags: {
+            '--mode': 'Sandbox mode (disabled, basic, strict, network-isolated)',
+            '--timeout': 'Execution timeout in ms (default: 30000)',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts sandbox exec "ls -la"',
+            'praisonai-ts sandbox exec "npm install" --mode strict',
+            'praisonai-ts sandbox check "rm -rf /"',
+            'praisonai-ts sandbox mode'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Sandbox - Safe command execution\n');
+        console.log('Subcommands:');
+        for (const [cmd, desc] of Object.entries(help.subcommands)) {
+            console.log(`  ${cmd.padEnd(12)} ${desc}`);
+        }
+        console.log('\nFlags:');
+        for (const [flag, desc] of Object.entries(help.flags)) {
+            console.log(`  ${flag.padEnd(12)} ${desc}`);
+        }
+        console.log('\nExamples:');
+        for (const ex of help.examples) {
+            console.log(`  ${ex}`);
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * CLI command: scheduler
+ * Agent task scheduling with cron-like patterns
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/scheduler.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * CLI command: scheduler
+ * Agent task scheduling with cron-like patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const scheduler_1 = require("../features/scheduler");
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'create':
+            await handleCreate(args.slice(1), options, isJson);
+            break;
+        case 'list':
+            await handleList(options, isJson);
+            break;
+        case 'run':
+            await handleRun(args.slice(1), options, isJson);
+            break;
+        case 'remove':
+            await handleRemove(args.slice(1), options, isJson);
+            break;
+        case 'enable':
+            await handleEnable(args.slice(1), options, isJson);
+            break;
+        case 'disable':
+            await handleDisable(args.slice(1), options, isJson);
+            break;
+        case 'patterns':
+            await handlePatterns(isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleCreate(args, options, isJson) {
+    const name = args[0];
+    const cron = options.cron;
+    const interval = options.interval;
+    if (!name) {
+        const error = { error: 'Task name is required' };
+        if (isJson) {
+            console.log(JSON.stringify(error));
+        }
+        else {
+            console.error('Error: Task name is required');
+            console.log('Usage: praisonai-ts scheduler create <name> --cron "* * * * *"');
+        }
+        process.exit(1);
+    }
+    if (!cron && !interval) {
+        const error = { error: 'Either --cron or --interval is required' };
+        if (isJson) {
+            console.log(JSON.stringify(error));
+        }
+        else {
+            console.error('Error: Either --cron or --interval is required');
+        }
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const id = scheduler.add({
+        name,
+        cron,
+        interval: interval ? interval * 1000 : undefined,
+        task: async () => {
+            console.log(`Task ${name} executed at ${new Date().toISOString()}`);
+            return { executed: true };
+        }
+    });
+    const result = {
+        success: true,
+        id,
+        name,
+        cron,
+        interval,
+        message: `Task '${name}' created with ID: ${id}`
+    };
+    if (isJson) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(`✓ Task '${name}' created`);
+        console.log(`  ID: ${id}`);
+        if (cron)
+            console.log(`  Cron: ${cron}`);
+        if (interval)
+            console.log(`  Interval: ${interval}s`);
+    }
+}
+async function handleList(options, isJson) {
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const tasks = scheduler.getAllTasks();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, tasks }, null, 2));
+    }
+    else {
+        if (tasks.length === 0) {
+            console.log('No scheduled tasks');
+        }
+        else {
+            console.log('Scheduled Tasks:');
+            for (const task of tasks) {
+                console.log(`  ${task.name} (${task.id})`);
+                console.log(`    Status: ${task.status}`);
+                console.log(`    Enabled: ${task.enabled}`);
+                console.log(`    Run count: ${task.runCount}`);
+                if (task.nextRun)
+                    console.log(`    Next run: ${task.nextRun.toISOString()}`);
+            }
+        }
+    }
+}
+async function handleRun(args, options, isJson) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Task ID is required');
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    try {
+        const result = await scheduler.runNow(id);
+        if (isJson) {
+            console.log(JSON.stringify({ success: true, result }, null, 2));
+        }
+        else {
+            console.log(`✓ Task ${id} executed successfully`);
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+async function handleRemove(args, options, isJson) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Task ID is required');
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const removed = scheduler.remove(id);
+    if (isJson) {
+        console.log(JSON.stringify({ success: removed, id }));
+    }
+    else {
+        if (removed) {
+            console.log(`✓ Task ${id} removed`);
+        }
+        else {
+            console.error(`Task ${id} not found`);
+            process.exit(1);
+        }
+    }
+}
+async function handleEnable(args, options, isJson) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Task ID is required');
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const enabled = scheduler.enable(id);
+    if (isJson) {
+        console.log(JSON.stringify({ success: enabled, id }));
+    }
+    else {
+        console.log(enabled ? `✓ Task ${id} enabled` : `Task ${id} not found`);
+    }
+}
+async function handleDisable(args, options, isJson) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Task ID is required');
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const disabled = scheduler.disable(id);
+    if (isJson) {
+        console.log(JSON.stringify({ success: disabled, id }));
+    }
+    else {
+        console.log(disabled ? `✓ Task ${id} disabled` : `Task ${id} not found`);
+    }
+}
+async function handlePatterns(isJson) {
+    const patterns = {
+        everyMinute: scheduler_1.cronExpressions.everyMinute,
+        every5Minutes: scheduler_1.cronExpressions.every5Minutes,
+        every15Minutes: scheduler_1.cronExpressions.every15Minutes,
+        everyHour: scheduler_1.cronExpressions.everyHour,
+        everyDay: scheduler_1.cronExpressions.everyDay,
+        everyWeek: scheduler_1.cronExpressions.everyWeek,
+        everyMonth: scheduler_1.cronExpressions.everyMonth,
+        weekdays: scheduler_1.cronExpressions.weekdays,
+        weekends: scheduler_1.cronExpressions.weekends
+    };
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, patterns }, null, 2));
+    }
+    else {
+        console.log('Common Cron Patterns:');
+        for (const [name, pattern] of Object.entries(patterns)) {
+            console.log(`  ${name}: ${pattern}`);
+        }
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'scheduler',
+        description: 'Agent task scheduling with cron-like patterns',
+        subcommands: {
+            create: 'Create a scheduled task',
+            list: 'List all scheduled tasks',
+            run: 'Run a task immediately',
+            remove: 'Remove a scheduled task',
+            enable: 'Enable a task',
+            disable: 'Disable a task',
+            patterns: 'Show common cron patterns'
+        },
+        flags: {
+            '--cron': 'Cron expression (e.g., "*/5 * * * *")',
+            '--interval': 'Interval in seconds',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts scheduler create my-task --cron "*/5 * * * *"',
+            'praisonai-ts scheduler create backup --interval 3600',
+            'praisonai-ts scheduler list',
+            'praisonai-ts scheduler run <task-id>',
+            'praisonai-ts scheduler patterns'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Scheduler - Agent task scheduling\n');
+        console.log('Subcommands:');
+        for (const [cmd, desc] of Object.entries(help.subcommands)) {
+            console.log(`  ${cmd.padEnd(12)} ${desc}`);
+        }
+        console.log('\nFlags:');
+        for (const [flag, desc] of Object.entries(help.flags)) {
+            console.log(`  ${flag.padEnd(12)} ${desc}`);
+        }
+        console.log('\nExamples:');
+        for (const ex of help.examples) {
+            console.log(`  ${ex}`);
+        }
+    }
+}

package/dist/cli/commands/session.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Session command - Manage agent sessions
+ */
+export interface SessionOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: SessionOptions): Promise<void>;