work-agent 0.1.0

package/app/api/skills/[name]/execute/route.ts

@@ -0,0 +1,121 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { tmpdir } from 'os';
+import { createTicket, createAuditLog } from '@/lib/db';
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ name: string }> }
+) {
+  try {
+    const { name } = await params;
+    const body = await request.json();
+    const { scriptName, params: scriptParams } = body;
+
+    if (!scriptName) {
+      return NextResponse.json({ error: 'scriptName is required' }, { status: 400 });
+    }
+
+    const skillPath = join(process.cwd(), '.pi', 'skills', name);
+    const scriptPath = join(skillPath, 'scripts', scriptName);
+
+    if (!existsSync(scriptPath)) {
+      return NextResponse.json({ error: 'Script not found' }, { status: 404 });
+    }
+
+    let scriptContent;
+    try {
+      scriptContent = readFileSync(scriptPath, 'utf-8');
+    } catch {
+      return NextResponse.json({ error: 'Failed to read script' }, { status: 500 });
+    }
+
+    const isModify = scriptContent.includes('分类: 修改操作') || 
+                     scriptContent.includes('modify');
+
+    if (isModify) {
+      const ticket = await createTicket({
+        type: 'skill-script',
+        title: `执行 Skill 脚本: ${name}/${scriptName}`,
+        description: `修改操作需要审批\n\n脚本内容:\n\`\`\`bash\n${scriptContent.slice(0, 500)}\n\`\`\``,
+        status: 'pending',
+        priority: 'medium',
+        skillName: name,
+        scriptContent,
+        scriptPath: `scripts/${scriptName}`,
+        riskLevel: 'medium',
+        approvals: [],
+        createdBy: 'system',
+        aiSessionId: undefined,
+        aiGenerated: true,
+      });
+
+      await createAuditLog({
+        action: 'skill_script_execute_requested',
+        userId: 'system',
+        ticketId: ticket.id,
+        details: { skillName: name, scriptName, operationType: 'modify' },
+        status: 'success',
+      });
+
+      return NextResponse.json({
+        success: true,
+        requiresApproval: true,
+        ticketId: ticket.id,
+        message: '修改操作需要审批，已创建工单',
+        ticketUrl: `/tickets/${ticket.id}`,
+      });
+    }
+
+    const tempDir = join(tmpdir(), `skill-exec-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    const tempScriptPath = join(tempDir, scriptName);
+    
+    writeFileSync(tempScriptPath, scriptContent);
+    execSync(`chmod +x "${tempScriptPath}"`);
+
+    let output = '';
+    let error = '';
+
+    try {
+      output = execSync(`"${tempScriptPath}"`, {
+        encoding: 'utf-8',
+        timeout: 30000,
+        env: {
+          ...process.env,
+          TOKEN: scriptParams?.token || '',
+        },
+      }).toString();
+    } catch (err: unknown) {
+      const execError = err as { stdout?: string; stderr?: string; message?: string };
+      error = execError?.stderr || execError?.message || String(err);
+    } finally {
+      rmSync(tempDir, { recursive: true });
+    }
+
+    await createAuditLog({
+      action: 'skill_script_executed',
+      userId: 'system',
+      details: { 
+        skillName: name, 
+        scriptName, 
+        operationType: 'read_only',
+        outputLength: output.length,
+        hasError: !!error,
+      },
+      status: error ? 'failure' : 'success',
+    });
+
+    return NextResponse.json({
+      success: true,
+      requiresApproval: false,
+      output: output || error,
+      hasError: !!error,
+    });
+  } catch (error) {
+    console.error('Error executing script:', error);
+    return NextResponse.json({ error: 'Failed to execute script' }, { status: 500 });
+  }
+}

package/app/api/skills/[name]/route.ts

@@ -0,0 +1,167 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ name: string }> }
+) {
+  try {
+    const { name } = await params;
+    const searchParams = request.nextUrl.searchParams;
+    const userId = searchParams.get('userId');
+    
+    let skillPath = join(process.cwd(), '.pi', 'skills', name);
+    
+    // 如果提供了 userId，先检查用户目录
+    if (userId) {
+      const userSkillPath = join(process.cwd(), 'data', 'skills', 'users', userId, name);
+      if (existsSync(userSkillPath)) {
+        skillPath = userSkillPath;
+      }
+    } else if (!existsSync(skillPath)) {
+      // 如果没有提供 userId 且系统目录没有，则返回 404
+      return NextResponse.json({ error: 'Skill not found' }, { status: 404 });
+    }
+    
+    const jsonPath = join(skillPath, 'SKILL.json');
+    const mdPath = join(skillPath, 'SKILL.md');
+    const configPath = join(skillPath, 'config.yaml');
+    const scriptsDir = join(skillPath, 'scripts');
+
+    if (!existsSync(skillPath)) {
+      return NextResponse.json({ error: 'Skill not found' }, { status: 404 });
+    }
+
+    let metadata: Record<string, unknown> = {};
+    let readme = '';
+    let config: string | Record<string, unknown> = {};
+    const scripts: Array<{
+      name: string;
+      type: 'read_only' | 'modify';
+      description: string;
+      method: string;
+      path: string;
+    }> = [];
+
+    try {
+      const jsonContent = readFileSync(jsonPath, 'utf-8');
+      metadata = JSON.parse(jsonContent);
+    } catch {}
+
+    try {
+      readme = readFileSync(mdPath, 'utf-8');
+    } catch {}
+
+    try {
+      const yamlContent = readFileSync(configPath, 'utf-8');
+      try {
+        config = JSON.parse(yamlContent);
+      } catch {
+        config = yamlContent;
+      }
+    } catch {}
+
+    if (existsSync(scriptsDir)) {
+      const { readdirSync, statSync } = require('fs');
+      const files = readdirSync(scriptsDir).filter((f: string) => {
+        const fullPath = join(scriptsDir, f);
+        return statSync(fullPath).isFile() && !f.startsWith('.') && !f.endsWith('.sh');
+      });
+
+      scripts.push(...files.map((file: string) => {
+        let type: 'read_only' | 'modify' = 'read_only';
+        let description = '';
+        let method = 'GET';
+        let path = '/';
+
+        try {
+          const content = readFileSync(join(scriptsDir, file), 'utf-8');
+          const lines = content.split('\n').slice(0, 10);
+          
+          for (const line of lines) {
+            if (line.includes('分类:')) {
+              type = line.includes('只读操作') ? 'read_only' : 'modify';
+            }
+            if (line.includes('# ')) {
+              description = line.replace('# ', '').trim();
+            }
+            if (line.includes('API:')) {
+              const match = line.match(/(\w+)\s+(.*)/);
+              if (match) {
+                method = match[1];
+                path = match[2];
+              }
+            }
+          }
+        } catch {}
+
+        return {
+          name: file,
+          type,
+          description,
+          method,
+          path,
+        };
+      }));
+    }
+
+    const isBuiltIn = name === 'generate-api-system';
+    
+    const isUserSkill = skillPath.includes('data/users');
+    const resultPath = isUserSkill 
+      ? skillPath.replace(process.cwd() + '/', '')
+      : `.pi/skills/${name}`;
+
+    return NextResponse.json({
+      ...metadata,
+      readme,
+      config,
+      scripts,
+      isBuiltIn,
+      skillPath: resultPath,
+    });
+  } catch (error) {
+    console.error('Error getting skill:', error);
+    return NextResponse.json({ error: 'Failed to get skill' }, { status: 500 });
+  }
+}
+
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ name: string }> }
+) {
+  try {
+    const { name } = await params;
+    const searchParams = request.nextUrl.searchParams;
+    const userId = searchParams.get('userId');
+
+    if (name === 'generate-api-system') {
+      return NextResponse.json({ error: 'Cannot delete built-in skill' }, { status: 403 });
+    }
+
+    // 先检查内置技能目录
+    let skillPath = join(process.cwd(), '.pi', 'skills', name);
+    let isUserSkill = false;
+
+    // 如果内置技能不存在，或者提供了 userId，则检查用户私有技能目录
+    if (!existsSync(skillPath) || userId) {
+      const userSkillPath = join(process.cwd(), 'data', 'users', userId || '', 'skills', name);
+      if (existsSync(userSkillPath)) {
+        skillPath = userSkillPath;
+        isUserSkill = true;
+      }
+    }
+
+    if (!existsSync(skillPath)) {
+      return NextResponse.json({ error: 'Skill not found' }, { status: 404 });
+    }
+
+    rmSync(skillPath, { recursive: true });
+
+    return NextResponse.json({ success: true, message: `Skill '${name}' has been deleted` });
+  } catch (error) {
+    console.error('Error deleting skill:', error);
+    return NextResponse.json({ error: 'Failed to delete skill' }, { status: 500 });
+  }
+}

package/app/api/skills/create/route.ts

@@ -0,0 +1,65 @@
+/**
+ * 通用Skill创建API
+ *
+ * POST /api/skills/create
+ *
+ * 用于通过API创建通用skill（非Swagger生成）
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { createSkill, detectSkillType } from '../../../../lib/skill-generator';
+import type { CreateSkillRequest } from '../../../../lib/skill-types';
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+
+    // 验证必填字段
+    if (!body.name) {
+      return NextResponse.json({
+        error: 'name is required'
+      }, { status: 400 });
+    }
+
+    if (!body.description) {
+      return NextResponse.json({
+        error: 'description is required'
+      }, { status: 400 });
+    }
+
+    // 构建请求
+    const skillRequest: CreateSkillRequest = {
+      name: body.name,
+      displayName: body.displayName || body.name,
+      description: body.description,
+      type: body.type,
+      knowledge: body.knowledge,
+      commandPatterns: body.commandPatterns,
+      riskConfig: body.riskConfig,
+      examples: body.examples,
+      author: body.author,
+    };
+
+    // 创建skill
+    const result = await createSkill(skillRequest);
+
+    if (!result.success) {
+      return NextResponse.json({
+        error: result.error
+      }, { status: 409 }); // 409 Conflict - resource already exists
+    }
+
+    return NextResponse.json({
+      success: true,
+      skillName: result.skillName,
+      type: result.type,
+      path: result.skillPath,
+      files: result.files,
+    });
+  } catch (error) {
+    console.error('Error creating skill:', error);
+    return NextResponse.json({
+      error: 'Failed to create skill'
+    }, { status: 500 });
+  }
+}