Initial commit: TaskPool React panel

- React frontend with route-level code splitting - Backend rebranded from Baihu to TaskPool - DB brand migration script and local compatibility
2026-07-26 08:43:52 +08:00
commit e6956aa001
397 changed files with 73621 additions and 0 deletions
@@ -0,0 +1,242 @@
+package repo
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/fs"
+	"path/filepath"
+	"strings"
+
+	"github.com/engigu/taskpool/internal/constant"
+	"github.com/engigu/taskpool/internal/database"
+	"github.com/engigu/taskpool/internal/models"
+	"github.com/engigu/taskpool/internal/services/relation"
+	"github.com/engigu/taskpool/internal/utils"
+)
+
+// ParseRepoScriptsAndAddCron 扫描仓库目录中的脚本，解析 cron 和环境注释，并注册任务
+func ParseRepoScriptsAndAddCron(taskID string, logWriter io.Writer, forceCommentToTask bool) ([]string, []string) {
+	// 帮助函数：如果提供了 logWriter，则将日志输出到该处
+	log := func(format string, a ...interface{}) {
+		msg := fmt.Sprintf(format, a...)
+		if !strings.HasSuffix(msg, "\n") {
+			msg += "\n"
+		}
+		if logWriter != nil {
+			logWriter.Write([]byte(msg))
+		}
+	}
+
+	var repoTask models.Task
+	res := database.DB.Where("id = ?", taskID).Limit(1).Find(&repoTask)
+	if res.Error != nil || res.RowsAffected == 0 {
+		return nil, nil
+	}
+
+	if repoTask.Type != constant.TaskTypeRepo {
+		return nil, nil
+	}
+
+	var repoCfg models.RepoConfig
+	if err := json.Unmarshal([]byte(repoTask.Config), &repoCfg); err != nil {
+		return nil, nil
+	}
+
+	// 如果命令行强制开启，则覆盖配置
+	if forceCommentToTask {
+		repoCfg.CommentToTask = "true"
+	}
+
+	// 1. 确定解析策略
+	strategy := GetParserStrategy(repoCfg.RepoSource)
+
+	// 目标路径
+	targetPath := repoCfg.TargetPath
+	if targetPath == "" {
+		targetPath = repoTask.WorkDir
+	} else if !filepath.IsAbs(targetPath) {
+		targetPath = filepath.Join(utils.ResolveAbsScriptsDir(), targetPath)
+	}
+	if targetPath == "" {
+		return nil, nil
+	}
+	targetPath = filepath.Clean(targetPath)
+
+	// 获取仓库标识符
+	repoId := utils.GetRepoIdentifier(repoCfg.SourceURL, repoCfg.Branch)
+
+	gitDir := filepath.Join(targetPath, ".git")
+	if !isDir(targetPath) || !pathExists(gitDir) {
+		repoPath := filepath.Join(targetPath, repoId)
+		if pathExists(repoPath) {
+			targetPath = repoPath
+		}
+	}
+
+	if !pathExists(targetPath) {
+		return nil, nil
+	}
+
+	// 同步过程中使用的标签
+	tag := fmt.Sprintf("%s", repoId)
+
+	exts := getValidExtensions(repoCfg.Extensions)
+
+	log("\n----------------------------------------")
+	log("  开始扫描脚本并自动注册定时任务  ")
+	log("----------------------------------------")
+
+	foundSourceIDs := make(map[string]bool)
+	var upsertedIDs []string
+	var deletedIDs []string
+	newTaskCount := 0
+	updateTaskCount := 0
+
+	filepath.WalkDir(targetPath, func(path string, d fs.DirEntry, err error) error {
+		if err != nil || d.IsDir() {
+			return nil
+		}
+
+		if strings.Contains(path, ".git") {
+			return nil
+		}
+
+		ext := filepath.Ext(path)
+		if !strategy.SupportExtension(ext, exts) {
+			return nil
+		}
+
+		// 2. 元数据提取
+		taskName, taskCron := strategy.ExtractMeta(path, ext, repoCfg)
+
+		// 3. 过滤处理
+		relRepoPath, _ := filepath.Rel(targetPath, path)
+		filename := filepath.Base(path)
+		if !strategy.ShouldProcess(relRepoPath, filename, repoCfg) {
+			return nil
+		}
+
+		if taskName != "" && taskCron != "" && repoCfg.AutoAddCron {
+			// 获取脚本相对于数据目录的路径
+			absScriptsDir := utils.ResolveAbsScriptsDir()
+			// absTargetPath, _ := filepath.Abs(targetPath)
+			absPath, _ := filepath.Abs(path)
+
+			// 计算 SourceID: 相对于脚本目录的完整路径，并清洗特殊符号
+			relPath, _ := filepath.Rel(absScriptsDir, absPath)
+			sourceID := sanitizeIdentifier(relPath)
+
+			// 替换绝对路径为代号 $SCRIPTS_DIR$
+			displayPath := path
+			displayWorkDir := targetPath
+			if strings.HasPrefix(absPath, absScriptsDir) {
+				// 命令仅使用文件名，工作目录设置为脚本所在目录
+				displayPath = filepath.Base(path)
+				relDir, _ := filepath.Rel(absScriptsDir, filepath.Dir(absPath))
+				if relDir == "." {
+					displayWorkDir = constant.ScriptsDirPlaceholder
+				} else {
+					displayWorkDir = filepath.ToSlash(filepath.Join(constant.ScriptsDirPlaceholder, relDir))
+				}
+			}
+
+			// 找到任务，进行保存
+			command := getCommandByExt(ext, displayPath)
+			taskID, isNew := upsertRepoTask(&repoTask, sourceID, taskName, command, taskCron, displayWorkDir, tag)
+
+			if isNew {
+				log("[新增] 任务: %s (%s)", taskName, filename)
+				newTaskCount++
+			} else {
+				log("[更新] 任务: %s (%s)", taskName, filename)
+				updateTaskCount++
+			}
+			foundSourceIDs[sourceID] = true
+			upsertedIDs = append(upsertedIDs, taskID)
+		}
+
+		return nil
+	})
+
+	// 清理该仓库下不再存在的旧脚本任务
+	deletedTaskCount := 0
+	var oldTasks []models.Task
+	if err := database.DB.Where("repo_task_id = ?", repoTask.ID).Find(&oldTasks).Error; err == nil {
+		for _, ot := range oldTasks {
+			if !foundSourceIDs[ot.SourceID] {
+				log("[移除] 脚本已不存在，删除对应任务: %s", ot.Name)
+				deletedTaskCount++
+				deletedIDs = append(deletedIDs, ot.ID)
+				
+				// 删除关联
+				relation.DataRelation.CleanRelations(ot.ID, constant.RelationTypeTaskTag)
+				relation.DataRelation.CleanRelations(ot.ID, constant.RelationTypeTaskEnv)
+				
+				database.DB.Unscoped().Where("id = ?", ot.ID).Delete(&models.Task{})
+			}
+		}
+	}
+
+	log("\n扫描完成: [新增 %d] [更新 %d] [移除 %d]", newTaskCount, updateTaskCount, deletedTaskCount)
+	log("----------------------------------------")
+	return upsertedIDs, deletedIDs
+}
+
+// upsertRepoTask 处理来自仓库的任务的创建或更新
+func upsertRepoTask(parentTask *models.Task, sourceID, name, command, cron, workDir, tag string) (string, bool) {
+	defaultTaskConfig := `{"$task_all_envs":true,"$task_concurrency":0}`
+	var existing models.Task
+	tx := database.DB.Where("source_id = ? AND repo_task_id = ?", sourceID, parentTask.ID).Limit(1).Find(&existing)
+
+	if tx.RowsAffected > 0 {
+		// 更新操作
+		existing.Name = name
+		existing.Command = models.BigText(command)
+		existing.Schedule = normalizeCron(cron)
+		existing.Languages = parentTask.Languages
+		existing.SourceID = sourceID
+		existing.RepoTaskID = parentTask.ID
+		existing.WorkDir = workDir
+		// 如果原配置为空或者是 {}，则应用默认配置
+		if string(existing.Config) == "" || string(existing.Config) == "{}" {
+			existing.Config = models.BigText(defaultTaskConfig)
+		}
+		// 默认开启按条数清理30条
+		if existing.CleanConfig == "" {
+			existing.CleanConfig = `{"type":"count","keep":30}`
+		}
+		// 显式白名单模式：只更新脚本核心相关的字段，其他所有字段（如 Enabled, Pin, Remark 等）均不触碰
+		database.DB.Model(&existing).
+			Select("Name", "Command", "Schedule", "WorkDir", "Languages").
+			Updates(&existing)
+		return existing.ID, false
+	} else {
+		// 创建新任务
+		newTask := &models.Task{
+			Name:        name,
+			Command:     models.BigText(command),
+			Schedule:    normalizeCron(cron),
+			Type:        "task",
+			TriggerType: constant.TriggerTypeCron,
+			Tags:        tag,
+			Languages:   parentTask.Languages,
+			Timeout:     parentTask.Timeout,
+			Config:      models.BigText(defaultTaskConfig),
+			Enabled:     utils.BoolPtr(true),
+			WorkDir:     workDir,
+			SourceID:    sourceID,
+			RepoTaskID:  parentTask.ID,
+			CleanConfig: `{"type":"count","keep":30}`,
+		}
+		newTask.ID = utils.GenerateID()
+		database.DB.Create(newTask)
+
+		// 确保将标签同步写入到新的 DataRelation 中
+		if tag != "" {
+			relation.DataRelation.SaveTags(newTask.ID, constant.RelationTypeTaskTag, tag)
+		}
+		
+		return newTask.ID, true
+	}
+}
@@ -0,0 +1,27 @@
+package repo
+
+import (
+	"github.com/engigu/taskpool/internal/models"
+)
+
+// RepoParserStrategy 定义不同仓库解析策略的接口
+type RepoParserStrategy interface {
+	// SupportExtension 判断给定后缀的文件是否应该被处理
+	SupportExtension(ext string, exts []string) bool
+
+	// ShouldProcess 应用白名单/黑名单过滤，决定是否处理该文件
+	ShouldProcess(relRepoPath, filename string, cfg models.RepoConfig) bool
+
+	// ExtractMeta 从脚本文件中提取任务元数据（名称和 cron 表达式）
+	ExtractMeta(path string, ext string, cfg models.RepoConfig) (taskName string, taskCron string)
+}
+
+// GetParserStrategy 根据来源类型返回相应的策略实现
+func GetParserStrategy(sourceType string) RepoParserStrategy {
+	switch sourceType {
+	case "ql":
+		return &QinglongStrategy{}
+	default:
+		return &StandardStrategy{}
+	}
+}
@@ -0,0 +1,71 @@
+package repo
+
+import (
+	"github.com/engigu/taskpool/internal/models"
+	"regexp"
+	"strings"
+)
+
+// QinglongStrategy 实现与青龙兼容的解析逻辑
+type QinglongStrategy struct{}
+
+func (s *QinglongStrategy) SupportExtension(ext string, exts []string) bool {
+	for _, e := range exts {
+		if ext == e {
+			return true
+		}
+	}
+	return false
+}
+
+func (s *QinglongStrategy) ShouldProcess(relRepoPath, filename string, cfg models.RepoConfig) bool {
+	// 只有在显式设置了白名单时才进行白名单校验 (青龙行为)
+	if cfg.WhitelistPaths != "" {
+		if !matchesQLPattern(relRepoPath, filename, cfg.WhitelistPaths) {
+			return false
+		}
+	}
+
+	// 校验黑名单
+	if cfg.Blacklist != "" {
+		if matchesQLPattern(relRepoPath, filename, cfg.Blacklist) {
+			return false
+		}
+	}
+	return true
+}
+
+func (s *QinglongStrategy) ExtractMeta(path string, ext string, cfg models.RepoConfig) (taskName string, taskCron string) {
+	return ExtractScriptMeta(path, ext)
+}
+
+// matchesQLPattern 应用关键字过滤逻辑（正则或包含匹配）
+func matchesQLPattern(rel, filename string, keywordsStr string) bool {
+	if keywordsStr == "" {
+		return false
+	}
+
+	keywords := splitKeywords(keywordsStr)
+	for _, k := range keywords {
+		// 1. 尝试作为正则整体进行匹配，默认不区分大小写 (?i)
+		pattern := k
+		if !strings.HasPrefix(pattern, "(?i)") {
+			pattern = "(?i)" + pattern
+		}
+
+		reg, err := regexp.Compile(pattern)
+		if err == nil {
+			// 优先匹配文件名（解决 ^jd[^_] 这种锚点在相对路径下失效的问题）
+			if reg.MatchString(filename) || reg.MatchString(rel) {
+				return true
+			}
+		} else {
+			// 回退逻辑：全小写包含判断
+			kLower := strings.ToLower(k)
+			if strings.Contains(strings.ToLower(rel), kLower) || strings.Contains(strings.ToLower(filename), kLower) {
+				return true
+			}
+		}
+	}
+	return false
+}
@@ -0,0 +1,31 @@
+package repo
+
+import (
+	"github.com/engigu/taskpool/internal/models"
+)
+
+// StandardStrategy 实现默认的解析逻辑
+type StandardStrategy struct{}
+
+func (s *StandardStrategy) SupportExtension(ext string, exts []string) bool {
+	for _, e := range exts {
+		if ext == e {
+			return true
+		}
+	}
+	return false
+}
+
+func (s *StandardStrategy) ShouldProcess(relRepoPath, filename string, cfg models.RepoConfig) bool {
+	// 标准策略未来可能具有不同的过滤规则
+	// 目前如果提供了白名单/黑名单，则遵循相同的逻辑，但使用更简单的匹配
+	return true
+}
+
+func (s *StandardStrategy) ExtractMeta(path string, ext string, cfg models.RepoConfig) (taskName string, taskCron string) {
+	// 仅在开启兼容 QL 配置时才解析脚本注释
+	if cfg.CommentToTask == "true" {
+		return ExtractScriptMeta(path, ext)
+	}
+	return "", ""
+}
@@ -0,0 +1,251 @@
+package repo
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/engigu/taskpool/internal/utils"
+	"github.com/robfig/cron/v3"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+var (
+	// envRegex 匹配脚本中的环境名称设置，如 Env("名称")
+	envRegex = regexp.MustCompile(`(?i)(?:new[ \t]+)?Env\(['"]?([^'"]+)['"]?\)`)
+	// cronRegex 匹配脚本中的 cron 表达式设置
+	cronRegex = regexp.MustCompile(`(?i)(?:cron[ \t]*[:=][ \t]*['"]?([^'"\r\n]+))|(?:(?:^|[ \t\*\/])(([0-9\*\/\-,L?#]+[ \t]+){4,5}[0-9\*\/\-,L?#]+))`)
+	// cronFormatRegex 用于校验提取出的字符串是否符合 Cron 表达式格式 (5位或6位)
+	cronFormatRegex = regexp.MustCompile(`^(([0-9\*\/\-,L?#]+)[ \t]+){4,5}([0-9\*\/\-,L?#]+)$`)
+)
+
+// ExtractScriptMeta 读取文件以提取任务名称和 cron 表达式
+func ExtractScriptMeta(path string, ext string) (taskName string, taskCron string) {
+	f, err := os.Open(path)
+	if err != nil {
+		return "", ""
+	}
+	defer f.Close()
+
+	scanner := bufio.NewScanner(f)
+	var firstCommentLine string
+	inBlockComment := false
+
+	// 特殊处理：针对当前文件名的 Cron 关联正则表达式 (对标青龙 perl 逻辑)
+	// 寻找类似 "// 0 0 * * * jd_task.js" 的行
+	fileNameEscaped := regexp.QuoteMeta(filepath.Base(path))
+	associatedCronRegex := regexp.MustCompile(fmt.Sprintf(`(?i)(?:^|[ \t\*\//])(([0-9\*\/\-,L?#]+[ \t]+){4,5}[0-9\*\/\-,L?#]+)[ \t,"]+.*%s`, fileNameEscaped))
+
+	for i := 0; i < 15 && scanner.Scan(); i++ { // 限制扫描范围，避免误匹配代码深处的属性
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+
+		// 处理块注释开始/结束
+		if strings.HasPrefix(line, "/*") {
+			inBlockComment = true
+			line = strings.TrimPrefix(line, "/*")
+			line = strings.TrimPrefix(line, "*")
+			line = strings.TrimSpace(line)
+		}
+		if strings.HasSuffix(line, "*/") {
+			inBlockComment = false
+			line = strings.TrimSuffix(line, "*/")
+			line = strings.TrimSpace(line)
+		}
+
+		// 1. 尝试提取任务名称 (优先使用 Env)
+		if taskName == "" {
+			if envMatch := envRegex.FindStringSubmatch(line); len(envMatch) > 1 {
+				taskName = strings.TrimSpace(envMatch[1])
+			} else if strings.Contains(line, "name:") {
+				// 兼容 name: "xxx" 格式
+				nameRegex := regexp.MustCompile(`(?i)name:[ \t]*['"]([^'"]+)['"]`)
+				if nameMatch := nameRegex.FindStringSubmatch(line); len(nameMatch) > 1 {
+					taskName = strings.TrimSpace(nameMatch[1])
+				}
+			}
+		}
+
+		// 如果还没找到名称，且在注释中，记录第一行非空注释作为备选名称
+		if taskName == "" && (inBlockComment || strings.HasPrefix(line, "//") || strings.HasPrefix(line, "*") || strings.HasPrefix(line, "#")) {
+			cleanLine := line
+			if strings.HasPrefix(line, "//") {
+				cleanLine = strings.TrimPrefix(line, "//")
+			} else if strings.HasPrefix(line, "#") {
+				cleanLine = strings.TrimPrefix(line, "#")
+			} else if strings.HasPrefix(line, "*") {
+				cleanLine = strings.TrimPrefix(line, "*")
+			}
+			cleanLine = strings.TrimSpace(cleanLine)
+
+			// 排除掉包含 "Env" 或 "cron" 的行, 且排除掉可能是路径或URL的行
+			if cleanLine != "" && !strings.Contains(strings.ToLower(cleanLine), "env") &&
+				!strings.Contains(strings.ToLower(cleanLine), "cron") &&
+				!strings.Contains(cleanLine, "http") &&
+				!strings.Contains(cleanLine, "/") &&
+				firstCommentLine == "" {
+				// 且排除掉纯 cron 表达式
+				if !cronRegex.MatchString(cleanLine) {
+					firstCommentLine = cleanLine
+				}
+			}
+		}
+
+		// 2. 提取 Cron
+		if taskCron == "" {
+			// A. 优先查找关联了当前文件名的 Cron (对标 QL)
+			if assocMatch := associatedCronRegex.FindStringSubmatch(line); len(assocMatch) > 1 {
+				tempCron := strings.Trim(strings.TrimSpace(assocMatch[1]), "\"' \t")
+				if isLikelyCron(tempCron) {
+					taskCron = tempCron
+				}
+			}
+
+			// B. 如果没找到，尝试普通的 cron: "..." 或 cron 表达式
+			if taskCron == "" {
+				if cronMatch := cronRegex.FindStringSubmatch(line); len(cronMatch) > 0 {
+					for _, m := range cronMatch[1:] {
+						if m != "" {
+							tempCron := strings.Trim(strings.TrimSpace(m), "\"' \t")
+							if isLikelyCron(tempCron) {
+								taskCron = tempCron
+								break
+							}
+						}
+					}
+				}
+			}
+		}
+
+		if taskName != "" && taskCron != "" {
+			break
+		}
+	}
+
+	// 如果最后还是没找到 taskName，使用备选名称或文件名
+	if taskName == "" {
+		if firstCommentLine != "" {
+			taskName = firstCommentLine
+		} else {
+			taskName = strings.TrimSuffix(filepath.Base(path), ext)
+		}
+	}
+
+	return taskName, taskCron
+}
+
+// isLikelyCron 校验字符串是否符合 Cron 表达式的格式特征且数值合法
+func isLikelyCron(s string) bool {
+	if !cronFormatRegex.MatchString(s) {
+		return false
+	}
+
+	// 语义校验：确保数值在合法范围内（解决如 JS 数组数字超出 Cron 范围的问题）
+	fields := strings.Fields(s)
+	testCron := s
+	if len(fields) == 5 {
+		testCron = "0 " + s
+	}
+
+	// 使用与面板执行器一致的 Parser 进行校验
+	parser := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)
+	_, err := parser.Parse(testCron)
+	return err == nil
+}
+
+// splitKeywords 按竖线或逗号分割字符串
+func splitKeywords(s string) []string {
+	if s == "" {
+		return nil
+	}
+	var parts []string
+	if strings.Contains(s, "|") {
+		parts = strings.Split(s, "|")
+	} else if strings.Contains(s, ",") {
+		parts = strings.Split(s, ",")
+	} else {
+		parts = []string{s}
+	}
+
+	var res []string
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p != "" {
+			res = append(res, p)
+		}
+	}
+	return res
+}
+
+// getValidExtensions 返回支持的文件扩展名列表，优先考虑自定义扩展名
+func getValidExtensions(customExtensions string) []string {
+	exts := []string{".js", ".py", ".ts", ".sh"}
+	if customExtensions != "" {
+		customExts := splitKeywords(customExtensions)
+		if len(customExts) > 0 {
+			exts = nil
+			for _, e := range customExts {
+				e = strings.TrimSpace(e)
+				if e != "" {
+					if !strings.HasPrefix(e, ".") {
+						e = "." + e
+					}
+					exts = append(exts, e)
+				}
+			}
+		}
+	}
+	return exts
+}
+
+// sanitizeIdentifier 将非字母数字字符替换为下划线
+func sanitizeIdentifier(s string) string {
+	reg := regexp.MustCompile(`[^a-zA-Z0-9]+`)
+	res := reg.ReplaceAllString(s, "_")
+	return strings.ToLower(strings.Trim(res, "_"))
+}
+
+// normalizeCron 确保 cron 表达式具有 6 个字段
+func normalizeCron(cron string) string {
+	fields := strings.Fields(cron)
+	if len(fields) == 5 {
+		return "0 " + cron
+	}
+	return cron
+}
+
+// pathExists 检查路径是否存在
+func pathExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// isDir 检查路径是否为目录
+func isDir(path string) bool {
+	info, err := os.Stat(path)
+	if err != nil {
+		return false
+	}
+	return info.IsDir()
+}
+
+// getCommandByExt 根据文件扩展名返回默认执行命令
+func getCommandByExt(ext, path string) string {
+	quotedPath := utils.QuotePath(path)
+	switch ext {
+	case ".js", ".ts":
+		return fmt.Sprintf("node %s", quotedPath)
+	case ".py":
+		return fmt.Sprintf("python %s", quotedPath)
+	case ".sh":
+		return fmt.Sprintf("bash %s", quotedPath)
+	case ".php":
+		return fmt.Sprintf("php %s", quotedPath)
+	case ".cs":
+		return fmt.Sprintf("dotnet run %s", quotedPath)
+	}
+	return quotedPath
+}