765 lines
21 KiB
Go
765 lines
21 KiB
Go
package app
|
||
|
||
import (
|
||
"archive/zip"
|
||
"bytes"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"net/http"
|
||
"os"
|
||
"os/exec"
|
||
"path/filepath"
|
||
"strings"
|
||
"time"
|
||
|
||
"git.echol.cn/loser/st/server/global"
|
||
"git.echol.cn/loser/st/server/model/app"
|
||
"go.uber.org/zap"
|
||
"gorm.io/datatypes"
|
||
)
|
||
|
||
// extensionsBaseDir 扩展文件存放根目录（与 router.go 中的静态服务路径一致）
|
||
const extensionsBaseDir = "data/st-core-scripts/scripts/extensions/third-party"
|
||
|
||
// STManifest SillyTavern 扩展 manifest.json 结构
|
||
type STManifest struct {
|
||
DisplayName string `json:"display_name"`
|
||
Loading string `json:"loading_order"` // 加载顺序
|
||
Requires []string `json:"requires"`
|
||
Optional []string `json:"optional"`
|
||
Js string `json:"js"` // 入口 JS 文件
|
||
Css string `json:"css"` // 入口 CSS 文件
|
||
Author string `json:"author"`
|
||
Version string `json:"version"`
|
||
Homepages string `json:"homepages"`
|
||
Repository string `json:"repository"`
|
||
AutoUpdate bool `json:"auto_update"`
|
||
Description string `json:"description"`
|
||
Tags []string `json:"tags"`
|
||
Settings map[string]interface{} `json:"settings"`
|
||
Raw map[string]interface{} `json:"-"` // 原始 JSON 数据
|
||
}
|
||
|
||
// getExtensionDir 获取指定扩展的文件系统目录
|
||
func getExtensionDir(extName string) string {
|
||
return filepath.Join(extensionsBaseDir, extName)
|
||
}
|
||
|
||
// ensureExtensionsBaseDir 确保扩展基础目录存在
|
||
func ensureExtensionsBaseDir() error {
|
||
return os.MkdirAll(extensionsBaseDir, 0755)
|
||
}
|
||
|
||
// parseManifestFile 从扩展目录中读取并解析 manifest.json
|
||
func parseManifestFile(dir string) (*STManifest, error) {
|
||
manifestPath := filepath.Join(dir, "manifest.json")
|
||
data, err := os.ReadFile(manifestPath)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("无法读取 manifest.json: %w", err)
|
||
}
|
||
|
||
var manifest STManifest
|
||
if err := json.Unmarshal(data, &manifest); err != nil {
|
||
return nil, fmt.Errorf("解析 manifest.json 失败: %w", err)
|
||
}
|
||
|
||
// 保留原始 JSON 用于存储到数据库
|
||
var raw map[string]interface{}
|
||
if err := json.Unmarshal(data, &raw); err == nil {
|
||
manifest.Raw = raw
|
||
}
|
||
|
||
return &manifest, nil
|
||
}
|
||
|
||
// parseManifestBytes 从字节数组解析 manifest.json
|
||
func parseManifestBytes(data []byte) (*STManifest, error) {
|
||
var manifest STManifest
|
||
if err := json.Unmarshal(data, &manifest); err != nil {
|
||
return nil, fmt.Errorf("解析 manifest.json 失败: %w", err)
|
||
}
|
||
|
||
var raw map[string]interface{}
|
||
if err := json.Unmarshal(data, &raw); err == nil {
|
||
manifest.Raw = raw
|
||
}
|
||
|
||
return &manifest, nil
|
||
}
|
||
|
||
// InstallExtensionFromGit 从 Git 仓库安装扩展
|
||
func (s *ExtensionService) InstallExtensionFromGit(userID uint, gitURL string, branch string) (*app.AIExtension, error) {
|
||
if branch == "" {
|
||
branch = "main"
|
||
}
|
||
|
||
if err := ensureExtensionsBaseDir(); err != nil {
|
||
return nil, fmt.Errorf("创建扩展目录失败: %w", err)
|
||
}
|
||
|
||
// 从 URL 提取扩展名
|
||
extName := extractRepoName(gitURL)
|
||
if extName == "" {
|
||
return nil, errors.New("无法从 URL 中提取扩展名")
|
||
}
|
||
|
||
extDir := getExtensionDir(extName)
|
||
|
||
// 检查目录是否已存在
|
||
if _, err := os.Stat(extDir); err == nil {
|
||
return nil, fmt.Errorf("扩展 '%s' 已存在，请先删除或使用升级功能", extName)
|
||
}
|
||
|
||
global.GVA_LOG.Info("从 Git 安装扩展",
|
||
zap.String("url", gitURL),
|
||
zap.String("branch", branch),
|
||
zap.String("dir", extDir),
|
||
)
|
||
|
||
// 执行 git clone
|
||
cmd := exec.Command("git", "clone", "--depth", "1", "--branch", branch, gitURL, extDir)
|
||
output, err := cmd.CombinedOutput()
|
||
if err != nil {
|
||
global.GVA_LOG.Error("git clone 失败",
|
||
zap.String("output", string(output)),
|
||
zap.Error(err),
|
||
)
|
||
// 清理失败的目录
|
||
_ = os.RemoveAll(extDir)
|
||
return nil, fmt.Errorf("git clone 失败: %s", strings.TrimSpace(string(output)))
|
||
}
|
||
|
||
global.GVA_LOG.Info("git clone 成功", zap.String("name", extName))
|
||
|
||
// 如果扩展需要构建（有 package.json 的 build 脚本且 dist 不存在），执行构建
|
||
if err := buildExtensionIfNeeded(extDir); err != nil {
|
||
global.GVA_LOG.Warn("扩展构建失败（不影响安装）",
|
||
zap.String("name", extName),
|
||
zap.Error(err),
|
||
)
|
||
}
|
||
|
||
// 创建数据库记录
|
||
return s.createExtensionFromDir(userID, extDir, extName, "git", gitURL, branch)
|
||
}
|
||
|
||
// InstallExtensionFromManifestURL 从 manifest URL 安装扩展
|
||
func (s *ExtensionService) InstallExtensionFromManifestURL(userID uint, manifestURL string, branch string) (*app.AIExtension, error) {
|
||
if err := ensureExtensionsBaseDir(); err != nil {
|
||
return nil, fmt.Errorf("创建扩展目录失败: %w", err)
|
||
}
|
||
|
||
global.GVA_LOG.Info("从 Manifest URL 安装扩展", zap.String("url", manifestURL))
|
||
|
||
// 下载 manifest.json
|
||
manifestData, err := httpGet(manifestURL)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("下载 manifest.json 失败: %w", err)
|
||
}
|
||
|
||
manifest, err := parseManifestBytes(manifestData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 确定扩展名
|
||
extName := sanitizeName(manifest.DisplayName)
|
||
if extName == "" {
|
||
extName = extractNameFromURL(manifestURL)
|
||
}
|
||
if extName == "" {
|
||
return nil, errors.New("无法确定扩展名，manifest 中缺少 display_name")
|
||
}
|
||
|
||
extDir := getExtensionDir(extName)
|
||
if _, err := os.Stat(extDir); err == nil {
|
||
return nil, fmt.Errorf("扩展 '%s' 已存在，请先删除或使用升级功能", extName)
|
||
}
|
||
|
||
if err := os.MkdirAll(extDir, 0755); err != nil {
|
||
return nil, fmt.Errorf("创建扩展目录失败: %w", err)
|
||
}
|
||
|
||
// 保存 manifest.json
|
||
if err := os.WriteFile(filepath.Join(extDir, "manifest.json"), manifestData, 0644); err != nil {
|
||
_ = os.RemoveAll(extDir)
|
||
return nil, fmt.Errorf("保存 manifest.json 失败: %w", err)
|
||
}
|
||
|
||
// 获取 manifest URL 的基础路径
|
||
baseURL := manifestURL[:strings.LastIndex(manifestURL, "/")+1]
|
||
|
||
// 下载 JS 入口文件
|
||
if manifest.Js != "" {
|
||
jsURL := baseURL + manifest.Js
|
||
jsData, err := httpGet(jsURL)
|
||
if err != nil {
|
||
global.GVA_LOG.Warn("下载 JS 文件失败", zap.String("url", jsURL), zap.Error(err))
|
||
} else {
|
||
if err := os.WriteFile(filepath.Join(extDir, manifest.Js), jsData, 0644); err != nil {
|
||
global.GVA_LOG.Warn("保存 JS 文件失败", zap.Error(err))
|
||
}
|
||
}
|
||
}
|
||
|
||
// 下载 CSS 文件
|
||
if manifest.Css != "" {
|
||
cssURL := baseURL + manifest.Css
|
||
cssData, err := httpGet(cssURL)
|
||
if err != nil {
|
||
global.GVA_LOG.Warn("下载 CSS 文件失败", zap.String("url", cssURL), zap.Error(err))
|
||
} else {
|
||
if err := os.WriteFile(filepath.Join(extDir, manifest.Css), cssData, 0644); err != nil {
|
||
global.GVA_LOG.Warn("保存 CSS 文件失败", zap.Error(err))
|
||
}
|
||
}
|
||
}
|
||
|
||
// 创建数据库记录
|
||
return s.createExtensionFromDir(userID, extDir, extName, "url", manifestURL, branch)
|
||
}
|
||
|
||
// ImportExtensionFromZip 从 zip 文件导入扩展
|
||
func (s *ExtensionService) ImportExtensionFromZip(userID uint, filename string, zipData []byte) (*app.AIExtension, error) {
|
||
if err := ensureExtensionsBaseDir(); err != nil {
|
||
return nil, fmt.Errorf("创建扩展目录失败: %w", err)
|
||
}
|
||
|
||
// 先解压到临时目录
|
||
tmpDir, err := os.MkdirTemp("", "ext-import-*")
|
||
if err != nil {
|
||
return nil, fmt.Errorf("创建临时目录失败: %w", err)
|
||
}
|
||
defer os.RemoveAll(tmpDir)
|
||
|
||
// 解压 zip
|
||
if err := extractZip(zipData, tmpDir); err != nil {
|
||
return nil, fmt.Errorf("解压 zip 失败: %w", err)
|
||
}
|
||
|
||
// 找到 manifest.json 所在目录（可能在根目录或子目录）
|
||
manifestDir, err := findManifestDir(tmpDir)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 解析 manifest
|
||
manifest, err := parseManifestFile(manifestDir)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 确定扩展名
|
||
extName := sanitizeName(manifest.DisplayName)
|
||
if extName == "" {
|
||
extName = strings.TrimSuffix(filename, filepath.Ext(filename))
|
||
}
|
||
|
||
extDir := getExtensionDir(extName)
|
||
if _, err := os.Stat(extDir); err == nil {
|
||
return nil, fmt.Errorf("扩展 '%s' 已存在，请先删除或使用升级功能", extName)
|
||
}
|
||
|
||
// 移动文件到目标目录
|
||
if err := os.Rename(manifestDir, extDir); err != nil {
|
||
// 如果跨分区移动失败，回退为复制
|
||
if err := copyDir(manifestDir, extDir); err != nil {
|
||
return nil, fmt.Errorf("移动扩展文件失败: %w", err)
|
||
}
|
||
}
|
||
|
||
global.GVA_LOG.Info("ZIP 扩展导入成功",
|
||
zap.String("name", extName),
|
||
zap.String("dir", extDir),
|
||
)
|
||
|
||
return s.createExtensionFromDir(userID, extDir, extName, "file", "", "")
|
||
}
|
||
|
||
// UpgradeExtensionFromSource 从源地址升级扩展
|
||
func (s *ExtensionService) UpgradeExtensionFromSource(userID, extID uint) (*app.AIExtension, error) {
|
||
ext, err := s.GetExtension(userID, extID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if ext.SourceURL == "" {
|
||
return nil, errors.New("该扩展没有源地址，无法升级")
|
||
}
|
||
|
||
extDir := getExtensionDir(ext.Name)
|
||
|
||
switch ext.InstallSource {
|
||
case "git":
|
||
// Git 扩展：执行 git pull
|
||
global.GVA_LOG.Info("从 Git 升级扩展",
|
||
zap.String("name", ext.Name),
|
||
zap.String("dir", extDir),
|
||
)
|
||
|
||
cmd := exec.Command("git", "-C", extDir, "pull", "--ff-only")
|
||
output, err := cmd.CombinedOutput()
|
||
if err != nil {
|
||
global.GVA_LOG.Error("git pull 失败",
|
||
zap.String("output", string(output)),
|
||
zap.Error(err),
|
||
)
|
||
return nil, fmt.Errorf("git pull 失败: %s", strings.TrimSpace(string(output)))
|
||
}
|
||
|
||
global.GVA_LOG.Info("git pull 成功", zap.String("output", string(output)))
|
||
|
||
// 如果扩展需要构建，执行构建
|
||
if err := buildExtensionIfNeeded(extDir); err != nil {
|
||
global.GVA_LOG.Warn("升级后扩展构建失败",
|
||
zap.String("name", ext.Name),
|
||
zap.Error(err),
|
||
)
|
||
}
|
||
|
||
case "url":
|
||
// URL 扩展：重新下载 manifest 和文件
|
||
manifestData, err := httpGet(ext.SourceURL)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("下载 manifest.json 失败: %w", err)
|
||
}
|
||
|
||
manifest, err := parseManifestBytes(manifestData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 覆盖写入 manifest.json
|
||
if err := os.WriteFile(filepath.Join(extDir, "manifest.json"), manifestData, 0644); err != nil {
|
||
return nil, fmt.Errorf("保存 manifest.json 失败: %w", err)
|
||
}
|
||
|
||
baseURL := ext.SourceURL[:strings.LastIndex(ext.SourceURL, "/")+1]
|
||
|
||
// 重新下载 JS
|
||
if manifest.Js != "" {
|
||
if jsData, err := httpGet(baseURL + manifest.Js); err == nil {
|
||
_ = os.WriteFile(filepath.Join(extDir, manifest.Js), jsData, 0644)
|
||
}
|
||
}
|
||
// 重新下载 CSS
|
||
if manifest.Css != "" {
|
||
if cssData, err := httpGet(baseURL + manifest.Css); err == nil {
|
||
_ = os.WriteFile(filepath.Join(extDir, manifest.Css), cssData, 0644)
|
||
}
|
||
}
|
||
|
||
default:
|
||
return nil, errors.New("该扩展的安装来源不支持升级")
|
||
}
|
||
|
||
// 重新解析 manifest 并更新数据库
|
||
manifest, _ := parseManifestFile(extDir)
|
||
if manifest != nil {
|
||
now := time.Now().Unix()
|
||
updates := map[string]interface{}{
|
||
"last_update_check": &now,
|
||
}
|
||
if manifest.Version != "" {
|
||
updates["version"] = manifest.Version
|
||
}
|
||
if manifest.Description != "" {
|
||
updates["description"] = manifest.Description
|
||
}
|
||
if manifest.Author != "" {
|
||
updates["author"] = manifest.Author
|
||
}
|
||
if manifest.Js != "" {
|
||
updates["script_path"] = manifest.Js
|
||
}
|
||
if manifest.Css != "" {
|
||
updates["style_path"] = manifest.Css
|
||
}
|
||
if manifest.Raw != nil {
|
||
if raw, err := json.Marshal(manifest.Raw); err == nil {
|
||
updates["manifest_data"] = datatypes.JSON(raw)
|
||
}
|
||
}
|
||
global.GVA_DB.Model(&app.AIExtension{}).Where("id = ? AND user_id = ?", extID, userID).Updates(updates)
|
||
}
|
||
|
||
return s.GetExtension(userID, extID)
|
||
}
|
||
|
||
// InstallExtensionFromURL 智能安装：根据 URL 判断是 Git 仓库还是 Manifest URL
|
||
func (s *ExtensionService) InstallExtensionFromURL(userID uint, url string, branch string) (*app.AIExtension, error) {
|
||
if isGitURL(url) {
|
||
return s.InstallExtensionFromGit(userID, url, branch)
|
||
}
|
||
return s.InstallExtensionFromManifestURL(userID, url, branch)
|
||
}
|
||
|
||
// ---------------------
|
||
// 辅助函数
|
||
// ---------------------
|
||
|
||
// createExtensionFromDir 从扩展目录创建数据库记录
|
||
func (s *ExtensionService) createExtensionFromDir(userID uint, extDir, extName, installSource, sourceURL, branch string) (*app.AIExtension, error) {
|
||
manifest, err := parseManifestFile(extDir)
|
||
if err != nil {
|
||
// manifest 解析失败不阻止安装，使用基本信息
|
||
global.GVA_LOG.Warn("解析 manifest 失败，使用基本信息", zap.Error(err))
|
||
manifest = &STManifest{}
|
||
}
|
||
|
||
now := time.Now().Unix()
|
||
|
||
displayName := manifest.DisplayName
|
||
if displayName == "" {
|
||
displayName = extName
|
||
}
|
||
version := manifest.Version
|
||
if version == "" {
|
||
version = "1.0.0"
|
||
}
|
||
|
||
ext := app.AIExtension{
|
||
UserID: userID,
|
||
Name: extName,
|
||
DisplayName: displayName,
|
||
Version: version,
|
||
Author: manifest.Author,
|
||
Description: manifest.Description,
|
||
Homepage: manifest.Homepages,
|
||
Repository: manifest.Repository,
|
||
ExtensionType: "ui",
|
||
ScriptPath: manifest.Js,
|
||
StylePath: manifest.Css,
|
||
InstallSource: installSource,
|
||
SourceURL: sourceURL,
|
||
Branch: branch,
|
||
IsInstalled: true,
|
||
IsEnabled: false,
|
||
InstallDate: &now,
|
||
AutoUpdate: manifest.AutoUpdate,
|
||
}
|
||
|
||
// 存储 manifest 原始数据
|
||
if manifest.Raw != nil {
|
||
if raw, err := json.Marshal(manifest.Raw); err == nil {
|
||
ext.ManifestData = datatypes.JSON(raw)
|
||
}
|
||
}
|
||
|
||
// 存储标签
|
||
if len(manifest.Tags) > 0 {
|
||
if tags, err := json.Marshal(manifest.Tags); err == nil {
|
||
ext.Tags = datatypes.JSON(tags)
|
||
}
|
||
}
|
||
|
||
// 存储默认设置
|
||
if manifest.Settings != nil {
|
||
if settings, err := json.Marshal(manifest.Settings); err == nil {
|
||
ext.Settings = datatypes.JSON(settings)
|
||
}
|
||
}
|
||
|
||
// 存储依赖
|
||
if len(manifest.Requires) > 0 {
|
||
deps := make(map[string]string)
|
||
for _, r := range manifest.Requires {
|
||
deps[r] = "*"
|
||
}
|
||
if depsJSON, err := json.Marshal(deps); err == nil {
|
||
ext.Dependencies = datatypes.JSON(depsJSON)
|
||
}
|
||
}
|
||
|
||
if err := global.GVA_DB.Create(&ext).Error; err != nil {
|
||
return nil, fmt.Errorf("创建扩展记录失败: %w", err)
|
||
}
|
||
|
||
global.GVA_LOG.Info("扩展安装成功",
|
||
zap.String("name", extName),
|
||
zap.String("source", installSource),
|
||
zap.String("version", version),
|
||
)
|
||
|
||
return &ext, nil
|
||
}
|
||
|
||
// buildExtensionIfNeeded 如果扩展目录中有 package.json 且包含 build 脚本，
|
||
// 而 manifest 中指定的入口 JS 文件不存在，则自动执行 npm/pnpm install && build
|
||
func buildExtensionIfNeeded(extDir string) error {
|
||
// 读取 manifest 获取入口文件路径
|
||
manifest, err := parseManifestFile(extDir)
|
||
if err != nil || manifest.Js == "" {
|
||
return nil // 无 manifest 或无 JS 入口，不需要构建
|
||
}
|
||
|
||
// 检查入口 JS 文件是否存在
|
||
jsPath := filepath.Join(extDir, manifest.Js)
|
||
if _, err := os.Stat(jsPath); err == nil {
|
||
return nil // 入口文件已存在，无需构建
|
||
}
|
||
|
||
// 检查 package.json 是否存在
|
||
pkgPath := filepath.Join(extDir, "package.json")
|
||
pkgData, err := os.ReadFile(pkgPath)
|
||
if err != nil {
|
||
return nil // 无 package.json，不是需要构建的扩展
|
||
}
|
||
|
||
// 检查是否有 build 脚本
|
||
var pkg struct {
|
||
Scripts map[string]string `json:"scripts"`
|
||
}
|
||
if err := json.Unmarshal(pkgData, &pkg); err != nil {
|
||
return nil
|
||
}
|
||
if _, hasBuild := pkg.Scripts["build"]; !hasBuild {
|
||
return nil // 没有 build 脚本
|
||
}
|
||
|
||
global.GVA_LOG.Info("扩展需要构建，开始安装依赖及构建",
|
||
zap.String("dir", extDir),
|
||
zap.String("entry", manifest.Js),
|
||
)
|
||
|
||
// 判断使用 pnpm 还是 npm
|
||
var pkgManager string
|
||
if _, err := os.Stat(filepath.Join(extDir, "pnpm-lock.yaml")); err == nil {
|
||
pkgManager = "pnpm"
|
||
} else if _, err := os.Stat(filepath.Join(extDir, "pnpm-workspace.yaml")); err == nil {
|
||
pkgManager = "pnpm"
|
||
} else {
|
||
pkgManager = "npm"
|
||
}
|
||
|
||
// 确认包管理器可用
|
||
if _, err := exec.LookPath(pkgManager); err != nil {
|
||
// 回退到 npm
|
||
pkgManager = "npm"
|
||
if _, err := exec.LookPath("npm"); err != nil {
|
||
return fmt.Errorf("未找到 npm 或 pnpm，无法构建扩展")
|
||
}
|
||
}
|
||
|
||
global.GVA_LOG.Info("使用包管理器", zap.String("manager", pkgManager))
|
||
|
||
// 第一步：安装依赖
|
||
installCmd := exec.Command(pkgManager, "install")
|
||
installCmd.Dir = extDir
|
||
installOutput, err := installCmd.CombinedOutput()
|
||
if err != nil {
|
||
global.GVA_LOG.Error("依赖安装失败",
|
||
zap.String("output", string(installOutput)),
|
||
zap.Error(err),
|
||
)
|
||
return fmt.Errorf("%s install 失败: %s", pkgManager, strings.TrimSpace(string(installOutput)))
|
||
}
|
||
global.GVA_LOG.Info("依赖安装成功", zap.String("manager", pkgManager))
|
||
|
||
// 第二步：执行构建
|
||
buildCmd := exec.Command(pkgManager, "run", "build")
|
||
buildCmd.Dir = extDir
|
||
buildOutput, err := buildCmd.CombinedOutput()
|
||
if err != nil {
|
||
global.GVA_LOG.Error("构建失败",
|
||
zap.String("output", string(buildOutput)),
|
||
zap.Error(err),
|
||
)
|
||
return fmt.Errorf("%s run build 失败: %s", pkgManager, strings.TrimSpace(string(buildOutput)))
|
||
}
|
||
global.GVA_LOG.Info("扩展构建成功", zap.String("dir", extDir))
|
||
|
||
// 验证入口文件是否已生成
|
||
if _, err := os.Stat(jsPath); err != nil {
|
||
return fmt.Errorf("构建完成但入口文件仍不存在: %s", manifest.Js)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// isGitURL 判断 URL 是否为 Git 仓库
|
||
func isGitURL(url string) bool {
|
||
url = strings.ToLower(url)
|
||
if strings.HasSuffix(url, ".git") {
|
||
return true
|
||
}
|
||
if strings.Contains(url, "github.com/") ||
|
||
strings.Contains(url, "gitlab.com/") ||
|
||
strings.Contains(url, "gitee.com/") ||
|
||
strings.Contains(url, "bitbucket.org/") {
|
||
// 排除以 .json 结尾的 URL
|
||
if strings.HasSuffix(url, ".json") {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
// extractRepoName 从 Git URL 提取仓库名
|
||
func extractRepoName(gitURL string) string {
|
||
gitURL = strings.TrimSuffix(gitURL, ".git")
|
||
gitURL = strings.TrimRight(gitURL, "/")
|
||
parts := strings.Split(gitURL, "/")
|
||
if len(parts) == 0 {
|
||
return ""
|
||
}
|
||
return parts[len(parts)-1]
|
||
}
|
||
|
||
// extractNameFromURL 从 URL 路径中提取名称
|
||
func extractNameFromURL(url string) string {
|
||
// 对于 manifest URL：https://example.com/extensions/my-ext/manifest.json
|
||
// 提取上一级目录名
|
||
url = strings.TrimRight(url, "/")
|
||
parts := strings.Split(url, "/")
|
||
if len(parts) >= 2 {
|
||
filename := parts[len(parts)-1]
|
||
if strings.Contains(filename, "manifest") {
|
||
return parts[len(parts)-2]
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// sanitizeName 清理扩展名（移除不安全字符）
|
||
func sanitizeName(name string) string {
|
||
name = strings.TrimSpace(name)
|
||
// 将空格替换为连字符
|
||
name = strings.ReplaceAll(name, " ", "-")
|
||
// 只保留字母、数字、连字符、下划线
|
||
var result strings.Builder
|
||
for _, c := range name {
|
||
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '_' {
|
||
result.WriteRune(c)
|
||
}
|
||
}
|
||
return result.String()
|
||
}
|
||
|
||
// httpGet 发送 HTTP GET 请求
|
||
func httpGet(url string) ([]byte, error) {
|
||
client := &http.Client{
|
||
Timeout: 60 * time.Second,
|
||
}
|
||
resp, err := client.Get(url)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
if resp.StatusCode != http.StatusOK {
|
||
return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, resp.Status)
|
||
}
|
||
|
||
return io.ReadAll(resp.Body)
|
||
}
|
||
|
||
// extractZip 解压 zip 文件到指定目录
|
||
func extractZip(zipData []byte, destDir string) error {
|
||
reader, err := zip.NewReader(bytes.NewReader(zipData), int64(len(zipData)))
|
||
if err != nil {
|
||
return fmt.Errorf("打开 zip 文件失败: %w", err)
|
||
}
|
||
|
||
for _, file := range reader.File {
|
||
// 安全检查：防止 zip slip 攻击
|
||
destPath := filepath.Join(destDir, file.Name)
|
||
if !strings.HasPrefix(filepath.Clean(destPath), filepath.Clean(destDir)+string(os.PathSeparator)) {
|
||
return fmt.Errorf("非法的 zip 文件路径: %s", file.Name)
|
||
}
|
||
|
||
if file.FileInfo().IsDir() {
|
||
if err := os.MkdirAll(destPath, 0755); err != nil {
|
||
return err
|
||
}
|
||
continue
|
||
}
|
||
|
||
// 确保父目录存在
|
||
if err := os.MkdirAll(filepath.Dir(destPath), 0755); err != nil {
|
||
return err
|
||
}
|
||
|
||
rc, err := file.Open()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
outFile, err := os.Create(destPath)
|
||
if err != nil {
|
||
rc.Close()
|
||
return err
|
||
}
|
||
|
||
_, err = io.Copy(outFile, rc)
|
||
outFile.Close()
|
||
rc.Close()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// findManifestDir 在解压的目录中查找 manifest.json 所在目录
|
||
func findManifestDir(rootDir string) (string, error) {
|
||
// 先检查根目录
|
||
if _, err := os.Stat(filepath.Join(rootDir, "manifest.json")); err == nil {
|
||
return rootDir, nil
|
||
}
|
||
|
||
// 检查一级子目录（常见的 zip 结构是 zip 内包含一个项目文件夹）
|
||
entries, err := os.ReadDir(rootDir)
|
||
if err != nil {
|
||
return "", fmt.Errorf("读取目录失败: %w", err)
|
||
}
|
||
|
||
for _, entry := range entries {
|
||
if entry.IsDir() {
|
||
subDir := filepath.Join(rootDir, entry.Name())
|
||
if _, err := os.Stat(filepath.Join(subDir, "manifest.json")); err == nil {
|
||
return subDir, nil
|
||
}
|
||
}
|
||
}
|
||
|
||
return "", errors.New("未找到 manifest.json，请确保 zip 文件包含有效的 SillyTavern 扩展")
|
||
}
|
||
|
||
// copyDir 递归复制目录
|
||
func copyDir(src, dst string) error {
|
||
if err := os.MkdirAll(dst, 0755); err != nil {
|
||
return err
|
||
}
|
||
|
||
entries, err := os.ReadDir(src)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
for _, entry := range entries {
|
||
srcPath := filepath.Join(src, entry.Name())
|
||
dstPath := filepath.Join(dst, entry.Name())
|
||
|
||
if entry.IsDir() {
|
||
if err := copyDir(srcPath, dstPath); err != nil {
|
||
return err
|
||
}
|
||
} else {
|
||
data, err := os.ReadFile(srcPath)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if err := os.WriteFile(dstPath, data, 0644); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|