agentstudio 0.1.18 → 0.1.21

package/services/schedulerService.js

@@ -0,0 +1,743 @@
+"use strict";
+/**
+ * Scheduler Service
+ *
+ * Manages scheduled task execution using cron-like scheduling.
+ * Supports both interval-based and cron expression-based scheduling.
+ *
+ * Features:
+ * - Concurrent task execution with configurable limit
+ * - Automatic task recovery on startup
+ * - Execution history tracking
+ * - Integration with Agent execution
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeScheduler = initializeScheduler;
+exports.shutdownScheduler = shutdownScheduler;
+exports.enableScheduler = enableScheduler;
+exports.disableScheduler = disableScheduler;
+exports.scheduleTask = scheduleTask;
+exports.unscheduleTask = unscheduleTask;
+exports.rescheduleTask = rescheduleTask;
+exports.executeTask = executeTask;
+exports.stopExecution = stopExecution;
+exports.getRunningExecutions = getRunningExecutions;
+exports.getSchedulerStatus = getSchedulerStatus;
+exports.getActiveTaskIds = getActiveTaskIds;
+const node_cron_1 = __importDefault(require("node-cron"));
+const uuid_1 = require("uuid");
+const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
+const scheduledTasks_js_1 = require("../types/scheduledTasks.js");
+const scheduledTaskStorage_js_1 = require("./scheduledTaskStorage.js");
+const agentStorage_js_1 = require("./agentStorage.js");
+const claudeUtils_js_1 = require("../utils/claudeUtils.js");
+// Scheduler enabled state (independent from initialization)
+let schedulerEnabled = false;
+// ============================================================================
+// Service State
+// ============================================================================
+let isInitialized = false;
+let config = { ...scheduledTasks_js_1.DEFAULT_SCHEDULER_CONFIG };
+const activeJobs = new Map();
+let runningTaskCount = 0;
+const agentStorage = new agentStorage_js_1.AgentStorage();
+const runningExecutions = new Map();
+// ============================================================================
+// Orphaned Task Cleanup
+// ============================================================================
+/**
+ * Clean up orphaned "running" tasks from previous server runs
+ * When the server restarts, any tasks that were "running" are now orphaned
+ * since the actual execution is lost. Mark them as "error" with a clear message.
+ */
+function cleanupOrphanedRunningTasks() {
+    const tasks = (0, scheduledTaskStorage_js_1.loadScheduledTasks)();
+    let cleanedCount = 0;
+    for (const task of tasks) {
+        if (task.lastRunStatus === 'running') {
+            console.info(`[Scheduler] Cleaning up orphaned running task: ${task.id} (${task.name})`);
+            (0, scheduledTaskStorage_js_1.updateTaskRunStatus)(task.id, 'error', 'Server restarted while task was running');
+            cleanedCount++;
+        }
+    }
+    if (cleanedCount > 0) {
+        console.info(`[Scheduler] Cleaned up ${cleanedCount} orphaned running tasks`);
+    }
+}
+// ============================================================================
+// Initialization
+// ============================================================================
+/**
+ * Initialize the scheduler service
+ * Loads all enabled tasks and schedules them
+ */
+function initializeScheduler(customConfig) {
+    if (isInitialized) {
+        console.warn('[Scheduler] Already initialized');
+        return;
+    }
+    if (customConfig) {
+        config = { ...config, ...customConfig };
+    }
+    console.info(`[Scheduler] Initializing with config: maxConcurrent=${config.maxConcurrent}`);
+    // Clean up orphaned "running" tasks from previous server runs
+    cleanupOrphanedRunningTasks();
+    // Load and schedule all enabled tasks
+    const tasks = (0, scheduledTaskStorage_js_1.loadScheduledTasks)();
+    const enabledTasks = tasks.filter(t => t.enabled);
+    console.info(`[Scheduler] Found ${enabledTasks.length} enabled tasks out of ${tasks.length} total`);
+    // Set initial enabled state based on config
+    const shouldEnable = customConfig?.enabled !== undefined ? customConfig.enabled : true;
+    if (shouldEnable) {
+        for (const task of enabledTasks) {
+            scheduleTask(task);
+        }
+        schedulerEnabled = true;
+        console.info('[Scheduler] Initialization complete - scheduler ENABLED');
+    }
+    else {
+        schedulerEnabled = false;
+        console.info('[Scheduler] Initialization complete - scheduler DISABLED (can be enabled via API)');
+    }
+    isInitialized = true;
+}
+/**
+ * Shutdown the scheduler service
+ * Stops all scheduled jobs
+ */
+function shutdownScheduler() {
+    console.info('[Scheduler] Shutting down...');
+    for (const [taskId, activeJob] of activeJobs) {
+        if (activeJob.cronJob) {
+            activeJob.cronJob.stop();
+        }
+        if (activeJob.timeout) {
+            clearTimeout(activeJob.timeout);
+        }
+        console.debug(`[Scheduler] Stopped job for task: ${taskId}`);
+    }
+    activeJobs.clear();
+    isInitialized = false;
+    schedulerEnabled = false;
+    console.info('[Scheduler] Shutdown complete');
+}
+/**
+ * Enable the scheduler (start executing scheduled tasks)
+ */
+function enableScheduler() {
+    if (!isInitialized) {
+        console.warn('[Scheduler] Cannot enable: scheduler not initialized');
+        return;
+    }
+    if (schedulerEnabled) {
+        console.warn('[Scheduler] Already enabled');
+        return;
+    }
+    console.info('[Scheduler] Enabling scheduler...');
+    // Re-schedule all enabled tasks
+    const tasks = (0, scheduledTaskStorage_js_1.loadScheduledTasks)();
+    const enabledTasks = tasks.filter(t => t.enabled);
+    for (const task of enabledTasks) {
+        if (!activeJobs.has(task.id)) {
+            scheduleTask(task);
+        }
+    }
+    schedulerEnabled = true;
+    console.info('[Scheduler] Enabled');
+}
+/**
+ * Disable the scheduler (stop executing scheduled tasks)
+ */
+function disableScheduler() {
+    if (!schedulerEnabled) {
+        console.warn('[Scheduler] Already disabled');
+        return;
+    }
+    console.info('[Scheduler] Disabling scheduler...');
+    // Stop all scheduled jobs but keep them in memory
+    for (const [taskId, activeJob] of activeJobs) {
+        if (activeJob.cronJob) {
+            activeJob.cronJob.stop();
+        }
+        if (activeJob.timeout) {
+            clearTimeout(activeJob.timeout);
+        }
+        console.debug(`[Scheduler] Stopped job for task: ${taskId}`);
+    }
+    activeJobs.clear();
+    schedulerEnabled = false;
+    console.info('[Scheduler] Disabled');
+}
+// ============================================================================
+// Task Scheduling
+// ============================================================================
+/**
+ * Schedule a task for execution
+ */
+function scheduleTask(task) {
+    // Stop existing job if any
+    if (activeJobs.has(task.id)) {
+        unscheduleTask(task.id);
+    }
+    if (!task.enabled) {
+        console.debug(`[Scheduler] Task ${task.id} is disabled, not scheduling`);
+        return false;
+    }
+    try {
+        // Handle one-time execution
+        if (task.schedule.type === 'once' && task.schedule.executeAt) {
+            return scheduleOnceTask(task);
+        }
+        const cronExpression = getCronExpression(task);
+        if (!cronExpression || !node_cron_1.default.validate(cronExpression)) {
+            console.error(`[Scheduler] Invalid cron expression for task ${task.id}: ${cronExpression}`);
+            return false;
+        }
+        const cronJob = node_cron_1.default.schedule(cronExpression, () => {
+            executeTask(task.id).catch(error => {
+                console.error(`[Scheduler] Error executing task ${task.id}:`, error);
+            });
+        });
+        activeJobs.set(task.id, { task, cronJob });
+        // Calculate and update next run time
+        const nextRunAt = getNextRunTime(cronExpression);
+        (0, scheduledTaskStorage_js_1.updateTaskNextRunAt)(task.id, nextRunAt);
+        console.info(`[Scheduler] Scheduled task ${task.id} (${task.name}) with cron: ${cronExpression}`);
+        return true;
+    }
+    catch (error) {
+        console.error(`[Scheduler] Failed to schedule task ${task.id}:`, error);
+        return false;
+    }
+}
+/**
+ * Schedule a one-time task execution
+ */
+function scheduleOnceTask(task) {
+    const executeAt = task.schedule.executeAt;
+    if (!executeAt) {
+        console.error(`[Scheduler] No executeAt time for once task ${task.id}`);
+        return false;
+    }
+    const executeTime = new Date(executeAt).getTime();
+    const now = Date.now();
+    const delay = executeTime - now;
+    if (delay <= 0) {
+        console.warn(`[Scheduler] Task ${task.id} executeAt time is in the past, skipping`);
+        // Disable the task since it's already past
+        Promise.resolve().then(() => __importStar(require('./scheduledTaskStorage.js'))).then(storage => {
+            storage.updateScheduledTask(task.id, { enabled: false });
+        });
+        return false;
+    }
+    // Maximum delay for setTimeout is ~24.8 days (2^31 - 1 ms)
+    const MAX_DELAY = 2147483647;
+    if (delay > MAX_DELAY) {
+        // Schedule a check for later
+        const checkDelay = MAX_DELAY;
+        console.info(`[Scheduler] Task ${task.id} executeAt is too far in future, will re-check later`);
+        const timeout = setTimeout(() => {
+            // Re-schedule when timer fires
+            const currentTask = (0, scheduledTaskStorage_js_1.getScheduledTask)(task.id);
+            if (currentTask && currentTask.enabled) {
+                scheduleOnceTask(currentTask);
+            }
+        }, checkDelay);
+        activeJobs.set(task.id, { task, timeout });
+        (0, scheduledTaskStorage_js_1.updateTaskNextRunAt)(task.id, executeAt);
+        return true;
+    }
+    // Schedule the execution
+    const timeout = setTimeout(async () => {
+        try {
+            await executeTask(task.id);
+        }
+        catch (error) {
+            console.error(`[Scheduler] Error executing one-time task ${task.id}:`, error);
+        }
+        // Disable the task after execution
+        Promise.resolve().then(() => __importStar(require('./scheduledTaskStorage.js'))).then(storage => {
+            storage.updateScheduledTask(task.id, { enabled: false });
+            console.info(`[Scheduler] One-time task ${task.id} executed and disabled`);
+        });
+        // Remove from active jobs
+        activeJobs.delete(task.id);
+    }, delay);
+    activeJobs.set(task.id, { task, timeout });
+    (0, scheduledTaskStorage_js_1.updateTaskNextRunAt)(task.id, executeAt);
+    const delayMinutes = Math.round(delay / 60000);
+    console.info(`[Scheduler] Scheduled one-time task ${task.id} (${task.name}) to execute at ${executeAt} (in ${delayMinutes} minutes)`);
+    return true;
+}
+/**
+ * Unschedule a task
+ */
+function unscheduleTask(taskId) {
+    const activeJob = activeJobs.get(taskId);
+    if (activeJob) {
+        if (activeJob.cronJob) {
+            activeJob.cronJob.stop();
+        }
+        if (activeJob.timeout) {
+            clearTimeout(activeJob.timeout);
+        }
+        activeJobs.delete(taskId);
+        (0, scheduledTaskStorage_js_1.updateTaskNextRunAt)(taskId, undefined);
+        console.info(`[Scheduler] Unscheduled task: ${taskId}`);
+    }
+}
+/**
+ * Reschedule a task (after update)
+ */
+function rescheduleTask(taskId) {
+    const task = (0, scheduledTaskStorage_js_1.getScheduledTask)(taskId);
+    if (!task) {
+        console.warn(`[Scheduler] Task not found for reschedule: ${taskId}`);
+        return false;
+    }
+    return scheduleTask(task);
+}
+// ============================================================================
+// Task Execution
+// ============================================================================
+/**
+ * Execute a scheduled task
+ */
+async function executeTask(taskId) {
+    const task = (0, scheduledTaskStorage_js_1.getScheduledTask)(taskId);
+    if (!task) {
+        console.error(`[Scheduler] Task not found: ${taskId}`);
+        return;
+    }
+    // Check concurrent limit
+    if (runningTaskCount >= config.maxConcurrent) {
+        console.warn(`[Scheduler] Concurrent limit reached (${config.maxConcurrent}), skipping task ${taskId}`);
+        return;
+    }
+    // Check if task is already running (prevent double execution)
+    if (task.lastRunStatus === 'running') {
+        console.warn(`[Scheduler] Task ${taskId} is already running, skipping`);
+        return;
+    }
+    const executionId = `exec_${(0, uuid_1.v4)().slice(0, 8)}`;
+    const startedAt = new Date().toISOString();
+    // Create AbortController for this execution
+    const abortController = new AbortController();
+    // Create execution record (include agentId and projectPath for "continue chat" functionality)
+    const execution = {
+        id: executionId,
+        taskId,
+        startedAt,
+        status: 'running',
+        agentId: task.agentId,
+        projectPath: task.projectPath,
+    };
+    (0, scheduledTaskStorage_js_1.addTaskExecution)(execution);
+    (0, scheduledTaskStorage_js_1.updateTaskRunStatus)(taskId, 'running');
+    runningTaskCount++;
+    // Track running execution
+    runningExecutions.set(executionId, {
+        taskId,
+        executionId,
+        abortController,
+        startedAt,
+    });
+    console.info(`[Scheduler] Executing task ${taskId} (${task.name}), execution: ${executionId}`);
+    try {
+        // Execute the agent with abort signal
+        const result = await executeAgentTask(task, abortController.signal);
+        // Update execution record with logs
+        (0, scheduledTaskStorage_js_1.updateTaskExecution)(taskId, executionId, {
+            status: 'success',
+            completedAt: new Date().toISOString(),
+            responseSummary: result.summary,
+            sessionId: result.sessionId,
+            logs: result.logs,
+        });
+        (0, scheduledTaskStorage_js_1.updateTaskRunStatus)(taskId, 'success');
+        console.info(`[Scheduler] Task ${taskId} completed successfully`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorStack = error instanceof Error ? error.stack : undefined;
+        // Try to get logs from the error context if available
+        const errorLogs = [
+            {
+                timestamp: new Date().toISOString(),
+                level: 'error',
+                type: 'system',
+                message: `Execution failed: ${errorMessage}`,
+                data: { stack: errorStack },
+            }
+        ];
+        (0, scheduledTaskStorage_js_1.updateTaskExecution)(taskId, executionId, {
+            status: 'error',
+            completedAt: new Date().toISOString(),
+            error: errorMessage,
+            errorStack: errorStack,
+            logs: errorLogs,
+        });
+        (0, scheduledTaskStorage_js_1.updateTaskRunStatus)(taskId, 'error', errorMessage);
+        console.error(`[Scheduler] Task ${taskId} failed:`, error);
+    }
+    finally {
+        runningTaskCount--;
+        // Remove from running executions
+        runningExecutions.delete(executionId);
+        // Update next run time (only for recurring tasks)
+        if (task.schedule.type !== 'once') {
+            const cronExpression = getCronExpression(task);
+            if (cronExpression) {
+                const nextRunAt = getNextRunTime(cronExpression);
+                (0, scheduledTaskStorage_js_1.updateTaskNextRunAt)(taskId, nextRunAt);
+            }
+        }
+    }
+}
+/**
+ * Stop a running task execution
+ * @param executionId - The execution ID to stop
+ * @returns true if stopped successfully, false if not found or already completed
+ */
+function stopExecution(executionId) {
+    const execution = runningExecutions.get(executionId);
+    if (!execution) {
+        return { success: false, message: 'Execution not found or already completed' };
+    }
+    console.info(`[Scheduler] Stopping execution: ${executionId} (task: ${execution.taskId})`);
+    // Abort the execution
+    execution.abortController.abort();
+    // Update execution status
+    (0, scheduledTaskStorage_js_1.updateTaskExecution)(execution.taskId, executionId, {
+        status: 'stopped',
+        completedAt: new Date().toISOString(),
+        error: 'Execution stopped by user',
+        logs: [{
+                timestamp: new Date().toISOString(),
+                level: 'warn',
+                type: 'system',
+                message: 'Execution stopped by user',
+            }],
+    });
+    // Update task status
+    (0, scheduledTaskStorage_js_1.updateTaskRunStatus)(execution.taskId, 'stopped', 'Stopped by user');
+    // Remove from running executions
+    runningExecutions.delete(executionId);
+    runningTaskCount--;
+    console.info(`[Scheduler] Execution ${executionId} stopped successfully`);
+    return { success: true, message: 'Execution stopped successfully' };
+}
+/**
+ * Get list of currently running executions
+ */
+function getRunningExecutions() {
+    return Array.from(runningExecutions.values()).map(exec => ({
+        executionId: exec.executionId,
+        taskId: exec.taskId,
+        startedAt: exec.startedAt,
+    }));
+}
+/**
+ * Extract MCP tools from agent's allowedTools configuration
+ * Follows the same logic as frontend's useToolSelector.ts
+ */
+function extractMcpToolsFromAgent(agent) {
+    const mcpTools = [];
+    if (!agent.allowedTools || !Array.isArray(agent.allowedTools)) {
+        return mcpTools;
+    }
+    for (const tool of agent.allowedTools) {
+        if (!tool.enabled)
+            continue;
+        const toolName = tool.name;
+        if (toolName.includes('.') && !toolName.startsWith('mcp__')) {
+            // MCP tool format: serverName.toolName -> mcp__serverName__toolName
+            const [serverName, ...toolNameParts] = toolName.split('.');
+            const mcpToolId = `mcp__${serverName}__${toolNameParts.join('.')}`;
+            mcpTools.push(mcpToolId);
+        }
+        else if (toolName.startsWith('mcp__')) {
+            // Already formatted MCP tool
+            mcpTools.push(toolName);
+        }
+    }
+    return mcpTools;
+}
+/**
+ * Execute agent task using Claude SDK
+ */
+async function executeAgentTask(task, abortSignal) {
+    const logs = [];
+    const addLog = (level, type, message, data) => {
+        logs.push({
+            timestamp: new Date().toISOString(),
+            level,
+            type,
+            message,
+            data,
+        });
+    };
+    // Get agent configuration
+    const agent = agentStorage.getAgent(task.agentId);
+    if (!agent) {
+        addLog('error', 'system', `Agent not found: ${task.agentId}`);
+        throw new Error(`Agent not found: ${task.agentId}`);
+    }
+    addLog('info', 'system', `Using agent: ${agent.name} (${agent.id})`);
+    addLog('info', 'system', `Working directory: ${task.projectPath}`);
+    addLog('info', 'system', `Trigger message: ${task.triggerMessage}`);
+    // Determine the model to use (override or agent default)
+    let modelToUse = agent.model || 'sonnet'; // Default to sonnet if not specified
+    addLog('info', 'system', `Agent default model: ${agent.model || '(not specified)'}`);
+    if (task.modelOverride?.modelId) {
+        modelToUse = task.modelOverride.modelId;
+        addLog('info', 'system', `Model override applied: ${modelToUse} (from task config)`);
+    }
+    addLog('info', 'system', `Final model to use: ${modelToUse}`);
+    // Determine Claude version to use (from task override)
+    // Note: AgentConfig doesn't have claudeVersionId, it's only in AgentSession
+    const claudeVersionToUse = task.modelOverride?.versionId;
+    if (claudeVersionToUse) {
+        addLog('info', 'system', `Using supplier/version: ${claudeVersionToUse}`);
+    }
+    else {
+        addLog('info', 'system', `No supplier/version specified, using default`);
+    }
+    // Extract MCP tools from agent configuration
+    const mcpTools = extractMcpToolsFromAgent(agent);
+    if (mcpTools.length > 0) {
+        addLog('info', 'system', `MCP tools extracted from agent config: ${mcpTools.join(', ')}`);
+    }
+    else {
+        addLog('info', 'system', 'No MCP tools configured for this agent');
+    }
+    // Build query options using the shared utility function
+    // This handles: MCP tools, environment variables, Claude version, A2A integration
+    // NOTE: Scheduled tasks run unattended, so we MUST use bypassPermissions mode
+    addLog('info', 'system', 'Building query options with MCP and environment support...');
+    // Determine permission mode based on model
+    // IMPORTANT: Some models do NOT work in scheduled tasks (unattended mode)
+    // These models require 'default' permission mode with user interaction, but scheduled tasks
+    // run unattended and require 'bypassPermissions' mode
+    const modelLower = modelToUse.toLowerCase();
+    const isGlmModel = modelLower.includes('glm') ||
+        modelLower.includes('zhipu') ||
+        modelLower.includes('chatglm') ||
+        modelLower.startsWith('glm');
+    addLog('info', 'system', `Model compatibility check: model="${modelToUse}", isGlmModel=${isGlmModel}`);
+    if (isGlmModel) {
+        // NOTE: GLM models may have limitations with bypassPermissions mode
+        // Previously this was blocked, but now we allow testing with a warning
+        addLog('warn', 'system', `GLM model detected: ${modelToUse}. GLM models may have compatibility issues with scheduled tasks.`);
+        addLog('warn', 'system', `If this task fails, consider using Claude models (Sonnet, Haiku, Opus) instead.`);
+    }
+    // Additional check: some models might not support bypassPermissions mode
+    // Log a warning for unrecognized model names
+    const knownClaudeModels = ['sonnet', 'haiku', 'opus', 'claude'];
+    const isKnownClaudeModel = knownClaudeModels.some(m => modelLower.includes(m));
+    if (!isKnownClaudeModel) {
+        addLog('warn', 'system', `Warning: Model "${modelToUse}" may not support bypassPermissions mode required for scheduled tasks`);
+    }
+    // For Claude models, use bypassPermissions mode (unattended execution)
+    const permissionMode = 'bypassPermissions';
+    addLog('info', 'system', `Using 'bypassPermissions' mode for Claude model: ${modelToUse}`);
+    const { queryOptions } = await (0, claudeUtils_js_1.buildQueryOptions)(agent, task.projectPath, mcpTools.length > 0 ? mcpTools : undefined, permissionMode, modelToUse, claudeVersionToUse, undefined, // defaultEnv - will be loaded from Claude version config
+    undefined, // userEnv - scheduled tasks don't have user-provided env vars
+    undefined, // sessionIdForAskUser - scheduled tasks don't support user interaction
+    undefined // agentIdForAskUser
+    );
+    // Override maxTurns for scheduled tasks to prevent infinite loops
+    queryOptions.maxTurns = agent.maxTurns || 10;
+    addLog('info', 'system', `Query options built: permissionMode=bypassPermissions, model=${modelToUse}, maxTurns=${queryOptions.maxTurns}`);
+    // Log MCP servers if configured
+    if (queryOptions.mcpServers) {
+        const mcpServerNames = Object.keys(queryOptions.mcpServers);
+        addLog('info', 'system', `MCP servers configured: ${mcpServerNames.join(', ')}`);
+        // Log detailed MCP server config for debugging
+        for (const [serverName, serverConfig] of Object.entries(queryOptions.mcpServers)) {
+            addLog('info', 'system', `  - ${serverName}: ${JSON.stringify(serverConfig)}`);
+        }
+    }
+    else {
+        addLog('warn', 'system', `No MCP servers configured in queryOptions (mcpTools passed: ${mcpTools.join(', ') || 'none'})`);
+    }
+    // Collect response
+    let fullResponse = '';
+    let sessionId;
+    addLog('info', 'system', 'Starting Claude Code query...');
+    try {
+        for await (const message of (0, claude_agent_sdk_1.query)({
+            prompt: task.triggerMessage,
+            options: queryOptions,
+        })) {
+            // Check if execution was aborted
+            if (abortSignal?.aborted) {
+                addLog('warn', 'system', 'Execution aborted by user');
+                throw new Error('Execution aborted by user');
+            }
+            // Capture session ID
+            if (message.session_id && !sessionId) {
+                sessionId = message.session_id;
+                addLog('info', 'system', `Session ID: ${sessionId}`);
+            }
+            // Log different message types
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const block of message.message.content) {
+                    if (block.type === 'text') {
+                        fullResponse += block.text;
+                        addLog('info', 'assistant', block.text);
+                    }
+                    else if (block.type === 'tool_use') {
+                        addLog('info', 'tool_use', `Tool: ${block.name}`, {
+                            tool: block.name,
+                            input: block.input
+                        });
+                    }
+                }
+            }
+            else if (message.type === 'result') {
+                addLog('info', 'result', `Execution completed`, {
+                    costUsd: message.total_cost_usd,
+                    durationMs: message.duration_ms,
+                    numTurns: message.num_turns,
+                });
+            }
+            else if (message.type === 'system') {
+                // System messages might contain error info
+                addLog('info', 'system', `System: ${JSON.stringify(message)}`);
+            }
+        }
+    }
+    catch (queryError) {
+        const errorMessage = queryError instanceof Error ? queryError.message : String(queryError);
+        const errorStack = queryError instanceof Error ? queryError.stack : undefined;
+        addLog('error', 'system', `Query failed: ${errorMessage}`, { stack: errorStack });
+        throw queryError;
+    }
+    addLog('info', 'system', 'Query completed successfully');
+    // Create summary (first 500 chars)
+    const summary = fullResponse.length > 500
+        ? fullResponse.slice(0, 497) + '...'
+        : fullResponse;
+    return { summary, sessionId, logs };
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Convert task schedule to cron expression
+ */
+function getCronExpression(task) {
+    const { schedule } = task;
+    if (schedule.type === 'cron' && schedule.cronExpression) {
+        return schedule.cronExpression;
+    }
+    if (schedule.type === 'interval' && schedule.intervalMinutes) {
+        // Convert interval to cron expression
+        // e.g., 30 minutes -> "*/30 * * * *"
+        if (schedule.intervalMinutes < 60) {
+            return `*/${schedule.intervalMinutes} * * * *`;
+        }
+        else {
+            // For hourly or longer intervals
+            const hours = Math.floor(schedule.intervalMinutes / 60);
+            return `0 */${hours} * * *`;
+        }
+    }
+    return null;
+}
+/**
+ * Calculate next run time from cron expression
+ */
+function getNextRunTime(cronExpression) {
+    try {
+        // node-cron doesn't have a built-in method to get next run time
+        // We'll use a simple calculation based on the cron expression
+        const now = new Date();
+        const parts = cronExpression.split(' ');
+        // For simple cases, calculate approximate next run
+        if (parts[0].startsWith('*/')) {
+            // Interval in minutes
+            const interval = parseInt(parts[0].slice(2));
+            const currentMinutes = now.getMinutes();
+            const nextMinutes = Math.ceil(currentMinutes / interval) * interval;
+            const next = new Date(now);
+            if (nextMinutes >= 60) {
+                next.setHours(next.getHours() + 1);
+                next.setMinutes(nextMinutes - 60);
+            }
+            else if (nextMinutes === currentMinutes) {
+                next.setMinutes(currentMinutes + interval);
+            }
+            else {
+                next.setMinutes(nextMinutes);
+            }
+            next.setSeconds(0);
+            next.setMilliseconds(0);
+            return next.toISOString();
+        }
+        // For other patterns, return undefined (will be calculated on next check)
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// ============================================================================
+// Status Functions
+// ============================================================================
+/**
+ * Get scheduler status
+ */
+function getSchedulerStatus() {
+    return {
+        isInitialized,
+        enabled: schedulerEnabled,
+        config,
+        activeTaskCount: activeJobs.size,
+        runningTaskCount,
+    };
+}
+/**
+ * Get list of active task IDs
+ */
+function getActiveTaskIds() {
+    return Array.from(activeJobs.keys());
+}
+//# sourceMappingURL=schedulerService.js.map