work-agent 0.1.0

package/app/api/scheduled-tasks/[id]/route.ts

@@ -0,0 +1,165 @@
+/**
+ * 定时任务详情 API - GET/PUT/DELETE
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { getScheduledTask, updateScheduledTask, deleteScheduledTask, createAuditLog } from '@/lib/db';
+import { getNextRunTime, isValidCronExpression } from '@/lib/scheduler';
+
+type RouteContext = {
+	params: Promise<{ id: string }>;
+};
+
+/**
+ * GET /api/scheduled-tasks/[id] - 获取单个定时任务
+ */
+export async function GET(request: NextRequest, context: RouteContext) {
+	try {
+		const { id } = await context.params;
+		const task = await getScheduledTask(id);
+
+		if (!task) {
+			return NextResponse.json(
+				{ error: '定时任务不存在' },
+				{ status: 404 },
+			);
+		}
+
+		return NextResponse.json({ task });
+	} catch (error) {
+		return NextResponse.json(
+			{ error: error instanceof Error ? error.message : '获取定时任务失败' },
+			{ status: 500 },
+		);
+	}
+}
+
+/**
+ * PUT /api/scheduled-tasks/[id] - 更新定时任务
+ */
+export async function PUT(request: NextRequest, context: RouteContext) {
+	try {
+		const { id } = await context.params;
+		const body = await request.json();
+		const {
+			title,
+			description,
+			command,
+			status,
+			scheduleType,
+			scheduleExpression,
+			updatedBy,
+		} = body;
+
+		const current = await getScheduledTask(id);
+		if (!current) {
+			return NextResponse.json(
+				{ error: '定时任务不存在' },
+				{ status: 404 },
+			);
+		}
+
+		// 验证必填字段
+		if (!title || !command || !scheduleType || !scheduleExpression) {
+			return NextResponse.json(
+				{ error: '缺少必填字段: title, command, scheduleType, scheduleExpression' },
+				{ status: 400 },
+			);
+		}
+
+		const validScheduleTypes = ['cron', 'interval', 'once'];
+		if (!validScheduleTypes.includes(scheduleType)) {
+			return NextResponse.json(
+				{ error: `无效的调度类型，必须是: ${validScheduleTypes.join(', ')}` },
+				{ status: 400 },
+			);
+		}
+
+		const validStatuses = ['active', 'paused', 'disabled'];
+		if (status && !validStatuses.includes(status)) {
+			return NextResponse.json(
+				{ error: `无效的状态，必须是: ${validStatuses.join(', ')}` },
+				{ status: 400 },
+			);
+		}
+
+		// 验证 cron 表达式
+		if (scheduleType === 'cron' && !isValidCronExpression(scheduleExpression)) {
+			return NextResponse.json(
+				{ error: '无效的 cron 表达式' },
+				{ status: 400 },
+			);
+		}
+
+		// 如果调度表达式改变了，重新计算 nextRunAt
+		let nextRunAt = current.nextRunAt;
+		if (scheduleExpression !== current.scheduleExpression && scheduleType === 'cron') {
+			const calculated = getNextRunTime(scheduleExpression);
+			nextRunAt = calculated || undefined;
+		}
+
+		const updates: any = {
+			title,
+			description: description ?? '',
+			command,
+			scheduleType,
+			scheduleExpression,
+			nextRunAt,
+		};
+
+		if (status) {
+			updates.status = status;
+		}
+
+		const task = await updateScheduledTask(id, updates);
+
+		await createAuditLog({
+			action: 'scheduled_task_updated',
+			userId: updatedBy || 'system',
+			details: { taskId: id, updates },
+			status: 'success',
+		});
+
+		return NextResponse.json({ task });
+	} catch (error) {
+		return NextResponse.json(
+			{ error: error instanceof Error ? error.message : '更新定时任务失败' },
+			{ status: 500 },
+		);
+	}
+}
+
+/**
+ * DELETE /api/scheduled-tasks/[id] - 删除定时任务
+ */
+export async function DELETE(request: NextRequest, context: RouteContext) {
+	try {
+		const { id } = await context.params;
+		const { searchParams } = new URL(request.url);
+		const deletedBy = searchParams.get('deletedBy') || 'system';
+
+		const current = await getScheduledTask(id);
+		if (!current) {
+			return NextResponse.json(
+				{ error: '定时任务不存在' },
+				{ status: 404 },
+			);
+		}
+
+		await deleteScheduledTask(id);
+
+		await createAuditLog({
+			action: 'scheduled_task_deleted',
+			userId: deletedBy,
+			details: { taskId: id, title: current.title },
+			status: 'success',
+		});
+
+		return NextResponse.json({ success: true });
+	} catch (error) {
+		return NextResponse.json(
+			{ error: error instanceof Error ? error.message : '删除定时任务失败' },
+			{ status: 500 },
+		);
+	}
+}

package/app/api/scheduled-tasks/[id]/toggle/route.ts

@@ -0,0 +1,53 @@
+/**
+ * 定时任务启用/禁用 API - POST
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { getScheduledTask, updateScheduledTask, createAuditLog } from '@/lib/db';
+
+type RouteContext = {
+	params: Promise<{ id: string }>;
+};
+
+/**
+ * POST /api/scheduled-tasks/[id]/toggle - 启用/禁用定时任务
+ */
+export async function POST(request: NextRequest, context: RouteContext) {
+	try {
+		const { id } = await context.params;
+		const body = await request.json();
+		const { userId } = body;
+
+		const current = await getScheduledTask(id);
+		if (!current) {
+			return NextResponse.json(
+				{ error: '定时任务不存在' },
+				{ status: 404 },
+			);
+		}
+
+		// 切换状态：active <-> paused
+		const newStatus = current.status === 'active' ? 'paused' : 'active';
+
+		const task = await updateScheduledTask(id, { status: newStatus });
+
+		await createAuditLog({
+			action: 'scheduled_task_toggled',
+			userId: userId || 'system',
+			details: {
+				taskId: id,
+				title: current.title,
+				oldStatus: current.status,
+				newStatus,
+			},
+			status: 'success',
+		});
+
+		return NextResponse.json({ task });
+	} catch (error) {
+		return NextResponse.json(
+			{ error: error instanceof Error ? error.message : '切换定时任务状态失败' },
+			{ status: 500 },
+		);
+	}
+}

package/app/api/scheduled-tasks/route.ts

@@ -0,0 +1,101 @@
+/**
+ * 定时任务 API - GET/POST
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { getScheduledTasks, createScheduledTask, createAuditLog } from '@/lib/db';
+import { getNextRunTime, isValidCronExpression } from '@/lib/scheduler';
+
+/**
+ * GET /api/scheduled-tasks - 获取定时任务列表
+ */
+export async function GET(request: NextRequest) {
+	try {
+		const { searchParams } = new URL(request.url);
+		const filters = {
+			status: searchParams.get('status') ?? undefined,
+			createdBy: searchParams.get('createdBy') ?? undefined,
+			limit: searchParams.get('limit') ? parseInt(searchParams.get('limit')!) : undefined,
+		};
+
+		const tasks = await getScheduledTasks(filters);
+
+		return NextResponse.json({ tasks });
+	} catch (error) {
+		return NextResponse.json(
+			{ error: error instanceof Error ? error.message : '获取定时任务失败' },
+			{ status: 500 },
+		);
+	}
+}
+
+/**
+ * POST /api/scheduled-tasks - 创建新定时任务
+ */
+export async function POST(request: NextRequest) {
+	try {
+		const body = await request.json();
+		const {
+			title,
+			description,
+			command,
+			scheduleType,
+			scheduleExpression,
+			createdBy,
+		} = body;
+
+		// 验证必填字段
+		if (!title || !command || !scheduleType || !scheduleExpression || !createdBy) {
+			return NextResponse.json(
+				{ error: '缺少必填字段: title, command, scheduleType, scheduleExpression, createdBy' },
+				{ status: 400 },
+			);
+		}
+
+		const validScheduleTypes = ['cron', 'interval', 'once'];
+		if (!validScheduleTypes.includes(scheduleType)) {
+			return NextResponse.json(
+				{ error: `无效的调度类型，必须是: ${validScheduleTypes.join(', ')}` },
+				{ status: 400 },
+			);
+		}
+
+		// 验证 cron 表达式
+		if (scheduleType === 'cron' && !isValidCronExpression(scheduleExpression)) {
+			return NextResponse.json(
+				{ error: '无效的 cron 表达式' },
+				{ status: 400 },
+			);
+		}
+
+		// 计算 nextRunAt
+		const nextRunAt = scheduleType === 'cron' ? getNextRunTime(scheduleExpression) : undefined;
+
+		const taskData = {
+			title,
+			description: description ?? '',
+			command,
+			status: 'active' as const,
+			scheduleType,
+			scheduleExpression,
+			nextRunAt: nextRunAt || undefined,
+			createdBy,
+		};
+
+		const task = await createScheduledTask(taskData);
+
+		await createAuditLog({
+			action: 'scheduled_task_created',
+			userId: createdBy,
+			details: { taskId: task.id, title, command, scheduleExpression },
+			status: 'success',
+		});
+
+		return NextResponse.json({ task }, { status: 201 });
+	} catch (error) {
+		return NextResponse.json(
+			{ error: error instanceof Error ? error.message : '创建定时任务失败' },
+			{ status: 500 },
+		);
+	}
+}

package/app/api/sessions/[id]/messages/route.ts

@@ -0,0 +1,212 @@
+/**
+ * Session Messages API - GET
+ *
+ * Returns message history for a session from the JSONL file
+ * Includes chain-of-thought data (thinking and tool executions)
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const PI_SESSIONS_DIR = join(process.cwd(), 'data', 'pi-sessions');
+
+interface ToolExecution {
+	toolName: string;
+	startTime: Date;
+	endTime?: Date;
+	input?: any;
+	output?: any;
+	isError?: boolean;
+}
+
+interface MessageChainOfThought {
+	thinking: string;
+	toolExecutions: ToolExecution[];
+}
+
+interface SessionMessageWithCoT {
+	id: string;
+	role: 'user' | 'assistant' | 'system';
+	content: string;
+	timestamp: string;
+	chainOfThought?: MessageChainOfThought;
+}
+
+interface ToolCall {
+	id: string;
+	name: string;
+	arguments: {
+		command?: string;
+		[key: string]: any;
+	};
+}
+
+interface ContentItem {
+	type: 'text' | 'toolCall' | 'toolResult';
+	text?: string;
+	id?: string;
+	name?: string;
+	arguments?: any;
+	toolCallId?: string;
+	isError?: boolean;
+	content?: ContentItem[];
+}
+
+/**
+ * GET /api/sessions/[id]/messages - Get session messages with chain-of-thought
+ */
+export async function GET(
+	request: NextRequest,
+	{ params }: { params: Promise<{ id: string }> }
+) {
+	try {
+		const { id: sessionId } = await params;
+
+		const sessionFile = join(PI_SESSIONS_DIR, `${sessionId}.jsonl`);
+
+		if (!existsSync(sessionFile)) {
+			return NextResponse.json({ messages: [] });
+		}
+
+		const content = readFileSync(sessionFile, 'utf-8');
+		const lines = content.split('\n').filter(line => line.trim());
+		const messages: SessionMessageWithCoT[] = [];
+
+		// Track chain-of-thought data for assistant messages
+		let currentThinking = '';
+		let currentToolCalls: ToolCall[] = [];
+		let currentToolStartTime: Date | null = null;
+		let pendingAssistantMessage: SessionMessageWithCoT | null = null;
+
+		// Track tool executions by toolCallId to link with results later
+		const pendingToolExecutions = new Map<string, ToolExecution>();
+
+		for (const line of lines) {
+			try {
+				const data = JSON.parse(line);
+
+				switch (data.type) {
+					case 'message': {
+						const msg = data.message;
+						if (!msg) break;
+
+						// Handle toolResult messages
+						if (msg.role === 'toolResult') {
+							const toolCallId = msg.toolCallId;
+							if (toolCallId && pendingToolExecutions.has(toolCallId)) {
+								const toolExecution = pendingToolExecutions.get(toolCallId)!;
+								// Extract output from content
+								const textItems = msg.content?.filter((c: ContentItem) => c.type === 'text') || [];
+								const output = textItems.map((c: ContentItem) => c.text || '').join('');
+
+								toolExecution.output = output;
+								toolExecution.endTime = new Date(msg.timestamp || Date.now());
+								toolExecution.isError = msg.isError;
+							}
+							break;
+						}
+
+						// Finalize previous assistant message before starting a new one
+						if (pendingAssistantMessage && (msg.role === 'user' || msg.role === 'assistant')) {
+							// Add chainOfThought to the pending assistant message
+							if (pendingToolExecutions.size > 0) {
+								pendingAssistantMessage.chainOfThought = {
+									thinking: currentThinking,
+									toolExecutions: Array.from(pendingToolExecutions.values())
+								};
+							}
+							messages.push(pendingAssistantMessage);
+							pendingAssistantMessage = null;
+						}
+
+						// Reset for new assistant message
+						if (msg.role === 'assistant') {
+							currentThinking = '';
+							currentToolCalls = [];
+							currentToolStartTime = new Date(data.timestamp || Date.now());
+							pendingToolExecutions.clear();
+						}
+
+						if (msg.content && Array.isArray(msg.content)) {
+							// Extract text content
+							const textItems = msg.content.filter((c: ContentItem) => c.type === 'text');
+							const text = textItems.map((c: ContentItem) => c.text || '').join('');
+
+							// Extract tool calls from assistant messages
+							const toolCalls = msg.content.filter((c: ContentItem) => c.type === 'toolCall');
+							if (toolCalls.length > 0) {
+								for (const tc of toolCalls) {
+									const toolCallId = tc.id || '';
+									const toolExecution: ToolExecution = {
+										toolName: tc.name || 'unknown',
+										startTime: new Date(data.timestamp || Date.now()),
+										input: tc.arguments || {}
+									};
+									pendingToolExecutions.set(toolCallId, toolExecution);
+									currentToolCalls.push({
+										id: toolCallId,
+										name: tc.name || 'unknown',
+										arguments: tc.arguments || {}
+									});
+								}
+							}
+
+							// Only create messages for user and assistant roles
+							if (msg.role === 'user' || msg.role === 'assistant') {
+								const messageIndex = messages.filter(m => m.role === 'user' || m.role === 'assistant').length;
+								const messageId = `${sessionId}-${messageIndex}`;
+
+								if (msg.role === 'user') {
+									// User messages are added immediately
+									messages.push({
+										id: messageId,
+										role: msg.role,
+										content: text,
+										timestamp: data.timestamp || new Date().toISOString()
+									});
+								} else {
+									// Assistant messages are held pending until tool results are processed
+									pendingAssistantMessage = {
+										id: messageId,
+										role: msg.role,
+										content: text,
+										timestamp: data.timestamp || new Date().toISOString()
+									};
+								}
+							}
+						}
+						break;
+					}
+
+					case 'thinking':
+						if (data.content) {
+							currentThinking += data.content;
+						}
+						break;
+				}
+			} catch (e) {
+				// Skip parse errors
+				console.error('Error parsing line:', e);
+			}
+		}
+
+		// Finalize any pending assistant message at the end
+		if (pendingAssistantMessage) {
+			if (pendingToolExecutions.size > 0) {
+				pendingAssistantMessage.chainOfThought = {
+					thinking: currentThinking,
+					toolExecutions: Array.from(pendingToolExecutions.values())
+				};
+			}
+			messages.push(pendingAssistantMessage);
+		}
+
+		return NextResponse.json({ messages });
+	} catch (error) {
+		return NextResponse.json(
+			{ error: error instanceof Error ? error.message : '获取会话消息失败' },
+			{ status: 500 }
+		);
+	}
+}

package/app/api/sessions/route.ts

@@ -0,0 +1,101 @@
+/**
+ * Sessions API - GET, DELETE
+ *
+ * Lists all available sessions for switching, and delete sessions
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { getAllSessionMetadata, cleanupSession, migrateSessionsFromFiles } from '@/lib/pi-session';
+import { existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+
+// PI sessions directory (same as in pi-session.ts)
+const PI_SESSIONS_DIR = join(process.cwd(), 'data', 'pi-sessions');
+const SESSION_DIR = join(process.cwd(), 'data', 'sessions');
+
+// 启动时迁移历史会话数据
+migrateSessionsFromFiles();
+
+/**
+ * GET /api/sessions - List all sessions
+ */
+export async function GET(request: NextRequest) {
+	try {
+		const { searchParams } = new URL(request.url);
+		const userId = searchParams.get('userId');
+
+		let sessions = getAllSessionMetadata();
+
+		// Filter by userId if provided
+		if (userId) {
+			sessions = sessions.filter(s => s.userId === userId);
+		}
+
+		return NextResponse.json({
+			sessions: sessions.map((s) => ({
+				sessionId: s.sessionId,
+				userId: s.userId,
+				createdAt: s.createdAt,
+				lastAccessedAt: s.lastAccessedAt,
+				messageCount: s.messageCount,
+				title: s.title,
+			})),
+			count: sessions.length,
+		});
+	} catch (error) {
+		return NextResponse.json(
+			{ error: error instanceof Error ? error.message : '获取会话列表失败' },
+			{ status: 500 },
+		);
+	}
+}
+
+/**
+ * DELETE /api/sessions - Delete a session
+ *
+ * Query params:
+ * - sessionId: The session ID to delete
+ */
+export async function DELETE(request: NextRequest) {
+	try {
+		const { searchParams } = new URL(request.url);
+		const sessionId = searchParams.get('sessionId');
+
+		if (!sessionId) {
+			return NextResponse.json(
+				{ error: 'sessionId is required' },
+				{ status: 400 },
+			);
+		}
+
+		// Clean up in-memory session
+		cleanupSession(sessionId);
+
+		// Delete PI session file (JSONL)
+		const piSessionFile = join(PI_SESSIONS_DIR, `${sessionId}.jsonl`);
+		if (existsSync(piSessionFile)) {
+			try {
+				unlinkSync(piSessionFile);
+			} catch (e) {
+				console.error('Failed to delete PI session file:', e);
+			}
+		}
+
+		// Delete metadata file (JSON) - this is done by cleanupSession but double-check
+		const metadataFile = join(SESSION_DIR, `${sessionId}.json`);
+		if (existsSync(metadataFile)) {
+			try {
+				unlinkSync(metadataFile);
+			} catch (e) {
+				console.error('Failed to delete metadata file:', e);
+			}
+		}
+
+		return NextResponse.json({ success: true, sessionId });
+	} catch (error) {
+		return NextResponse.json(
+			{ error: error instanceof Error ? error.message : '删除会话失败' },
+			{ status: 500 },
+		);
+	}
+}

package/app/api/share/file/[id]/route.ts

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDocument } from '@/lib/db';
+
+export async function GET(
+	request: NextRequest,
+	{ params }: { params: Promise<{ id: string }> }
+) {
+	try {
+		const { id } = await params;
+
+		const document = getDocument(id);
+		if (!document) {
+			return NextResponse.json({ error: '文件未找到' }, { status: 404 });
+		}
+
+		if (!document.isPublic) {
+			return NextResponse.json({ error: '此文件未公开分享' }, { status: 403 });
+		}
+
+		if (document.type !== 'file') {
+			return NextResponse.json({ error: '不是文件类型' }, { status: 400 });
+		}
+
+		return NextResponse.json({
+			file: {
+				id: document.id,
+				title: document.title,
+				fileMetadata: document.fileMetadata,
+				isPublic: document.isPublic,
+				createdAt: document.createdAt.toISOString(),
+			},
+		});
+	} catch (error) {
+		console.error('[api/share/file] Error:', error);
+		return NextResponse.json({ error: '服务器错误' }, { status: 500 });
+	}
+}