work-agent 0.1.0

package/lib/scheduled-task-tool.ts

@@ -0,0 +1,184 @@
+/**
+ * 创建定时任务工具
+ * 让 AI 可以通过对话创建定时任务
+ */
+
+import { Type } from '@sinclair/typebox';
+import type { ToolDefinition, AgentToolResult, ExtensionContext } from '@mariozechner/pi-coding-agent';
+import { createScheduledTask, createAuditLog } from './db';
+import { getNextRunTime, isValidCronExpression, parseScheduleDescription } from './scheduler';
+import { getCurrentSessionId } from './pi-session';
+
+/**
+ * 创建定时任务工具的参数 Schema
+ */
+const createScheduledTaskSchema = Type.Object({
+	title: Type.String({
+		description: '任务标题，简短描述这个定时任务',
+	}),
+	command: Type.String({
+		description: '要执行的命令',
+	}),
+	schedule: Type.String({
+		description: "调度表达式，可以是自然语言（如'每天早上9点'）或 cron 表达式（如'0 9 * * *'）",
+	}),
+	description: Type.Optional(Type.String({
+		description: '任务详细描述',
+	})),
+});
+
+/**
+ * 创建定时任务工具的详情类型
+ */
+interface CreateScheduledTaskDetails {
+	success: boolean;
+	task?: {
+		id: string;
+		title: string;
+		command: string;
+		scheduleExpression: string;
+		nextRunAt?: string;
+		status: string;
+	};
+	error?: string;
+}
+
+/**
+ * 创建定时任务工具定义
+ */
+export const createScheduledTaskTool: ToolDefinition<typeof createScheduledTaskSchema, CreateScheduledTaskDetails> = {
+	name: 'create_scheduled_task',
+	label: 'Create Scheduled Task',
+	description: `创建一个定时任务，用于在指定时间自动执行命令。
+
+使用场景：
+- 用户要求定时执行某个命令
+- 用户要求周期性执行某个操作
+- 用户说"每天..."、"每周..."、"每小时..."等
+
+调度表达式的常用格式：
+- "每小时" 或 "0 * * * *"
+- "每天早上9点" 或 "0 9 * * *"
+- "每周一早上9点" 或 "0 9 * * 1"
+- "每月1号凌晨" 或 "0 0 1 * *"
+
+你可以直接使用自然语言描述，如"每天早上9点"，系统会自动转换为 cron 表达式。`,
+
+	parameters: createScheduledTaskSchema,
+
+	async execute(
+		toolCallId: string,
+		params: any,
+		signal: AbortSignal | undefined,
+		onUpdate: ((result: AgentToolResult<CreateScheduledTaskDetails>) => void) | undefined,
+		ctx: ExtensionContext
+	): Promise<AgentToolResult<CreateScheduledTaskDetails>> {
+		try {
+			const { title, command, schedule, description } = params;
+
+			// 解析调度表达式
+			let scheduleExpression = schedule;
+			const parsed = parseScheduleDescription(schedule);
+			if (parsed) {
+				scheduleExpression = parsed.expression;
+			}
+
+			// 验证 cron 表达式
+			if (!isValidCronExpression(scheduleExpression)) {
+				const errorResult: AgentToolResult<CreateScheduledTaskDetails> = {
+					content: [
+						{
+							type: 'text',
+							text: `❌ 无效的调度表达式: ${schedule}\n\n支持的格式：'每天早上9点'、'每周一9点'、'0 9 * * *' 等`,
+						},
+					],
+					details: {
+						success: false,
+						error: `无效的调度表达式: ${schedule}`,
+					},
+				};
+				onUpdate?.(errorResult);
+				return errorResult;
+			}
+
+			// 计算下次执行时间
+			const nextRunAt = getNextRunTime(scheduleExpression);
+
+			// 创建定时任务
+			const task = await createScheduledTask({
+				title,
+				description: description || '',
+				command,
+				status: 'active',
+				scheduleType: 'cron',
+				scheduleExpression,
+				nextRunAt: nextRunAt || undefined,
+				createdBy: 'ai-assistant',
+			});
+
+			// 创建审计日志
+			await createAuditLog({
+				action: 'scheduled_task_created',
+				userId: 'ai-assistant',
+				sessionId: getCurrentSessionId() || undefined,
+				details: {
+					taskId: task.id,
+					title,
+					command,
+					scheduleExpression,
+					createdByConversation: true,
+				},
+				status: 'success',
+			});
+
+			const result: AgentToolResult<CreateScheduledTaskDetails> = {
+				content: [
+					{
+						type: 'text',
+						text: `✅ 定时任务已创建成功！
+
+**任务ID:** ${task.id}
+**标题:** ${title}
+**命令:** \`${command}\`
+**调度:** ${scheduleExpression}
+**下次执行:** ${nextRunAt?.toLocaleString('zh-CN') || '待计算'}
+
+你可以在[定时任务](/scheduled-tasks)页面查看和管理这个任务。`,
+					},
+				],
+				details: {
+					success: true,
+					task: {
+						id: task.id,
+						title: task.title,
+						command: task.command,
+						scheduleExpression: task.scheduleExpression,
+						nextRunAt: task.nextRunAt?.toISOString(),
+						status: task.status,
+					},
+				},
+			};
+
+			onUpdate?.(result);
+			return result;
+		} catch (error: any) {
+			console.error('Failed to create scheduled task:', error);
+			const errorResult: AgentToolResult<CreateScheduledTaskDetails> = {
+				content: [
+					{
+						type: 'text',
+						text: `❌ 创建定时任务失败: ${error.message}`,
+					},
+				],
+				details: {
+					success: false,
+					error: error.message,
+				},
+			};
+			onUpdate?.(errorResult);
+			return errorResult;
+		}
+	},
+};
+
+export default createScheduledTaskTool;

package/lib/scheduler-init.ts

@@ -0,0 +1,43 @@
+/**
+ * 调度器初始化模块
+ * 在应用启动时初始化定时任务调度器
+ */
+
+import { startScheduler, initializeScheduledTaskNextRunTimes } from '@/lib/scheduler';
+
+// 标记调度器是否已初始化
+let initialized = false;
+
+/**
+ * 初始化调度器
+ * 此函数应在应用启动时调用一次
+ */
+export async function initializeScheduler(): Promise<void> {
+	if (initialized) {
+		console.log('Scheduler already initialized');
+		return;
+	}
+
+	try {
+		console.log('Initializing scheduler...');
+
+		// 首先初始化所有活动任务的下次执行时间
+		await initializeScheduledTaskNextRunTimes();
+
+		// 启动调度器（每分钟检查一次）
+		startScheduler(60000);
+
+		initialized = true;
+		console.log('Scheduler initialized successfully');
+	} catch (error) {
+		console.error('Failed to initialize scheduler:', error);
+		throw error;
+	}
+}
+
+/**
+ * 获取调度器初始化状态
+ */
+export function isSchedulerInitialized(): boolean {
+	return initialized;
+}

package/lib/scheduler.ts

@@ -0,0 +1,416 @@
+/**
+ * 调度器模块 - 负责定时任务的调度和执行
+ *
+ * 设计理念：
+ * - 定时任务是预定义的命令执行计划
+ * - 每次执行都创建完整的审计日志
+ * - 执行记录与工单系统关联，但不是每次都创建新工单
+ * - 支持通用命令执行，不限于特定类型
+ */
+
+import parser from 'cron-parser';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import {
+	getScheduledTasksDueForExecution,
+	updateScheduledTask,
+	createTaskExecution,
+	updateTaskExecution,
+	createTicket,
+	createAuditLog,
+} from './db';
+import { ScheduledTask } from './db';
+
+const execAsync = promisify(exec);
+
+// 调度器状态
+let schedulerInterval: NodeJS.Timeout | null = null;
+let isRunning = false;
+
+/**
+ * Cron 预设表达式
+ */
+export const CRON_PRESETS = {
+	hourly: {
+		label: '每小时',
+		expression: '0 * * * *',
+		description: '每小时的第0分钟执行',
+	},
+	every_6_hours: {
+		label: '每6小时',
+		expression: '0 */6 * * *',
+		description: '每6小时执行一次',
+	},
+	daily_8am: {
+		label: '每天上午8点',
+		expression: '0 8 * * *',
+		description: '每天早上8点执行',
+	},
+	daily_9am: {
+		label: '每天上午9点',
+		expression: '0 9 * * *',
+		description: '每天早上9点执行',
+	},
+	daily_midnight: {
+		label: '每天凌晨',
+		expression: '0 0 * * *',
+		description: '每天凌晨执行',
+	},
+	weekly_monday_9am: {
+		label: '每周一早上9点',
+		expression: '0 9 * * 1',
+		description: '每周一早上9点执行',
+	},
+	weekly_friday_6pm: {
+		label: '每周五下午6点',
+		expression: '0 18 * * 5',
+		description: '每周五下午6点执行',
+	},
+	monthly_1st_midnight: {
+		label: '每月1号凌晨',
+		expression: '0 0 1 * *',
+		description: '每月1号凌晨执行',
+	},
+	monthly_15th_9am: {
+		label: '每月15号上午9点',
+		expression: '0 9 15 * *',
+		description: '每月15号上午9点执行',
+	},
+} as const;
+
+export type CronPresetKey = keyof typeof CRON_PRESETS;
+
+/**
+ * 计算 cron 表达式的下次执行时间
+ */
+export function getNextRunTime(cronExpression: string): Date | null {
+	try {
+		const interval = parser.parse(cronExpression);
+		return interval.next().toDate();
+	} catch (error) {
+		console.error('Invalid cron expression:', cronExpression, error);
+		return null;
+	}
+}
+
+/**
+ * 验证 cron 表达式是否有效
+ */
+export function isValidCronExpression(expression: string): boolean {
+	try {
+		parser.parse(expression);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * 解析自然语言调度描述
+ */
+export function parseScheduleDescription(description: string): { expression: string; type: 'cron' } | null {
+	const desc = description.toLowerCase().trim();
+
+	// 每小时
+	if (desc.includes('每小时') || desc.includes('每个小时') || desc.match(/每\s*\d+\s*分钟/)) {
+		return { expression: CRON_PRESETS.hourly.expression, type: 'cron' };
+	}
+
+	// 每天X点
+	const dailyMatch = desc.match(/(?:每天|每日)\s*(上午|下午|早上)?\s*(\d{1,2})\s*点/);
+	if (dailyMatch) {
+		let hour = parseInt(dailyMatch[2]);
+		if (dailyMatch[1] === '下午' && hour !== 12) hour += 12;
+		if (dailyMatch[1] === '上午' && hour === 12) hour = 0;
+		if (hour >= 0 && hour <= 23) {
+			return { expression: `0 ${hour} * * *`, type: 'cron' };
+		}
+	}
+
+	// 匹配预设
+	for (const [, preset] of Object.entries(CRON_PRESETS)) {
+		if (desc.includes(preset.label) || desc.includes(preset.description)) {
+			return { expression: preset.expression, type: 'cron' };
+		}
+	}
+
+	// 每周X
+	const weekMatch = desc.match(/每周([一二三四五六日天])\s*(?:早上|上午|下午)?\s*(\d{1,2})?\s*点?/);
+	if (weekMatch) {
+		const dayMap: Record<string, number> = { '一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '日': 0, '天': 0 };
+		const day = dayMap[weekMatch[1]] ?? 1;
+		const hour = weekMatch[2] ? parseInt(weekMatch[2]) : 9;
+		return { expression: `0 ${hour} * * ${day}`, type: 'cron' };
+	}
+
+	// 每月X号
+	const monthlyMatch = desc.match(/(?:每月|每月的)\s*(\d{1,2})号/);
+	if (monthlyMatch) {
+		const day = parseInt(monthlyMatch[1]);
+		if (day >= 1 && day <= 31) {
+			const hourMatch = desc.match(/(\d{1,2})\s*点/);
+			const hour = hourMatch ? parseInt(hourMatch[1]) : 0;
+			return { expression: `0 ${hour} ${day} * *`, type: 'cron' };
+		}
+	}
+
+	// 尝试直接解析为 cron 表达式
+	if (isValidCronExpression(desc)) {
+		return { expression: desc, type: 'cron' };
+	}
+
+	return null;
+}
+
+/**
+ * 从任务中提取命令
+ */
+function extractCommand(task: ScheduledTask): string {
+	// 直接返回 command 字段
+	return task.command;
+}
+
+/**
+ * 执行单个定时任务
+ */
+async function executeScheduledTask(task: ScheduledTask): Promise<void> {
+	console.log(`[scheduler] Executing task: ${task.title} (${task.id})`);
+
+	const startTime = Date.now();
+	const command = extractCommand(task);
+
+	// 创建执行记录
+	const execution = await createTaskExecution({
+		taskId: task.id,
+		status: 'running',
+		startedAt: new Date(),
+	});
+
+	// 创建审计日志 - 任务开始
+	await createAuditLog({
+		action: 'scheduled_task_start',
+		userId: task.createdBy,
+		ticketId: undefined,
+		details: {
+			taskId: task.id,
+			taskTitle: task.title,
+			command,
+			scheduleExpression: task.scheduleExpression,
+		},
+		status: 'success',
+	});
+
+	try {
+		// 执行命令
+		console.log(`[scheduler] Executing command: ${command}`);
+		const { stdout, stderr } = await execAsync(command, {
+			timeout: 60000, // 60秒超时
+			maxBuffer: 1024 * 1024, // 1MB 缓冲
+		});
+
+		const executionTime = Date.now() - startTime;
+		const output = stdout || stderr;
+
+		// 创建工单记录（用于审计追踪）
+		const ticket = await createTicket({
+			type: 'bash-execute',
+			title: `[定时任务] ${task.title}`,
+			description: `由定时任务自动执行\n\n**命令:** \`${command}\`\n**执行时间:** ${executionTime}ms`,
+			status: 'completed',
+			priority: 'medium',
+			command,
+			output,
+			riskLevel: 'medium',
+			approvals: [
+				{
+					id: `auto-${Date.now()}`,
+					approver: 'scheduler',
+					decision: 'approved',
+					comment: '定时任务自动执行',
+					timestamp: new Date(),
+				},
+			],
+			createdBy: 'scheduler',
+			aiGenerated: false,
+		});
+
+		// 更新执行记录为成功
+		await updateTaskExecution(execution.id, {
+			status: 'completed',
+			completedAt: new Date(),
+			ticketId: ticket.id,
+		});
+
+		// 创建审计日志 - 任务完成
+		await createAuditLog({
+			action: 'scheduled_task_complete',
+			userId: task.createdBy,
+			ticketId: ticket.id,
+			details: {
+				taskId: task.id,
+				taskTitle: task.title,
+				command,
+				executionTime,
+				outputLength: output?.length || 0,
+			},
+			status: 'success',
+		});
+
+		console.log(`[scheduler] Task completed: ${task.title}, execution time: ${executionTime}ms`);
+	} catch (error: any) {
+		const executionTime = Date.now() - startTime;
+		const errorMessage = error.message || String(error);
+
+		console.error(`[scheduler] Task failed: ${task.title}`, errorMessage);
+
+		// 更新执行记录为失败
+		await updateTaskExecution(execution.id, {
+			status: 'failed',
+			completedAt: new Date(),
+			errorMessage,
+		});
+
+		// 创建审计日志 - 任务失败
+		await createAuditLog({
+			action: 'scheduled_task_failed',
+			userId: task.createdBy,
+			ticketId: undefined,
+			details: {
+				taskId: task.id,
+				taskTitle: task.title,
+				command,
+				executionTime,
+				error: errorMessage,
+			},
+			status: 'failure',
+		});
+	}
+
+	// 更新任务的下次执行时间
+	const nextRunTime = getNextRunTime(task.scheduleExpression);
+	await updateScheduledTask(task.id, {
+		lastRunAt: new Date(),
+		nextRunAt: nextRunTime || undefined,
+	});
+}
+
+/**
+ * 检查并执行到期的定时任务
+ */
+async function checkAndExecuteDueTasks(): Promise<void> {
+	if (isRunning) {
+		console.log('[scheduler] Already running, skipping this cycle');
+		return;
+	}
+
+	try {
+		isRunning = true;
+		const dueTasks = await getScheduledTasksDueForExecution();
+
+		if (dueTasks.length === 0) {
+			return;
+		}
+
+		console.log(`[scheduler] Found ${dueTasks.length} tasks due for execution`);
+
+		// 串行执行任务
+		for (const task of dueTasks) {
+			try {
+				await executeScheduledTask(task);
+			} catch (error) {
+				console.error(`[scheduler] Error executing task ${task.id}:`, error);
+			}
+		}
+	} catch (error) {
+		console.error('[scheduler] Error in scheduler cycle:', error);
+	} finally {
+		isRunning = false;
+	}
+}
+
+/**
+ * 更新所有活动定时任务的下次执行时间
+ */
+export async function initializeScheduledTaskNextRunTimes(): Promise<void> {
+	const { getScheduledTasks } = await import('./db');
+	const tasks = await getScheduledTasks({ status: 'active' });
+
+	for (const task of tasks) {
+		const nextRunTime = getNextRunTime(task.scheduleExpression);
+		if (nextRunTime) {
+			await updateScheduledTask(task.id, {
+				nextRunAt: nextRunTime,
+			});
+			console.log(`[scheduler] Initialized: ${task.title} -> ${nextRunTime.toISOString()}`);
+		}
+	}
+
+	console.log(`[scheduler] Initialized ${tasks.length} active tasks`);
+}
+
+/**
+ * 手动触发执行指定任务
+ */
+export async function triggerTaskExecution(taskId: string): Promise<{ success: boolean; error?: string }> {
+	const { getScheduledTask } = await import('./db');
+	const task = await getScheduledTask(taskId);
+
+	if (!task) {
+		return { success: false, error: '任务不存在' };
+	}
+
+	try {
+		await executeScheduledTask(task);
+		return { success: true };
+	} catch (error: any) {
+		return { success: false, error: error.message };
+	}
+}
+
+/**
+ * 启动调度器
+ */
+export function startScheduler(intervalMs: number = 60000): void {
+	if (schedulerInterval) {
+		console.log('[scheduler] Already running');
+		return;
+	}
+
+	console.log(`[scheduler] Starting with interval ${intervalMs}ms`);
+
+	// 立即执行一次检查
+	checkAndExecuteDueTasks();
+
+	// 设置定时器
+	schedulerInterval = setInterval(() => {
+		checkAndExecuteDueTasks();
+	}, intervalMs);
+}
+
+/**
+ * 停止调度器
+ */
+export function stopScheduler(): void {
+	if (schedulerInterval) {
+		clearInterval(schedulerInterval);
+		schedulerInterval = null;
+		console.log('[scheduler] Stopped');
+	}
+}
+
+/**
+ * 获取调度器状态
+ */
+export function getSchedulerStatus(): { running: boolean; interval: number | null } {
+	return {
+		running: schedulerInterval !== null,
+		interval: schedulerInterval ? 60000 : null,
+	};
+}
+
+/**
+ * 手动触发执行检查（用于测试）
+ */
+export async function triggerExecutionCheck(): Promise<void> {
+	await checkAndExecuteDueTasks();
+}