work-agent 0.1.0

package/app/api/config/status/route.ts

@@ -0,0 +1,56 @@
+/**
+ * Configuration Status API
+ *
+ * Returns the current configuration status of the system.
+ * Used to determine if setup is required.
+ */
+
+import { NextResponse } from 'next/server';
+import { loadModelsConfig, PI_CONFIG_DIR } from '@/lib/pi-config';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+	try {
+		const config = loadModelsConfig();
+		const hasProviders = config?.providers && Object.keys(config.providers).length > 0;
+
+		// Check for environment variables (new AI_ prefix and legacy)
+		const hasAiEnvConfig = !!(
+			process.env.AI_PROVIDER && process.env.AI_API_KEY
+		);
+		const hasLegacyEnvKey = !!(
+			process.env.ZHIPU_API_KEY || process.env.ANTHROPIC_API_KEY
+		);
+		const hasEnvApiKey = hasAiEnvConfig || hasLegacyEnvKey;
+
+		// Check if any provider has valid configuration
+		let isConfigured = hasEnvApiKey;
+		if (!isConfigured && hasProviders) {
+			for (const provider of Object.values(config!.providers)) {
+				if (provider.apiKey && provider.baseUrl) {
+					isConfigured = true;
+					break;
+				}
+			}
+		}
+
+		return NextResponse.json({
+			isConfigured,
+			configDir: PI_CONFIG_DIR,
+			hasProviders: hasProviders,
+			hasEnvApiKey,
+			envProvider: process.env.AI_PROVIDER || null,
+			providers: hasProviders
+				? Object.keys(config!.providers)
+				: [],
+		});
+	} catch (error) {
+		console.error('[config/status] Error:', error);
+		return NextResponse.json(
+			{ error: 'Failed to check configuration', isConfigured: false },
+			{ status: 500 }
+		);
+	}
+}

package/app/api/config/test/route.ts

@@ -0,0 +1,212 @@
+/**
+ * Configuration Test API
+ *
+ * Tests the connection to an AI provider.
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+interface TestRequest {
+	providerId: string;
+	baseUrl: string;
+	api: string;
+	apiKey: string;
+	modelId?: string;
+}
+
+/**
+ * POST /api/config/test - Test provider connection
+ */
+export async function POST(request: NextRequest) {
+	try {
+		const body: TestRequest = await request.json();
+		const { providerId, baseUrl, api, apiKey, modelId } = body;
+
+		console.log('[config/test] Testing connection:', {
+			providerId,
+			baseUrl,
+			api,
+			modelId,
+		});
+
+		if (!baseUrl || !api) {
+			return NextResponse.json(
+				{ success: false, error: '缺少必要参数' },
+				{ status: 400 }
+			);
+		}
+
+		// Test connection based on API type
+		let testResult: { success: boolean; message: string };
+
+		if (api === 'openai-completions') {
+			testResult = await testOpenAIConnection(baseUrl, apiKey, modelId);
+		} else if (api === 'anthropic-messages') {
+			testResult = await testAnthropicConnection(baseUrl, apiKey, modelId);
+		} else {
+			return NextResponse.json(
+				{ success: false, error: `不支持的 API 类型: ${api}` },
+				{ status: 400 }
+			);
+		}
+
+		console.log('[config/test] Test result:', testResult);
+
+		if (testResult.success) {
+			return NextResponse.json({
+				success: true,
+				message: testResult.message,
+			});
+		} else {
+			return NextResponse.json(
+				{ success: false, error: testResult.message },
+				{ status: 200 }
+			);
+		}
+	} catch (error) {
+		console.error('[config/test] Error:', error);
+		return NextResponse.json(
+			{ 
+				success: false, 
+				error: error instanceof Error ? error.message : '测试连接失败' 
+			},
+			{ status: 500 }
+		);
+	}
+}
+
+/**
+ * Test OpenAI-compatible API connection
+ */
+async function testOpenAIConnection(
+	baseUrl: string,
+	apiKey: string,
+	modelId?: string
+): Promise<{ success: boolean; message: string }> {
+	try {
+		// For Ollama, try to get model list first
+		if (baseUrl.includes('11434')) {
+			try {
+				const tagsUrl = baseUrl.replace('/v1', '/api/tags');
+				console.log('[config/test] Fetching Ollama models from:', tagsUrl);
+				
+				const tagsResponse = await fetch(tagsUrl, {
+					method: 'GET',
+					headers: {
+						'Content-Type': 'application/json',
+					},
+				});
+
+				if (tagsResponse.ok) {
+					const tagsData = await tagsResponse.json();
+					const models = tagsData.models || [];
+					const modelCount = models.length;
+					
+					if (modelId) {
+						const hasModel = models.some((m: any) => 
+							m.name === modelId || m.name.startsWith(modelId + ':')
+						);
+						if (hasModel) {
+							return { 
+								success: true, 
+								message: `连接成功！找到模型 ${modelId}（共 ${modelCount} 个模型）` 
+							};
+						} else {
+							return { 
+								success: false, 
+								message: `连接成功但未找到模型 ${modelId}（可用模型: ${models.slice(0, 5).map((m: any) => m.name).join(', ')}${modelCount > 5 ? '...' : ''}）` 
+							};
+						}
+					} else {
+						return { 
+							success: true, 
+							message: `连接成功！发现 ${modelCount} 个模型` 
+						};
+					}
+				}
+			} catch (error) {
+				console.log('[config/test] Failed to fetch Ollama models, trying chat completion');
+			}
+		}
+
+		// Try a simple chat completion request
+		const testUrl = `${baseUrl}/chat/completions`;
+		console.log('[config/test] Testing OpenAI endpoint:', testUrl);
+
+		const response = await fetch(testUrl, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				'Authorization': `Bearer ${apiKey}`,
+			},
+			body: JSON.stringify({
+				model: modelId || 'gpt-3.5-turbo',
+				messages: [{ role: 'user', content: 'test' }],
+				max_tokens: 5,
+			}),
+		});
+
+		if (response.ok) {
+			return { success: true, message: '连接成功！API 响应正常' };
+		} else {
+			const errorData = await response.json().catch(() => ({}));
+			const errorMessage = errorData.error?.message || response.statusText;
+			return { 
+				success: false, 
+				message: `API 返回错误 (${response.status}): ${errorMessage}` 
+			};
+		}
+	} catch (error) {
+		return { 
+			success: false, 
+			message: `连接失败: ${error instanceof Error ? error.message : '网络错误'}` 
+		};
+	}
+}
+
+/**
+ * Test Anthropic API connection
+ */
+async function testAnthropicConnection(
+	baseUrl: string,
+	apiKey: string,
+	modelId?: string
+): Promise<{ success: boolean; message: string }> {
+	try {
+		const testUrl = `${baseUrl}/v1/messages`;
+		console.log('[config/test] Testing Anthropic endpoint:', testUrl);
+
+		const response = await fetch(testUrl, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				'x-api-key': apiKey,
+				'anthropic-version': '2023-06-01',
+			},
+			body: JSON.stringify({
+				model: modelId || 'claude-3-5-sonnet-20241022',
+				max_tokens: 10,
+				messages: [{ role: 'user', content: 'test' }],
+			}),
+		});
+
+		if (response.ok) {
+			return { success: true, message: '连接成功！API 响应正常' };
+		} else {
+			const errorData = await response.json().catch(() => ({}));
+			const errorMessage = errorData.error?.message || response.statusText;
+			return { 
+				success: false, 
+				message: `API 返回错误 (${response.status}): ${errorMessage}` 
+			};
+		}
+	} catch (error) {
+		return { 
+			success: false, 
+			message: `连接失败: ${error instanceof Error ? error.message : '网络错误'}` 
+		};
+	}
+}

package/app/api/documents/[id]/route.ts

@@ -0,0 +1,88 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDocument, updateDocument, deleteDocument } from '@/lib/db';
+
+// GET /api/documents/[id] - 获取单个文档
+export async function GET(
+	request: NextRequest,
+	{ params }: { params: Promise<{ id: string }> }
+) {
+	try {
+		const { id } = await params;
+		const document = await getDocument(id);
+
+		if (!document) {
+			return NextResponse.json(
+				{ error: 'Document not found' },
+				{ status: 404 }
+			);
+		}
+
+		return NextResponse.json({ document });
+	} catch (error) {
+		console.error('Failed to get document:', error);
+		return NextResponse.json(
+			{ error: 'Failed to get document' },
+			{ status: 500 }
+		);
+	}
+}
+
+// PUT /api/documents/[id] - 更新文档
+export async function PUT(
+	request: NextRequest,
+	{ params }: { params: Promise<{ id: string }> }
+) {
+	try {
+		const { id } = await params;
+		const body = await request.json();
+		const { title, content, category, tags } = body;
+
+		const document = await updateDocument(id, {
+			title,
+			content,
+			category,
+			tags,
+		});
+
+		if (!document) {
+			return NextResponse.json(
+				{ error: 'Document not found' },
+				{ status: 404 }
+			);
+		}
+
+		return NextResponse.json({ document });
+	} catch (error) {
+		console.error('Failed to update document:', error);
+		return NextResponse.json(
+			{ error: 'Failed to update document' },
+			{ status: 500 }
+		);
+	}
+}
+
+// DELETE /api/documents/[id] - 删除文档
+export async function DELETE(
+	request: NextRequest,
+	{ params }: { params: Promise<{ id: string }> }
+) {
+	try {
+		const { id } = await params;
+		const success = await deleteDocument(id);
+
+		if (!success) {
+			return NextResponse.json(
+				{ error: 'Document not found' },
+				{ status: 404 }
+			);
+		}
+
+		return NextResponse.json({ success: true });
+	} catch (error) {
+		console.error('Failed to delete document:', error);
+		return NextResponse.json(
+			{ error: 'Failed to delete document' },
+			{ status: 500 }
+		);
+	}
+}

package/app/api/documents/route.ts

@@ -0,0 +1,53 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDocuments, createDocument } from '@/lib/db';
+
+// GET /api/documents - 获取文档列表
+export async function GET(request: NextRequest) {
+	try {
+		const searchParams = request.nextUrl.searchParams;
+		const category = searchParams.get('category') || undefined;
+		const author = searchParams.get('author') || undefined;
+		const limit = searchParams.get('limit') ? parseInt(searchParams.get('limit')!) : undefined;
+
+		const documents = await getDocuments({ category, author, limit });
+
+		return NextResponse.json({ documents });
+	} catch (error) {
+		console.error('Failed to get documents:', error);
+		return NextResponse.json(
+			{ error: 'Failed to get documents' },
+			{ status: 500 }
+		);
+	}
+}
+
+// POST /api/documents - 创建新文档
+export async function POST(request: NextRequest) {
+	try {
+		const body = await request.json();
+		const { title, content, category, tags, author } = body;
+
+		if (!title || !author) {
+			return NextResponse.json(
+				{ error: 'Title and author are required' },
+				{ status: 400 }
+			);
+		}
+
+		const document = await createDocument({
+			title,
+			content: content || '',
+			category,
+			tags,
+			author,
+		});
+
+		return NextResponse.json({ document }, { status: 201 });
+	} catch (error) {
+		console.error('Failed to create document:', error);
+		return NextResponse.json(
+			{ error: 'Failed to create document' },
+			{ status: 500 }
+		);
+	}
+}

package/app/api/health/route.ts

@@ -0,0 +1,32 @@
+/**
+ * 健康检查和调度器初始化 API
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { initializeScheduler, isSchedulerInitialized } from '@/lib/scheduler-init';
+
+/**
+ * GET /api/health - 健康检查，同时确保调度器已启动
+ */
+export async function GET(request: NextRequest) {
+	try {
+		// 确保调度器已初始化
+		if (!isSchedulerInitialized()) {
+			await initializeScheduler();
+		}
+
+		return NextResponse.json({
+			status: 'ok',
+			timestamp: new Date().toISOString(),
+			scheduler: 'running',
+		});
+	} catch (error) {
+		return NextResponse.json(
+			{
+				status: 'error',
+				error: error instanceof Error ? error.message : 'Unknown error',
+			},
+			{ status: 500 },
+		);
+	}
+}

package/app/api/knowledge/[id]/route.ts

@@ -0,0 +1,152 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDocument, updateDocument, deleteDocument, updateKnowledgeActive, getUserById } from '@/lib/db';
+import type { KnowledgeType, KnowledgeSourceType } from '@/lib/db';
+
+// GET /api/knowledge/[id] - 获取单个知识
+export async function GET(
+	request: NextRequest,
+	{ params }: { params: Promise<{ id: string }> }
+) {
+	try {
+		const { id } = await params;
+		const document = await getDocument(id);
+
+		if (!document) {
+			return NextResponse.json(
+				{ error: 'Knowledge not found' },
+				{ status: 404 }
+			);
+		}
+
+		return NextResponse.json({ document });
+	} catch (error) {
+		console.error('Failed to get knowledge:', error);
+		return NextResponse.json(
+			{ error: 'Failed to get knowledge' },
+			{ status: 500 }
+		);
+	}
+}
+
+// PUT /api/knowledge/[id] - 更新知识
+export async function PUT(
+	request: NextRequest,
+	{ params }: { params: Promise<{ id: string }> }
+) {
+	try {
+		const { id } = await params;
+		const body = await request.json();
+		const { title, content, category, tags, type, sourceType, isActive } = body;
+
+		const document = await updateDocument(id, {
+			title,
+			content,
+			category,
+			tags,
+			type: type as KnowledgeType,
+			sourceType: sourceType as KnowledgeSourceType,
+			isActive,
+		});
+
+		if (!document) {
+			return NextResponse.json(
+				{ error: 'Knowledge not found' },
+				{ status: 404 }
+			);
+		}
+
+		return NextResponse.json({ document });
+	} catch (error) {
+		console.error('Failed to update knowledge:', error);
+		return NextResponse.json(
+			{ error: 'Failed to update knowledge' },
+			{ status: 500 }
+		);
+	}
+}
+
+// DELETE /api/knowledge/[id] - 删除知识
+// 查询参数: userId, role (admin 可删除任何知识)
+export async function DELETE(
+	request: NextRequest,
+	{ params }: { params: Promise<{ id: string }> }
+) {
+	try {
+		const { id } = await params;
+		const { searchParams } = new URL(request.url);
+		const userId = searchParams.get('userId');
+		const role = searchParams.get('role');
+
+		// 获取知识详情
+		const document = await getDocument(id);
+		if (!document) {
+			return NextResponse.json(
+				{ error: 'Knowledge not found' },
+				{ status: 404 }
+			);
+		}
+
+		// 权限检查：管理员可删除任何知识，普通用户只能删除自己的
+		if (userId && role !== 'admin') {
+			if (document.author !== userId) {
+				return NextResponse.json(
+					{ error: '无权删除此知识' },
+					{ status: 403 }
+				);
+			}
+		}
+
+		const success = await deleteDocument(id);
+
+		if (!success) {
+			return NextResponse.json(
+				{ error: 'Knowledge not found' },
+				{ status: 404 }
+			);
+		}
+
+		return NextResponse.json({ success: true });
+	} catch (error) {
+		console.error('Failed to delete knowledge:', error);
+		return NextResponse.json(
+			{ error: 'Failed to delete knowledge' },
+			{ status: 500 }
+		);
+	}
+}
+
+// PATCH /api/knowledge/[id] - 更新激活状态
+export async function PATCH(
+	request: NextRequest,
+	{ params }: { params: Promise<{ id: string }> }
+) {
+	try {
+		const { id } = await params;
+		const body = await request.json();
+		const { isActive } = body;
+
+		if (isActive === undefined) {
+			return NextResponse.json(
+				{ error: 'isActive is required' },
+				{ status: 400 }
+			);
+		}
+
+		const document = await updateKnowledgeActive(id, isActive);
+
+		if (!document) {
+			return NextResponse.json(
+				{ error: 'Knowledge not found' },
+				{ status: 404 }
+			);
+		}
+
+		return NextResponse.json({ document });
+	} catch (error) {
+		console.error('Failed to update knowledge active status:', error);
+		return NextResponse.json(
+			{ error: 'Failed to update knowledge active status' },
+			{ status: 500 }
+		);
+	}
+}

package/app/api/knowledge/from-session/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { createKnowledgeFromSession } from '@/lib/db';
+
+// POST /api/knowledge/from-session - 从会话创建知识
+export async function POST(request: NextRequest) {
+	try {
+		const body = await request.json();
+		const { sessionId, title, summary } = body;
+
+		if (!sessionId || !summary) {
+			return NextResponse.json(
+				{ error: 'sessionId and summary are required' },
+				{ status: 400 }
+			);
+		}
+
+		const document = await createKnowledgeFromSession(sessionId, summary, title);
+
+		return NextResponse.json({ success: true, document }, { status: 201 });
+	} catch (error) {
+		console.error('Failed to create knowledge from session:', error);
+		return NextResponse.json(
+			{ error: 'Failed to create knowledge from session' },
+			{ status: 500 }
+		);
+	}
+}