Skip to content

Formerly KrillinAI, VideoTranslation and Dubbing Tool for 120+ Languages. Open-source AI workspace for creators, powered by Codex. Video downloader, video translation, create videos, images, audios, and edits with Agents in one place. For your Social Media like YouTube, TikTok, Instagram, etc.

feat: add OpenCreator runtime integration and harden translation

wulien-center05e3f5b399f9
diff --git a/.gitignore b/.gitignore
index eba4f809..72aa34e1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,6 +21,7 @@ dist/
.DS_Store
._*
KrillinAI.exe
+opencreator-server.exe
.codegraph/
.deepseek/
run.log
diff --git a/api/opencreator/v1/schema.json b/api/opencreator/v1/schema.json
new file mode 100644
index 00000000..281a85e1
--- /dev/null
+++ b/api/opencreator/v1/schema.json
@@ -0,0 +1,136 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema",
+ "$id": "https://opencreator.local/contracts/krillin-opencreator-v1.schema.json",
+ "title": "KrillinAI OpenCreator Protocol V1",
+ "oneOf": [
+ { "$ref": "#/$defs/createTaskRequest" },
+ { "$ref": "#/$defs/task" },
+ { "$ref": "#/$defs/taskEvent" },
+ { "$ref": "#/$defs/taskEventsResponse" },
+ { "$ref": "#/$defs/resultManifest" },
+ { "$ref": "#/$defs/capabilities" }
+ ],
+ "$defs": {
+ "identifier": {
+ "type": "string",
+ "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$"
+ },
+ "stageType": {
+ "enum": ["download", "subtitle", "tts", "render-horizontal", "render-vertical"]
+ },
+ "taskStatus": {
+ "enum": ["queued", "running", "succeeded", "failed", "canceled", "interrupted"]
+ },
+ "createTaskRequest": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": ["protocolVersion", "jobId", "stageRunId", "stageType", "idempotencyKey", "requestHash", "inputArtifactIds", "options"],
+ "properties": {
+ "protocolVersion": { "const": 1 },
+ "jobId": { "$ref": "#/$defs/identifier" },
+ "stageRunId": { "$ref": "#/$defs/identifier" },
+ "stageType": { "$ref": "#/$defs/stageType" },
+ "idempotencyKey": { "$ref": "#/$defs/identifier" },
+ "requestHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+ "inputArtifactIds": {
+ "type": "array",
+ "items": { "$ref": "#/$defs/identifier" },
+ "uniqueItems": true
+ },
+ "options": { "type": "object" },
+ "providerConfig": { "type": "object" }
+ }
+ },
+ "taskError": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": ["code", "message", "retryable"],
+ "properties": {
+ "code": { "type": "string", "minLength": 1 },
+ "message": { "type": "string", "minLength": 1 },
+ "retryable": { "type": "boolean" }
+ }
+ },
+ "task": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": ["id", "jobId", "stageRunId", "stageType", "status", "lastEventSeq", "createdAt", "updatedAt"],
+ "properties": {
+ "id": { "$ref": "#/$defs/identifier" },
+ "jobId": { "$ref": "#/$defs/identifier" },
+ "stageRunId": { "$ref": "#/$defs/identifier" },
+ "stageType": { "$ref": "#/$defs/stageType" },
+ "status": { "$ref": "#/$defs/taskStatus" },
+ "lastEventSeq": { "type": "integer", "minimum": 0 },
+ "resultManifestId": { "$ref": "#/$defs/identifier" },
+ "error": { "$ref": "#/$defs/taskError" },
+ "createdAt": { "type": "string", "format": "date-time" },
+ "updatedAt": { "type": "string", "format": "date-time" }
+ }
+ },
+ "taskEvent": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": ["taskId", "seq", "type", "payload", "createdAt"],
+ "properties": {
+ "taskId": { "$ref": "#/$defs/identifier" },
+ "seq": { "type": "integer", "minimum": 1 },
+ "type": { "enum": ["status", "progress", "artifact", "result", "error"] },
+ "payload": { "type": "object" },
+ "createdAt": { "type": "string", "format": "date-time" }
+ }
+ },
+ "taskEventsResponse": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": ["events", "nextSeq"],
+ "properties": {
+ "events": { "type": "array", "items": { "$ref": "#/$defs/taskEvent" } },
+ "nextSeq": { "type": "integer", "minimum": 0 }
+ }
+ },
+ "resultArtifact": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": ["id", "kind", "relativePath"],
+ "properties": {
+ "id": { "$ref": "#/$defs/identifier" },
+ "kind": { "type": "string", "minLength": 1 },
+ "relativePath": { "type": "string", "minLength": 1 },
+ "mimeType": { "type": "string", "minLength": 1 },
+ "size": { "type": "integer", "minimum": 0 },
+ "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" }
+ }
+ },
+ "resultManifest": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": ["protocolVersion", "id", "taskId", "jobId", "stageRunId", "artifacts", "metadata", "createdAt"],
+ "properties": {
+ "protocolVersion": { "const": 1 },
+ "id": { "$ref": "#/$defs/identifier" },
+ "taskId": { "$ref": "#/$defs/identifier" },
+ "jobId": { "$ref": "#/$defs/identifier" },
+ "stageRunId": { "$ref": "#/$defs/identifier" },
+ "artifacts": { "type": "array", "items": { "$ref": "#/$defs/resultArtifact" } },
+ "metadata": { "type": "object" },
+ "createdAt": { "type": "string", "format": "date-time" }
+ }
+ },
+ "capabilities": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": ["protocolVersion", "serviceVersion", "generation", "stages"],
+ "properties": {
+ "protocolVersion": { "const": 1 },
+ "serviceVersion": { "type": "string", "minLength": 1 },
+ "generation": { "type": "integer", "minimum": 1 },
+ "stages": {
+ "type": "array",
+ "items": { "$ref": "#/$defs/stageType" },
+ "uniqueItems": true
+ }
+ }
+ }
+ }
+}
diff --git a/cmd/cli/main.go b/cmd/cli/main.go
index dffe7111..db08143f 100644
--- a/cmd/cli/main.go
+++ b/cmd/cli/main.go
@@ -11,6 +11,7 @@ import (
"krillin-ai/internal/service"
"krillin-ai/log"
"os"
+ "strings"
)
func main() {
@@ -51,17 +52,43 @@ func main() {
},
})
}
- if err := config.CheckConfig(); err != nil {
+ if err := config.CheckBaseConfig(); err != nil {
writeAndExit(errorResponse(err, pipeline.ErrorKindUsage))
}
- if err := deps.CheckDependency(); err != nil {
+ if requiresTranscriptionAtStart(cmd) {
+ if err := config.ValidateTranscriptionConfig(); err != nil {
+ writeAndExit(errorResponse(err, pipeline.ErrorKindUsage))
+ }
+ }
+ if err := deps.CheckCoreDependencies(); err != nil {
writeAndExit(errorResponse(err, pipeline.ErrorKindDependency))
}
+ if requiresTranscriptionAtStart(cmd) {
+ if err := deps.CheckTranscriptionDependency(); err != nil {
+ writeAndExit(errorResponse(err, pipeline.ErrorKindDependency))
+ }
+ }
+ if cmd.Name == "tts" {
+ if err := deps.CheckTTSDependency(); err != nil {
+ writeAndExit(errorResponse(err, pipeline.ErrorKindDependency))
+ }
+ }
svc := service.NewService()
adapter := pipeline.NewServiceAdapter(svc)
writeAndExit(cli.Execute(context.Background(), adapter, cmd))
}
+func requiresTranscriptionAtStart(cmd cli.Command) bool {
+ if cmd.Name != "subtitle" {
+ return false
+ }
+ if cmd.Subtitle.CaptionSource == pipeline.CaptionSourceWhisper {
+ return true
+ }
+ input := strings.ToLower(strings.TrimSpace(cmd.Subtitle.Input))
+ return !strings.Contains(input, "youtube.com") && !strings.Contains(input, "youtu.be")
+}
+
func errorResponse(err error, kind pipeline.ErrorKind) pipeline.Response {
return pipeline.Response{
OK: false,
diff --git a/cmd/cli/main_test.go b/cmd/cli/main_test.go
new file mode 100644
index 00000000..8260e1e6
--- /dev/null
+++ b/cmd/cli/main_test.go
@@ -0,0 +1,50 @@
+package main
+
+import (
+ "krillin-ai/internal/cli"
+ "krillin-ai/internal/pipeline"
+ "testing"
+)
+
+func TestRequiresTranscriptionAtStart(t *testing.T) {
+ tests := []struct {
+ name string
+ cmd cli.Command
+ want bool
+ }{
+ {
+ name: "youtube platform captions can start without ASR",
+ cmd: cli.Command{Name: "subtitle", Subtitle: pipeline.SubtitleRequest{
+ Input: "https://www.youtube.com/watch?v=demo", CaptionSource: pipeline.CaptionSourceAny,
+ }},
+ want: false,
+ },
+ {
+ name: "forced speech recognition requires ASR",
+ cmd: cli.Command{Name: "subtitle", Subtitle: pipeline.SubtitleRequest{
+ Input: "https://www.youtube.com/watch?v=demo", CaptionSource: pipeline.CaptionSourceWhisper,
+ }},
+ want: true,
+ },
+ {
+ name: "local media requires ASR",
+ cmd: cli.Command{Name: "subtitle", Subtitle: pipeline.SubtitleRequest{
+ Input: "video.mp4", CaptionSource: pipeline.CaptionSourceAny,
+ }},
+ want: true,
+ },
+ {
+ name: "render does not require ASR",
+ cmd: cli.Command{Name: "render-horizontal"},
+ want: false,
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ if got := requiresTranscriptionAtStart(test.cmd); got != test.want {
+ t.Fatalf("requiresTranscriptionAtStart() = %v, want %v", got, test.want)
+ }
+ })
+ }
+}
diff --git a/cmd/opencreator-server/main.go b/cmd/opencreator-server/main.go
new file mode 100644
index 00000000..23bb9126
--- /dev/null
+++ b/cmd/opencreator-server/main.go
@@ -0,0 +1,66 @@
+package main
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "krillin-ai/internal/opencreatorapi"
+ "krillin-ai/log"
+ "net"
+ "net/http"
+ "os"
+ "os/signal"
+ "syscall"
+ "time"
+)
+
+var serviceVersion = "0.1.0"
+
+func main() {
+ log.InitLogger()
+ defer log.GetLogger().Sync()
+
+ listenAddress := os.Getenv("OPENCREATOR_KRILLIN_LISTEN")
+ jobsRoot := os.Getenv("OPENCREATOR_KRILLIN_JOBS_ROOT")
+ token := os.Getenv("OPENCREATOR_KRILLIN_TOKEN")
+ if listenAddress != "127.0.0.1:0" {
+ fatal(errors.New("OPENCREATOR_KRILLIN_LISTEN must be exactly 127.0.0.1:0"))
+ }
+ manager, err := opencreatorapi.NewManager(jobsRoot, nil)
+ if err != nil {
+ fatal(err)
+ }
+ defer manager.Close()
+ generation := time.Now().UTC().UnixMilli()
+ server, err := opencreatorapi.NewServer(opencreatorapi.ServerConfig{
+ Token: token, ServiceVersion: serviceVersion, Generation: generation, Manager: manager,
+ })
+ if err != nil {
+ fatal(err)
+ }
+ listener, err := net.Listen("tcp4", listenAddress)
+ if err != nil {
+ fatal(err)
+ }
+ port := listener.Addr().(*net.TCPAddr).Port
+ startup, _ := json.Marshal(map[string]interface{}{"port": port, "generation": generation})
+ fmt.Println(string(startup))
+
+ httpServer := &http.Server{
+ Handler: server.Handler(), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 30 * time.Second, IdleTimeout: 30 * time.Second,
+ }
+ interrupt := make(chan os.Signal, 1)
+ signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)
+ go func() {
+ <-interrupt
+ _ = httpServer.Close()
+ }()
+ if err := httpServer.Serve(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
+ fatal(err)
+ }
+}
+
+func fatal(err error) {
+ _, _ = fmt.Fprintln(os.Stderr, "opencreator-server failed: "+err.Error())
+ os.Exit(1)
+}
diff --git a/config/config-example.toml b/config/config-example.toml
index 0e6bf1a5..7a6f1e25 100644
--- a/config/config-example.toml
+++ b/config/config-example.toml
@@ -35,7 +35,7 @@
[transcribe.whisperkit]
model = "large-v2" # whisperkit的本地模型可选值:large-v2
[transcribe.whispercpp]
- model = "large-v2" # whispercpp的本地模型可选值:large-v2
+ model = "tiny" # whispercpp的本地模型可选值:tiny,medium,large-v2
[transcribe.aliyun] # provider选aliyun这块就都要填
[transcribe.aliyun.oss]
access_key_id = ""
diff --git a/config/config.go b/config/config.go
index fff308d6..16a0a557 100644
--- a/config/config.go
+++ b/config/config.go
@@ -175,8 +175,9 @@ var Conf = Config{
},
}
-// 检查必要的配置是否完整
-func validateConfig() error {
+// ValidateTranscriptionConfig checks the selected transcription provider only
+// when a workflow is about to use speech recognition.
+func ValidateTranscriptionConfig() error {
// 检查转写服务提供商配置
switch Conf.Transcribe.Provider {
case "openai":
@@ -200,7 +201,7 @@ func validateConfig() error {
log.GetLogger().Error("whispercpp only support windows", zap.String("current os", runtime.GOOS))
return fmt.Errorf("whispercpp only support windows")
}
- if Conf.Transcribe.Whispercpp.Model != "large-v2" {
+ if Conf.Transcribe.Whispercpp.Model != "tiny" && Conf.Transcribe.Whispercpp.Model != "medium" && Conf.Transcribe.Whispercpp.Model != "large-v2" {
return errors.New("检测到开启了whisper.cpp,但模型选型配置不正确,请检查配置")
}
case "aliyun":
@@ -232,13 +233,19 @@ func LoadConfig() bool {
// 验证配置
func CheckConfig() error {
- var err error
- // 解析代理地址
- Conf.App.ParsedProxy, err = url.Parse(Conf.App.Proxy)
- if err != nil {
+ if err := CheckBaseConfig(); err != nil {
return err
}
- return validateConfig()
+ return ValidateTranscriptionConfig()
+}
+
+// CheckBaseConfig validates configuration shared by all CLI stages. A stage
+// that can finish with platform captions must not require ASR credentials up
+// front.
+func CheckBaseConfig() error {
+ var err error
+ Conf.App.ParsedProxy, err = url.Parse(Conf.App.Proxy)
+ return err
}
// SaveConfig 保存配置到文件
diff --git a/config/config_validation_test.go b/config/config_validation_test.go
new file mode 100644
index 00000000..0431d189
--- /dev/null
+++ b/config/config_validation_test.go
@@ -0,0 +1,31 @@
+package config
+
+import "testing"
+
+func TestBaseConfigDoesNotRequireTranscriptionCredentials(t *testing.T) {
+ previous := Conf
+ t.Cleanup(func() { Conf = previous })
+
+ Conf.App.Proxy = ""
+ Conf.Transcribe.Provider = "openai"
+ Conf.Transcribe.Openai.ApiKey = ""
+
+ if err := CheckBaseConfig(); err != nil {
+ t.Fatalf("CheckBaseConfig() error = %v", err)
+ }
+ if err := ValidateTranscriptionConfig(); err == nil {
+ t.Fatal("ValidateTranscriptionConfig() error = nil, want missing API key")
+ }
+}
+
+func TestValidateTranscriptionConfigAcceptsTinyWhisperCpp(t *testing.T) {
+ previous := Conf
+ t.Cleanup(func() { Conf = previous })
+
+ Conf.Transcribe.Provider = "whispercpp"
+ Conf.Transcribe.Whispercpp.Model = "tiny"
+
+ if err := ValidateTranscriptionConfig(); err != nil {
+ t.Fatalf("ValidateTranscriptionConfig() error = %v", err)
+ }
+}
diff --git a/internal/cli/commands_test.go b/internal/cli/commands_test.go
index 5799df5c..0f8c1335 100644
--- a/internal/cli/commands_test.go
+++ b/internal/cli/commands_test.go
@@ -415,11 +415,11 @@ func TestLoadSubtitleStyleFindsRepoDefaultFromDifferentWorkingDir(t *testing.T)
if !ok {
t.Fatal("default subtitle style path not found")
}
- t.Cleanup(func() {
+ defer func() {
if err := os.Chdir(originalWd); err != nil {
t.Fatalf("restore cwd: %v", err)
}
- })
+ }()
if err := os.Chdir(t.TempDir()); err != nil {
t.Fatal(err)
}
diff --git a/internal/deps/checker.go b/internal/deps/checker.go
index 80d009db..1cce8022 100644
--- a/internal/deps/checker.go
+++ b/internal/deps/checker.go
@@ -3,6 +3,7 @@ package deps
import (
"fmt"
"krillin-ai/config"
+ "krillin-ai/internal/resourcepath"
"krillin-ai/internal/storage"
"krillin-ai/log"
"krillin-ai/pkg/util"
@@ -17,6 +18,19 @@ import (
)
func CheckDependency() error {
+ if err := CheckCoreDependencies(); err != nil {
+ return err
+ }
+ if err := CheckTranscriptionDependency(); err != nil {
+ return err
+ }
+ return CheckTTSDependency()
+}
+
+func CheckCoreDependencies() error {
+ if resourcepath.Offline() {
+ return configurePackagedCoreDependencies()
+ }
err := checkAndDownloadFfmpeg()
if err != nil {
log.GetLogger().Error("ffmpeg环境准备失败", zap.Error(err))
@@ -32,6 +46,14 @@ func CheckDependency() error {
log.GetLogger().Error("yt-dlp环境准备失败", zap.Error(err))
return err
}
+ return nil
+}
+
+func CheckTranscriptionDependency() error {
+ if resourcepath.Offline() {
+ return configurePackagedTranscriptionDependency()
+ }
+ var err error
if config.Conf.Transcribe.Provider == "fasterwhisper" {
err = checkFasterWhisper()
if err != nil {
@@ -78,15 +100,76 @@ func CheckDependency() error {
return err
}
}
+ return nil
+}
+
+func CheckTTSDependency() error {
if config.Conf.Tts.Provider == "edge-tts" {
- if err = checkEdgeTts(); err != nil {
+ if err := checkEdgeTts(); err != nil {
log.GetLogger().Error("edge-tts环境准备失败", zap.Error(err))
+ return err
}
}
+ return nil
+}
+func configurePackagedCoreDependencies() error {
+ var err error
+ if storage.FfmpegPath, err = packagedExecutable("ffmpeg"); err != nil {
+ return err
+ }
+ if storage.FfprobePath, err = packagedExecutable("ffprobe"); err != nil {
+ return err
+ }
+ if storage.YtdlpPath, err = packagedExecutable("yt-dlp"); err != nil {
+ return err
+ }
return nil
}
+func configurePackagedTranscriptionDependency() error {
+ var err error
+ switch config.Conf.Transcribe.Provider {
+ case "fasterwhisper":
+ name := "faster-whisper"
+ if runtime.GOOS == "windows" {
+ name += ".exe"
+ }
+ if storage.FasterwhisperPath, err = resourcepath.RequireFile("bin", name); err != nil {
+ return err
+ }
+ if _, err = resourcepath.RequireDir("models", "fasterwhisper", fmt.Sprintf("faster-whisper-%s", config.Conf.Transcribe.Fasterwhisper.Model)); err != nil {
+ return err
+ }
+ case "whispercpp":
+ name := "whispercpp"
+ if runtime.GOOS == "windows" {
+ name += ".exe"
+ }
+ if storage.WhispercppPath, err = resourcepath.RequireFile("bin", name); err != nil {
+ return err
+ }
+ if _, err = resourcepath.RequireFile("models", "whispercpp", fmt.Sprintf("ggml-%s.bin", config.Conf.Transcribe.Whispercpp.Model)); err != nil {
+ return err
+ }
+ case "whisperkit":
+ if storage.WhisperKitPath, err = packagedExecutable("whisperkit-cli"); err != nil {
+ return err
+ }
+ if _, err = resourcepath.RequireDir("models", "whisperkit", config.Conf.Transcribe.Whisperkit.Model); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func packagedExecutable(name string) (string, error) {
+ if runtime.GOOS == "windows" {
+ name += ".exe"
+ }
+ return resourcepath.RequireFile("bin", name)
+}
+
// 检测并安装ffmpeg
func checkAndDownloadFfmpeg() error {
// 检查ffmpeg是否已经安装
diff --git a/internal/opencreatorapi/dto.go b/internal/opencreatorapi/dto.go
new file mode 100644
index 00000000..a534b8c1
--- /dev/null
+++ b/internal/opencreatorapi/dto.go
@@ -0,0 +1,105 @@
+package opencreatorapi
+
+import "time"
+
+const ProtocolVersion = 1
+
+type StageType string
+
+const (
+ StageDownload StageType = "download"
+ StageSubtitle StageType = "subtitle"
+ StageTTS StageType = "tts"
+ StageRenderHorizontal StageType = "render-horizontal"
+ StageRenderVertical StageType = "render-vertical"
+)
+
+type TaskStatus string
+
+const (
+ StatusQueued TaskStatus = "queued"
+ StatusRunning TaskStatus = "running"
+ StatusSucceeded TaskStatus = "succeeded"
+ StatusFailed TaskStatus = "failed"
+ StatusCanceled TaskStatus = "canceled"
+ StatusInterrupted TaskStatus = "interrupted"
+)
+
+type CreateTaskRequest struct {
+ ProtocolVersion int `json:"protocolVersion"`
+ JobID string `json:"jobId"`
+ StageRunID string `json:"stageRunId"`
+ StageType StageType `json:"stageType"`
+ IdempotencyKey string `json:"idempotencyKey"`
+ RequestHash string `json:"requestHash"`
+ InputArtifactIDs []string `json:"inputArtifactIds"`
+ Options map[string]interface{} `json:"options"`
+ ProviderConfig map[string]interface{} `json:"providerConfig,omitempty"`
+}
+
+type TaskError struct {
+ Code string `json:"code"`
+ Message string `json:"message"`
+ Retryable bool `json:"retryable"`
+}
+
+type Task struct {
+ ID string `json:"id"`
+ JobID string `json:"jobId"`
+ StageRunID string `json:"stageRunId"`
+ StageType StageType `json:"stageType"`
+ Status TaskStatus `json:"status"`
+ LastEventSeq int64 `json:"lastEventSeq"`
+ ResultManifestID string `json:"resultManifestId,omitempty"`
+ Error *TaskError `json:"error,omitempty"`
+ CreatedAt time.Time `json:"createdAt"`
+ UpdatedAt time.Time `json:"updatedAt"`
+}
+
+type TaskEvent struct {
+ TaskID string `json:"taskId"`
+ Seq int64 `json:"seq"`
+ Type string `json:"type"`
+ Payload map[string]interface{} `json:"payload"`
+ CreatedAt time.Time `json:"createdAt"`
+}
+
+type TaskEventsResponse struct {
+ Events []TaskEvent `json:"events"`
+ NextSeq int64 `json:"nextSeq"`
+}
+
+type ResultArtifact struct {
+ ID string `json:"id"`
+ Kind string `json:"kind"`
+ RelativePath string `json:"relativePath"`
+ MimeType string `json:"mimeType,omitempty"`
+ Size int64 `json:"size,omitempty"`
+ SHA256 string `json:"sha256,omitempty"`
+}
+
+type ResultManifest struct {
+ ProtocolVersion int `json:"protocolVersion"`
+ ID string `json:"id"`
+ TaskID string `json:"taskId"`
+ JobID string `json:"jobId"`
+ StageRunID string `json:"stageRunId"`
+ Artifacts []ResultArtifact `json:"artifacts"`
+ Metadata map[string]interface{} `json:"metadata"`
+ CreatedAt time.Time `json:"createdAt"`
+}
+
+type CapabilitiesResponse struct {
+ ProtocolVersion int `json:"protocolVersion"`
+ ServiceVersion string `json:"serviceVersion"`
+ Generation int64 `json:"generation"`
+ Stages []StageType `json:"stages"`
+}
+
+type APIError struct {
+ Error TaskError `json:"error"`
+}
+
+func allStages() []StageType {
+ return []StageType{StageDownload, StageSubtitle, StageTTS, StageRenderHorizontal, StageRenderVertical}
+}
diff --git a/internal/opencreatorapi/manager.go b/internal/opencreatorapi/manager.go
new file mode 100644
index 00000000..162173b5
--- /dev/null
+++ b/internal/opencreatorapi/manager.go
@@ -0,0 +1,177 @@
+package opencreatorapi
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "regexp"
+ "sync"
+)
+
+var requestHashPattern = regexp.MustCompile(`^[a-f0-9]{64}$`)
+
+type workItem struct {
+ request CreateTaskRequest
+ taskID string
+}
+
+type Manager struct {
+ guard *PathGuard
+ store *Store
+ runner StageRunner
+ queue chan workItem
+ ctx context.Context
+ cancel context.CancelFunc
+ wg sync.WaitGroup
+}
+
+func NewManager(jobsRoot string, runner StageRunner) (*Manager, error) {
+ guard, err := NewPathGuard(jobsRoot)
+ if err != nil {
+ return nil, err
+ }
+ store, err := NewStore(guard)
+ if err != nil {
+ return nil, err
+ }
+ if runner == nil {
+ runner = NewPipelineRunner(guard)
+ }
+ ctx, cancel := context.WithCancel(context.Background())
+ manager := &Manager{
+ guard: guard, store: store, runner: runner, queue: make(chan workItem, 64), ctx: ctx, cancel: cancel,
+ }
+ manager.wg.Add(1)
+ go manager.worker()
+ return manager, nil
+}
+
+func (m *Manager) Close() {
+ m.cancel()
+ m.wg.Wait()
+}
+
+func (m *Manager) Create(req CreateTaskRequest) (Task, bool, error) {
+ if err := validateCreateRequest(req); err != nil {
+ return Task{}, false, err
+ }
+ task, replay, err := m.store.Create(req)
+ if err != nil {
+ return task, replay, err
+ }
+ if replay && task.Status != StatusQueued {
+ return task, true, nil
+ }
+ select {
+ case m.queue <- workItem{request: req, taskID: task.ID}:
+ return task, replay, nil
+ case <-m.ctx.Done():
+ _, _ = m.store.Fail(task.ID, TaskError{Code: "service_stopping", Message: "KrillinAI service is stopping", Retryable: true})
+ return Task{}, false, errors.New("service is stopping")
+ }
+}
+
+func (m *Manager) Get(taskID string) (Task, error) {
+ return m.store.Get(taskID)
+}
+
+func (m *Manager) Events(taskID string, afterSeq int64) (TaskEventsResponse, error) {
+ return m.store.Events(taskID, afterSeq)
+}
+
+func (m *Manager) Cancel(taskID string) (Task, error) {
+ return m.store.Cancel(taskID)
+}
+
+func (m *Manager) Result(taskID string) (ResultManifest, error) {
+ return m.store.Result(taskID)
+}
+
+func (m *Manager) worker() {
+ defer m.wg.Done()
+ for {
+ select {
+ case <-m.ctx.Done():
+ return
+ case item := <-m.queue:
+ m.execute(item)
+ }
+ }
+}
+
+func (m *Manager) execute(item workItem) {
+ ctx, cancel := context.WithCancel(m.ctx)
+ task, err := m.store.Start(item.taskID, cancel)
+ if err != nil || task.Status != StatusRunning {
+ cancel()
+ return
+ }
+ workdir, err := m.guard.StageWorkdir(task.JobID, task.StageRunID)
+ if err != nil {
+ cancel()
+ _, _ = m.store.Fail(task.ID, TaskError{Code: "job_path_invalid", Message: err.Error(), Retryable: false})
+ return
+ }
+ result, err := m.runner.Run(ctx, item.request, workdir, func(phase string, percent int, message string) {
+ _, _ = m.store.Progress(task.ID, phase, percent, message)
+ })
+ cancel()
+ if err != nil {
+ if current, getErr := m.store.Get(task.ID); getErr == nil && current.Status == StatusCanceled {
+ return
+ }
+ runErr := &RunError{Code: "krillin_stage_failed", Message: redactSecrets(err.Error()), Retryable: true}
+ if errors.As(err, &runErr) {
+ // Keep the typed error.
+ }
+ _, _ = m.store.Fail(task.ID, TaskError{Code: runErr.Code, Message: runErr.Message, Retryable: runErr.Retryable})
+ return
+ }
+ manifest, err := newResultManifest(task, result)
+ if err == nil {
+ err = writeResultManifest(m.guard, task, manifest)
+ }
+ if err != nil {
+ _, _ = m.store.Fail(task.ID, TaskError{Code: "result_manifest_write_failed", Message: err.Error(), Retryable: true})
+ return
+ }
+ _, _ = m.store.Complete(task.ID, manifest.ID)
+}
+
+func validateCreateRequest(req CreateTaskRequest) error {
+ if req.ProtocolVersion != ProtocolVersion {
+ return &RunError{Code: "protocol_version_unsupported", Message: "protocolVersion must be 1", Retryable: false}
+ }
+ for _, value := range []string{req.JobID, req.StageRunID, req.IdempotencyKey} {
+ if err := validateIdentifier(value); err != nil {
+ return &RunError{Code: "invalid_identifier", Message: err.Error(), Retryable: false}
+ }
+ }
+ if !requestHashPattern.MatchString(req.RequestHash) {
+ return &RunError{Code: "invalid_request_hash", Message: "requestHash must be a lowercase SHA-256 value", Retryable: false}
+ }
+ foundStage := false
+ for _, stage := range allStages() {
+ if req.StageType == stage {
+ foundStage = true
+ break
+ }
+ }
+ if !foundStage {
+ return &RunError{Code: "stage_not_supported", Message: fmt.Sprintf("Unsupported stage: %s", req.StageType), Retryable: false}
+ }
+ seen := make(map[string]struct{}, len(req.InputArtifactIDs))
+ for _, id := range req.InputArtifactIDs {
+ if err := validateIdentifier(id); err != nil {
+ return &RunError{Code: "invalid_identifier", Message: err.Error(), Retryable: false}
+ }
+ if _, exists := seen[id]; exists {
+ return &RunError{Code: "duplicate_artifact_id", Message: "inputArtifactIds must be unique", Retryable: false}
+ }
+ seen[id] = struct{}{}
+ }
+ if req.Options == nil {
+ return &RunError{Code: "invalid_options", Message: "options must be an object", Retryable: false}
+ }
+ return nil
+}
diff --git a/internal/opencreatorapi/path_guard.go b/internal/opencreatorapi/path_guard.go
new file mode 100644
index 00000000..7f082c84
--- /dev/null
+++ b/internal/opencreatorapi/path_guard.go
@@ -0,0 +1,180 @@
+package opencreatorapi
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "os"
+ "path/filepath"
+ "regexp"
+)
+
+var identifierPattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$`)
+
+type PathGuard struct {
+ root string
+}
+
+type artifactIndex struct {
+ Artifacts []artifactIndexEntry `json:"artifacts"`
+}
+
+type artifactIndexEntry struct {
+ ID string `json:"id"`
+ Kind string `json:"kind"`
+ RelativePath string `json:"relativePath"`
+}
+
+func NewPathGuard(root string) (*PathGuard, error) {
+ if root == "" {
+ return nil, errors.New("jobs root is required")
+ }
+ abs, err := filepath.Abs(filepath.Clean(root))
+ if err != nil {
+ return nil, err
+ }
+ if err := os.MkdirAll(abs, 0700); err != nil {
+ return nil, err
+ }
+ real, err := filepath.EvalSymlinks(abs)
+ if err != nil {
+ return nil, err
+ }
+ return &PathGuard{root: real}, nil
+}
+
+func (g *PathGuard) Root() string {
+ return g.root
+}
+
+func (g *PathGuard) JobDir(jobID string) (string, error) {
+ if err := validateIdentifier(jobID); err != nil {
+ return "", err
+ }
+ return g.resolveDirect(g.root, jobID)
+}
+
+func (g *PathGuard) TaskDir(jobID, taskID string) (string, error) {
+ jobDir, err := g.JobDir(jobID)
+ if err != nil {
+ return "", err
+ }
+ if err := validateIdentifier(taskID); err != nil {
+ return "", err
+ }
+ return g.resolveDirect(filepath.Join(jobDir, "krillin-tasks"), taskID)
+}
+
+func (g *PathGuard) StageWorkdir(jobID, stageRunID string) (string, error) {
+ jobDir, err := g.JobDir(jobID)
+ if err != nil {
+ return "", err
+ }
+ if err := validateIdentifier(stageRunID); err != nil {
+ return "", err
+ }
+ return g.resolveDirect(filepath.Join(jobDir, "stages"), stageRunID, "krillin")
+}
+
+func (g *PathGuard) ResolveArtifact(jobID, artifactID string) (string, string, error) {
+ if err := validateIdentifier(artifactID); err != nil {
+ return "", "", err
+ }
+ jobDir, err := g.JobDir(jobID)
+ if err != nil {
+ return "", "", err
+ }
+ data, err := os.ReadFile(filepath.Join(jobDir, "artifact-index.json"))
+ if err != nil {
+ return "", "", fmt.Errorf("artifact index unavailable: %w", err)
+ }
+ var index artifactIndex
+ if err := json.Unmarshal(data, &index); err != nil {
+ return "", "", fmt.Errorf("artifact index invalid: %w", err)
+ }
+ for _, entry := range index.Artifacts {
+ if entry.ID != artifactID {
+ continue
+ }
+ if entry.RelativePath == "" || filepath.IsAbs(entry.RelativePath) {
+ return "", "", errors.New("artifact path must be job-relative")
+ }
+ candidate := filepath.Join(jobDir, filepath.FromSlash(entry.RelativePath))
+ real, err := filepath.EvalSymlinks(candidate)
+ if err != nil {
+ return "", "", err
+ }
+ if err := ensureInside(jobDir, real); err != nil {
+ return "", "", err
+ }
+ info, err := os.Stat(real)
+ if err != nil || !info.Mode().IsRegular() {
+ return "", "", errors.New("artifact is not a regular file")
+ }
+ return real, entry.Kind, nil
+ }
+ return "", "", errors.New("artifact is not registered for this job")
+}
+
+func (g *PathGuard) RelativeToRoot(path string) (string, error) {
+ real, err := filepath.EvalSymlinks(path)
+ if err != nil {
+ return "", err
+ }
+ if err := ensureInside(g.root, real); err != nil {
+ return "", err
+ }
+ relative, err := filepath.Rel(g.root, real)
+ if err != nil {
+ return "", err
+ }
+ return filepath.ToSlash(relative), nil
+}
+
+func (g *PathGuard) resolveDirect(parent string, parts ...string) (string, error) {
+ for _, part := range parts {
+ if err := validateIdentifier(part); err != nil {
+ return "", err
+ }
+ }
+ if err := os.MkdirAll(parent, 0700); err != nil {
+ return "", err
+ }
+ realParent, err := filepath.EvalSymlinks(parent)
+ if err != nil {
+ return "", err
+ }
+ if err := ensureInside(g.root, realParent); err != nil {
+ return "", err
+ }
+ path := filepath.Join(append([]string{realParent}, parts...)...)
+ if err := os.MkdirAll(path, 0700); err != nil {
+ return "", err
+ }
+ real, err := filepath.EvalSymlinks(path)
+ if err != nil {
+ return "", err
+ }
+ if err := ensureInside(g.root, real); err != nil {
+ return "", err
+ }
+ return real, nil
+}
+
+func validateIdentifier(value string) error {
+ if !identifierPattern.MatchString(value) {
+ return errors.New("invalid identifier")
+ }
+ return nil
+}
+
+func ensureInside(root, path string) error {
+ relative, err := filepath.Rel(root, path)
+ if err != nil || relative == ".." || filepath.IsAbs(relative) {
+ return errors.New("path escapes authorized root")
+ }
+ if len(relative) >= 3 && relative[:3] == ".."+string(filepath.Separator) {
+ return errors.New("path escapes authorized root")
+ }
+ return nil
+}
diff --git a/internal/opencreatorapi/runner.go b/internal/opencreatorapi/runner.go
new file mode 100644
index 00000000..148cf397
--- /dev/null
+++ b/internal/opencreatorapi/runner.go
@@ -0,0 +1,458 @@
+package opencreatorapi
+
+import (
+ "context"
+ "crypto/sha256"
+ "encoding/hex"
+ "encoding/json"
+ "fmt"
+ "krillin-ai/config"
+ "krillin-ai/internal/deps"
+ "krillin-ai/internal/pipeline"
+ "krillin-ai/internal/service"
+ subtitlestyle "krillin-ai/internal/subtitle_style"
+ "os"
+ "path/filepath"
+ "strings"
+ "time"
+)
+
+type StageRunner interface {
+ Run(context.Context, CreateTaskRequest, string, ProgressReporter) (RunResult, error)
+}
+
+type ProgressReporter func(phase string, percent int, message string)
+
+type RunResult struct {
+ Artifacts []ResultArtifact
+ Metadata map[string]interface{}
+}
+
+type RunError struct {
+ Code string
+ Message string
+ Retryable bool
+}
+
+func (e *RunError) Error() string {
+ return e.Message
+}
+
+type PipelineRunner struct {
+ guard *PathGuard
+}
+
+func NewPipelineRunner(guard *PathGuard) *PipelineRunner {
+ return &PipelineRunner{guard: guard}
+}
+
+func (r *PipelineRunner) Run(ctx context.Context, req CreateTaskRequest, workdir string, report ProgressReporter) (RunResult, error) {
+ reportProgress(report, "validating", 5, "正在检查任务设置")
+ previous := config.Conf
+ defer func() { config.Conf = previous }()
+ applyProviderConfig(req.ProviderConfig)
+ if err := config.CheckBaseConfig(); err != nil {
+ return RunResult{}, runError("invalid_provider_config", err, false)
+ }
+ if err := deps.CheckCoreDependencies(); err != nil {
+ return RunResult{}, runError("dependency_not_packaged", err, false)
+ }
+ if req.StageType == StageTTS {
+ if err := deps.CheckTTSDependency(); err != nil {
+ return RunResult{}, runError("dependency_not_packaged", err, false)
+ }
+ }
+ svc := service.NewService()
+ if svc == nil {
+ return RunResult{}, &RunError{Code: "provider_initialization_failed", Message: "KrillinAI provider initialization failed", Retryable: false}
+ }
+ adapter := pipeline.NewServiceAdapter(svc)
+ response, err := r.execute(ctx, req, workdir, adapter, svc, report)
+ if err != nil {
+ if response.Error != nil {
+ return RunResult{}, &RunError{
+ Code: response.Error.Code, Message: response.Error.Message, Retryable: response.Error.Retryable,
+ }
+ }
+ return RunResult{}, runError("krillin_stage_failed", err, true)
+ }
+ artifacts, err := r.collectArtifacts(req, response.Outputs)
+ if err != nil {
+ return RunResult{}, err
+ }
+ metadata := map[string]interface{}{}
+ if response.CaptionSource != "" {
+ metadata["captionSource"] = response.CaptionSource
+ }
+ if len(response.Warnings) > 0 {
+ metadata["warnings"] = response.Warnings
+ }
+ return RunResult{Artifacts: artifacts, Metadata: metadata}, nil
+}
+
+func (r *PipelineRunner) execute(
+ ctx context.Context,
+ req CreateTaskRequest,
+ workdir string,
+ adapter pipeline.StageService,
+ svc *service.Service,
+ report ProgressReporter,
+) (pipeline.Response, error) {
+ switch req.StageType {
+ case StageDownload:
+ reportProgress(report, "preparing_source", 10, "正在准备视频来源")
+ input := optionString(req.Options, "sourceUrl")
+ if input == "" {
+ return pipeline.Response{}, &RunError{Code: "source_missing", Message: "sourceUrl is required", Retryable: false}
+ }
+ result, err := svc.DownloadMedia(ctx, input, workdir, req.StageRunID)
+ reportProgress(report, "collecting_outputs", 95, "正在整理下载结果")
+ manifest := pipeline.NewManifest(req.StageRunID, workdir)
+ if applyErr := manifest.ApplyDefaultOutputs(); applyErr != nil {
+ return pipeline.Response{}, applyErr
+ }
+ manifest.InputURL = input
+ manifest.Outputs.OriginVideo = result.VideoPath
+ manifest.Outputs.OriginAudio = result.AudioPath
+ if err != nil {
+ manifest.MarkStage(pipeline.StageDownload, false, err.Error())
+ _ = manifest.Save()
+ return pipeline.Response{Stage: pipeline.StageDownload, Workdir: workdir, TaskID: req.StageRunID, Outputs: manifest.Outputs}, err
+ }
+ manifest.MarkStage(pipeline.StageDownload, true, "")
+ if err := manifest.Save(); err != nil {
+ return pipeline.Response{}, err
+ }
+ return pipeline.Response{OK: true, Stage: pipeline.StageDownload, Workdir: workdir, TaskID: req.StageRunID, Outputs: manifest.Outputs}, nil
+ case StageSubtitle:
+ source, err := r.sourceInput(req)
+ if err != nil {
+ return pipeline.Response{}, err
+ }
+ return pipeline.GenerateSubtitles(ctx, adapter, pipeline.SubtitleRequest{
+ Input: source, Workdir: workdir, TaskID: req.StageRunID,
+ OriginLang: optionString(req.Options, "originLanguage"),
+ TargetLang: optionString(req.Options, "targetLanguage"),
+ CaptionSource: pipeline.CaptionSource(defaultString(optionString(req.Options, "captionSource"), "any")),
+ BilingualTop: optionBool(req.Options, "bilingualTop"),
+ PrepareVideo: true,
+ ReportProgress: func(phase string, percent int, message string) {
+ reportProgress(report, phase, percent, message)
+ },
+ })
+ case StageTTS:
+ reportProgress(report, "generating_voice", 10, "正在准备配音")
+ inputSRT, err := r.artifactByKind(req, "target_subtitle")
+ if err != nil {
+ return pipeline.Response{}, err
+ }
+ video, _ := r.artifactByKind(req, "source_video")
+ return pipeline.GenerateTTS(ctx, adapter, pipeline.TTSRequest{
+ Workdir: workdir, TaskID: req.StageRunID, InputSRT: inputSRT,
+ LineMode: pipeline.LineModeTargetOnly, Video: video, Voice: optionString(req.Options, "voiceCode"),
+ })
+ case StageRenderHorizontal, StageRenderVertical:
+ reportProgress(report, "rendering_video", 10, "正在准备视频渲染")
+ subtitleStyle, err := subtitleStyleFromOptions(req.Options)
+ if err != nil {
+ return pipeline.Response{}, err
+ }
+ video, err := r.artifactByKind(req, "source_video", "dubbed_video")
+ if err != nil {
+ return pipeline.Response{}, err
+ }
+ subtitle, err := r.renderSubtitleInput(req)
+ if err != nil {
+ return pipeline.Response{}, err
+ }
+ return pipeline.Render(ctx, adapter, pipeline.RenderRequest{
+ Workdir: workdir, TaskID: req.StageRunID, Video: video, Subtitle: subtitle,
+ Horizontal: req.StageType == StageRenderHorizontal,
+ Dubbed: optionBool(req.Options, "dubbed"),
+ MajorTitle: optionString(req.Options, "verticalTitle"),
+ MinorTitle: optionString(req.Options, "verticalSubtitle"),
+ SubtitleStyle: subtitleStyle,
+ })
+ default:
+ return pipeline.Response{}, &RunError{Code: "stage_not_supported", Message: "Unsupported KrillinAI stage", Retryable: false}
+ }
+}
+
+func subtitleStyleFromOptions(options map[string]interface{}) (*subtitlestyle.StyleSet, error) {
+ values := mapObject(options, "subtitleStyle")
+ if values == nil {
+ return nil, nil
+ }
+ data, err := json.Marshal(values)
+ if err != nil {
+ return nil, &RunError{Code: "invalid_subtitle_style", Message: "subtitleStyle must be valid JSON", Retryable: false}
+ }
+ override, err := subtitlestyle.Decode(data, "options.subtitleStyle")
+ if err != nil {
+ return nil, &RunError{Code: "invalid_subtitle_style", Message: err.Error(), Retryable: false}
+ }
+ merged, err := subtitlestyle.Merge(subtitlestyle.DefaultStyleSet(), override)
+ if err != nil {
+ return nil, &RunError{Code: "invalid_subtitle_style", Message: err.Error(), Retryable: false}
+ }
+ return merged, nil
+}
+
+func reportProgress(report ProgressReporter, phase string, percent int, message string) {
+ if report == nil {
+ return
+ }
+ report(phase, percent, message)
+}
+
+func renderSubtitleKinds(stage StageType, options map[string]interface{}) []string {
+ if optionBool(options, "bilingual") {
+ if stage == StageRenderVertical {
+ return []string{"vertical_subtitle", "bilingual_subtitle", "target_subtitle"}
+ }
+ return []string{"bilingual_subtitle", "target_subtitle"}
+ }
+ return []string{"target_subtitle"}
+}
+
+func (r *PipelineRunner) renderSubtitleInput(req CreateTaskRequest) (string, error) {
+ path, kind, err := r.artifactByKindWithKind(req, renderSubtitleKinds(req.StageType, req.Options)...)
+ if err != nil {
+ return "", err
+ }
+ if req.StageType != StageRenderVertical || kind != "bilingual_subtitle" {
+ return path, nil
+ }
+
+ // Jobs created before vertical_subtitle became a first-class artifact still
+ // have the short subtitle beside bilingual_srt.srt in the trusted Job root.
+ legacyShort := filepath.Join(filepath.Dir(path), "short_origin_mixed_srt.srt")
+ info, statErr := os.Stat(legacyShort)
+ if statErr == nil && info.Mode().IsRegular() {
+ return legacyShort, nil
+ }
+ return path, nil
+}
+
+func (r *PipelineRunner) sourceInput(req CreateTaskRequest) (string, error) {
+ if path, err := r.artifactByKind(req, "source_video"); err == nil {
+ return "local:" + path, nil
+ }
+ source := optionString(req.Options, "sourceUrl")
+ if source == "" {
+ return "", &RunError{Code: "source_missing", Message: "A registered source video or sourceUrl is required", Retryable: false}
+ }
+ return source, nil
+}
+
+func (r *PipelineRunner) artifactByKind(req CreateTaskRequest, kinds ...string) (string, error) {
+ path, _, err := r.artifactByKindWithKind(req, kinds...)
+ return path, err
+}
+
+func (r *PipelineRunner) artifactByKindWithKind(req CreateTaskRequest, kinds ...string) (string, string, error) {
+ for _, wanted := range kinds {
+ for _, id := range req.InputArtifactIDs {
+ path, kind, err := r.guard.ResolveArtifact(req.JobID, id)
+ if err == nil && kind == wanted {
+ return path, kind, nil
+ }
+ }
+ }
+ return "", "", &RunError{Code: "input_artifact_missing", Message: fmt.Sprintf("Required artifact is missing: %s", strings.Join(kinds, " or ")), Retryable: false}
+}
+
+func (r *PipelineRunner) collectArtifacts(req CreateTaskRequest, outputs pipeline.Outputs) ([]ResultArtifact, error) {
+ type candidate struct {
+ kind string
+ path string
+ mime string
+ }
+ candidates := []candidate{}
+ switch req.StageType {
+ case StageDownload:
+ candidates = append(candidates, candidate{"source_video", outputs.OriginVideo, "video/mp4"})
+ case StageSubtitle:
+ candidates = append(candidates,
+ candidate{"source_video", outputs.OriginVideo, "video/mp4"},
+ candidate{"source_subtitle", outputs.OriginSRT, "application/x-subrip"},
+ candidate{"target_subtitle", outputs.TargetSRT, "application/x-subrip"},
+ candidate{"bilingual_subtitle", outputs.BilingualSRT, "application/x-subrip"},
+ candidate{"vertical_subtitle", outputs.ShortOriginMixedSRT, "application/x-subrip"},
+ )
+ case StageTTS:
+ candidates = append(candidates,
+ candidate{"dubbed_audio", outputs.TTSAudio, "audio/wav"},
+ candidate{"dubbed_video", outputs.VideoWithTTS, "video/mp4"},
+ )
+ case StageRenderHorizontal:
+ candidates = append(candidates, candidate{"horizontal_video", outputs.HorizontalVideo, "video/mp4"})
+ case StageRenderVertical:
+ candidates = append(candidates, candidate{"vertical_video", outputs.VerticalVideo, "video/mp4"})
+ }
+ artifacts := make([]ResultArtifact, 0, len(candidates))
+ for _, candidate := range candidates {
+ if candidate.path == "" {
+ continue
+ }
+ info, err := os.Stat(candidate.path)
+ if err != nil || !info.Mode().IsRegular() {
+ continue
+ }
+ relative, err := r.guard.RelativeToRoot(candidate.path)
+ if err != nil {
+ return nil, &RunError{Code: "output_path_escape", Message: err.Error(), Retryable: false}
+ }
+ hash, err := fileSHA256(candidate.path)
+ if err != nil {
+ return nil, err
+ }
+ artifacts = append(artifacts, ResultArtifact{
+ ID: req.StageRunID + "_" + strings.ReplaceAll(candidate.kind, "-", "_"),
+ Kind: candidate.kind, RelativePath: relative, MimeType: candidate.mime, Size: info.Size(), SHA256: hash,
+ })
+ }
+ if len(artifacts) == 0 {
+ return nil, &RunError{Code: "output_missing", Message: "KrillinAI produced no output artifacts", Retryable: false}
+ }
+ return artifacts, nil
+}
+
+func applyProviderConfig(values map[string]interface{}) {
+ config.Conf.App.Proxy = mapString(values, "proxy")
+ if llm := mapObject(values, "llm"); llm != nil {
+ config.Conf.Llm.BaseUrl = mapString(llm, "baseUrl")
+ config.Conf.Llm.ApiKey = mapString(llm, "apiKey")
+ config.Conf.Llm.Model = defaultString(mapString(llm, "model"), config.Conf.Llm.Model)
+ }
+ if transcription := mapObject(values, "transcription"); transcription != nil {
+ provider := mapString(transcription, "provider")
+ provider = strings.NewReplacer("faster-whisper", "fasterwhisper", "whisper.cpp", "whispercpp").Replace(provider)
+ if provider != "" {
+ config.Conf.Transcribe.Provider = provider
+ }
+ if gpu, ok := transcription["enableGpuAcceleration"].(bool); ok {
+ config.Conf.Transcribe.EnableGpuAcceleration = gpu
+ }
+ if openai := mapObject(transcription, "openai"); openai != nil {
+ config.Conf.Transcribe.Openai.BaseUrl = mapString(openai, "baseUrl")
+ config.Conf.Transcribe.Openai.ApiKey = mapString(openai, "apiKey")
+ config.Conf.Transcribe.Openai.Model = defaultString(mapString(openai, "model"), config.Conf.Transcribe.Openai.Model)
+ }
+ if local := mapObject(transcription, "fasterWhisper"); local != nil {
+ config.Conf.Transcribe.Fasterwhisper.Model = defaultString(mapString(local, "model"), config.Conf.Transcribe.Fasterwhisper.Model)
+ }
+ if local := mapObject(transcription, "whisperCpp"); local != nil {
+ config.Conf.Transcribe.Whispercpp.Model = defaultString(mapString(local, "model"), config.Conf.Transcribe.Whispercpp.Model)
+ }
+ if local := mapObject(transcription, "whisperKit"); local != nil {
+ config.Conf.Transcribe.Whisperkit.Model = defaultString(mapString(local, "model"), config.Conf.Transcribe.Whisperkit.Model)
+ }
+ if aliyun := mapObject(transcription, "aliyun"); aliyun != nil {
+ applyAliyunOSS(mapObject(aliyun, "oss"), &config.Conf.Transcribe.Aliyun.Oss)
+ applyAliyunSpeech(mapObject(aliyun, "speech"), &config.Conf.Transcribe.Aliyun.Speech)
+ }
+ }
+ if tts := mapObject(values, "tts"); tts != nil {
+ if provider := mapString(tts, "provider"); provider != "" {
+ config.Conf.Tts.Provider = provider
+ }
+ if openai := mapObject(tts, "openai"); openai != nil {
+ config.Conf.Tts.Openai.BaseUrl = mapString(openai, "baseUrl")
+ config.Conf.Tts.Openai.ApiKey = mapString(openai, "apiKey")
+ config.Conf.Tts.Openai.Model = defaultString(mapString(openai, "model"), config.Conf.Tts.Openai.Model)
+ }
+ if minimax := mapObject(tts, "minimax"); minimax != nil {
+ config.Conf.Tts.Minimax.BaseUrl = mapString(minimax, "baseUrl")
+ config.Conf.Tts.Minimax.ApiKey = mapString(minimax, "apiKey")
+ config.Conf.Tts.Minimax.Model = defaultString(mapString(minimax, "model"), config.Conf.Tts.Minimax.Model)
+ }
+ if aliyun := mapObject(tts, "aliyun"); aliyun != nil {
+ applyAliyunOSS(mapObject(aliyun, "oss"), &config.Conf.Tts.Aliyun.Oss)
+ applyAliyunSpeech(mapObject(aliyun, "speech"), &config.Conf.Tts.Aliyun.Speech)
+ }
+ }
+}
+
+func applyAliyunOSS(values map[string]interface{}, target *config.AliyunOssConfig) {
+ if values == nil {
+ return
+ }
+ target.AccessKeyId = mapString(values, "accessKeyId")
+ target.AccessKeySecret = mapString(values, "accessKeySecret")
+ target.Bucket = mapString(values, "bucket")
+}
+
+func applyAliyunSpeech(values map[string]interface{}, target *config.AliyunSpeechConfig) {
+ if values == nil {
+ return
+ }
+ target.AccessKeyId = mapString(values, "accessKeyId")
+ target.AccessKeySecret = mapString(values, "accessKeySecret")
+ target.AppKey = mapString(values, "appKey")
+}
+
+func optionString(values map[string]interface{}, key string) string { return mapString(values, key) }
+
+func optionBool(values map[string]interface{}, key string) bool {
+ value, _ := values[key].(bool)
+ return value
+}
+
+func mapObject(values map[string]interface{}, key string) map[string]interface{} {
+ value, _ := values[key].(map[string]interface{})
+ return value
+}
+
+func mapString(values map[string]interface{}, key string) string {
+ value, _ := values[key].(string)
+ return strings.TrimSpace(value)
+}
+
+func defaultString(value, fallback string) string {
+ if value == "" {
+ return fallback
+ }
+ return value
+}
+
+func runError(code string, err error, retryable bool) *RunError {
+ return &RunError{Code: code, Message: redactSecrets(err.Error()), Retryable: retryable}
+}
+
+func redactSecrets(value string) string {
+ for _, marker := range []string{"api_key", "apiKey", "token", "secret", "accessKeySecret"} {
+ if strings.Contains(strings.ToLower(value), strings.ToLower(marker)) {
+ return "Provider configuration is invalid or unavailable"
+ }
+ }
+ return value
+}
+
+func fileSHA256(path string) (string, error) {
+ data, err := os.ReadFile(path)
+ if err != nil {
+ return "", err
+ }
+ sum := sha256.Sum256(data)
+ return hex.EncodeToString(sum[:]), nil
+}
+
+func newResultManifest(task Task, result RunResult) (ResultManifest, error) {
+ id, err := randomID("manifest")
+ if err != nil {
+ return ResultManifest{}, err
+ }
+ return ResultManifest{
+ ProtocolVersion: ProtocolVersion, ID: id, TaskID: task.ID, JobID: task.JobID,
+ StageRunID: task.StageRunID, Artifacts: result.Artifacts, Metadata: result.Metadata, CreatedAt: time.Now().UTC(),
+ }, nil
+}
+
+func writeResultManifest(guard *PathGuard, task Task, manifest ResultManifest) error {
+ dir, err := guard.TaskDir(task.JobID, task.ID)
+ if err != nil {
+ return err
+ }
+ return atomicWriteJSON(filepath.Join(dir, "result-manifest.json"), manifest)
+}
diff --git a/internal/opencreatorapi/runner_options_test.go b/internal/opencreatorapi/runner_options_test.go
new file mode 100644
index 00000000..75ba9fb7
--- /dev/null
+++ b/internal/opencreatorapi/runner_options_test.go
@@ -0,0 +1,169 @@
+package opencreatorapi
+
+import (
+ "encoding/json"
+ "os"
+ "path/filepath"
+ "reflect"
+ "testing"
+
+ "krillin-ai/internal/pipeline"
+)
+
+func TestRenderSubtitleKindsUsesBilingualOnlyWhenRequested(t *testing.T) {
+ tests := []struct {
+ name string
+ stage StageType
+ options map[string]interface{}
+ want []string
+ }{
+ {name: "target only", stage: StageRenderHorizontal, options: map[string]interface{}{}, want: []string{"target_subtitle"}},
+ {name: "horizontal bilingual", stage: StageRenderHorizontal, options: map[string]interface{}{"bilingual": true}, want: []string{"bilingual_subtitle", "target_subtitle"}},
+ {name: "vertical bilingual", stage: StageRenderVertical, options: map[string]interface{}{"bilingual": true}, want: []string{"vertical_subtitle", "bilingual_subtitle", "target_subtitle"}},
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ if got := renderSubtitleKinds(test.stage, test.options); !reflect.DeepEqual(got, test.want) {
+ t.Fatalf("renderSubtitleKinds() = %v, want %v", got, test.want)
+ }
+ })
+ }
+}
+
+func TestRenderSubtitleInputUsesHistoricalShortSubtitle(t *testing.T) {
+ guard, err := NewPathGuard(t.TempDir())
+ if err != nil {
+ t.Fatal(err)
+ }
+ jobDir, err := guard.JobDir("job_1")
+ if err != nil {
+ t.Fatal(err)
+ }
+ subtitleDir := filepath.Join(jobDir, "stages", "subtitle_stage", "krillin")
+ if err := os.MkdirAll(subtitleDir, 0700); err != nil {
+ t.Fatal(err)
+ }
+ bilingual := filepath.Join(subtitleDir, "bilingual_srt.srt")
+ short := filepath.Join(subtitleDir, "short_origin_mixed_srt.srt")
+ if err := os.WriteFile(bilingual, []byte("bilingual"), 0600); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(short, []byte("short"), 0600); err != nil {
+ t.Fatal(err)
+ }
+ index := artifactIndex{Artifacts: []artifactIndexEntry{{
+ ID: "subtitle_1", Kind: "bilingual_subtitle",
+ RelativePath: filepath.ToSlash(filepath.Join("stages", "subtitle_stage", "krillin", "bilingual_srt.srt")),
+ }}}
+ data, err := json.Marshal(index)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(jobDir, "artifact-index.json"), data, 0600); err != nil {
+ t.Fatal(err)
+ }
+
+ runner := NewPipelineRunner(guard)
+ got, err := runner.renderSubtitleInput(CreateTaskRequest{
+ JobID: "job_1", StageType: StageRenderVertical,
+ InputArtifactIDs: []string{"subtitle_1"},
+ Options: map[string]interface{}{"bilingual": true},
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got != short {
+ t.Fatalf("renderSubtitleInput() = %q, want historical short subtitle %q", got, short)
+ }
+}
+
+func TestCollectSubtitleArtifactsIncludesVerticalSubtitle(t *testing.T) {
+ guard, err := NewPathGuard(t.TempDir())
+ if err != nil {
+ t.Fatal(err)
+ }
+ workdir, err := guard.StageWorkdir("job_1", "stage_1")
+ if err != nil {
+ t.Fatal(err)
+ }
+ paths := pipeline.Outputs{
+ OriginVideo: filepath.Join(workdir, "origin_video.mp4"),
+ OriginSRT: filepath.Join(workdir, "origin_language_srt.srt"),
+ TargetSRT: filepath.Join(workdir, "target_language_srt.srt"),
+ BilingualSRT: filepath.Join(workdir, "bilingual_srt.srt"),
+ ShortOriginMixedSRT: filepath.Join(workdir, "short_origin_mixed_srt.srt"),
+ }
+ for _, path := range []string{
+ paths.OriginVideo,
+ paths.OriginSRT,
+ paths.TargetSRT,
+ paths.BilingualSRT,
+ paths.ShortOriginMixedSRT,
+ } {
+ if err := os.WriteFile(path, []byte("fixture"), 0600); err != nil {
+ t.Fatal(err)
+ }
+ }
+
+ runner := NewPipelineRunner(guard)
+ artifacts, err := runner.collectArtifacts(CreateTaskRequest{
+ JobID: "job_1", StageRunID: "stage_1", StageType: StageSubtitle,
+ }, paths)
+ if err != nil {
+ t.Fatal(err)
+ }
+ found := false
+ for _, artifact := range artifacts {
+ if artifact.Kind == "vertical_subtitle" {
+ found = true
+ if filepath.Base(artifact.RelativePath) != "short_origin_mixed_srt.srt" {
+ t.Fatalf("vertical subtitle path = %q", artifact.RelativePath)
+ }
+ }
+ }
+ if !found {
+ t.Fatal("vertical_subtitle artifact was not collected")
+ }
+}
+
+func TestSubtitleStyleFromOptionsMapsMinorPrimaryColor(t *testing.T) {
+ style, err := subtitleStyleFromOptions(map[string]interface{}{
+ "subtitleStyle": map[string]interface{}{
+ "version": float64(1),
+ "horizontal": map[string]interface{}{
+ "major": map[string]interface{}{
+ "primary_color": "#FFE0A3",
+ "outline_color": "#2B1B12",
+ "outline": float64(4),
+ },
+ "minor": map[string]interface{}{
+ "primary_color": "#FFFFFF",
+ "outline_color": "#2B1B12",
+ "outline": float64(4),
+ },
+ },
+ "vertical": map[string]interface{}{
+ "major": map[string]interface{}{"primary_color": "#FFE0A3"},
+ "minor": map[string]interface{}{"primary_color": "#FFFFFF"},
+ },
+ },
+ })
+ if err != nil {
+ t.Fatalf("subtitleStyleFromOptions() error = %v", err)
+ }
+ if style.Horizontal.Major.PrimaryColor != "#FFE0A3" {
+ t.Fatalf("horizontal Major primary color = %q", style.Horizontal.Major.PrimaryColor)
+ }
+ if style.Horizontal.Minor.PrimaryColor != "#FFFFFF" {
+ t.Fatalf("horizontal Minor primary color = %q, want English subtitle white", style.Horizontal.Minor.PrimaryColor)
+ }
+ if style.Vertical.Minor.PrimaryColor != "#FFFFFF" {
+ t.Fatalf("vertical Minor primary color = %q, want English subtitle white", style.Vertical.Minor.PrimaryColor)
+ }
+ if style.Horizontal.Minor.Outline == nil || *style.Horizontal.Minor.Outline != 4 {
+ t.Fatalf("horizontal Minor outline = %v, want 4", style.Horizontal.Minor.Outline)
+ }
+ if style.Horizontal.Minor.FontSize == nil || *style.Horizontal.Minor.FontSize != 10 {
+ t.Fatalf("horizontal Minor default font size was not preserved: %v", style.Horizontal.Minor.FontSize)
+ }
+}
diff --git a/internal/opencreatorapi/server.go b/internal/opencreatorapi/server.go
new file mode 100644
index 00000000..0b41b050
--- /dev/null
+++ b/internal/opencreatorapi/server.go
@@ -0,0 +1,178 @@
+package opencreatorapi
+
+import (
+ "crypto/subtle"
+ "encoding/json"
+ "errors"
+ "io"
+ "net/http"
+ "strconv"
+ "strings"
+)
+
+type ServerConfig struct {
+ Token string
+ ServiceVersion string
+ Generation int64
+ Manager *Manager
+}
+
+type Server struct {
+ token string
+ serviceVersion string
+ generation int64
+ manager *Manager
+ handler http.Handler
+}
+
+func NewServer(config ServerConfig) (*Server, error) {
+ if len(config.Token) < 32 {
+ return nil, errors.New("service token must contain at least 256 bits")
+ }
+ if config.Manager == nil {
+ return nil, errors.New("manager is required")
+ }
+ server := &Server{
+ token: config.Token, serviceVersion: config.ServiceVersion, generation: config.Generation, manager: config.Manager,
+ }
+ server.handler = server.authenticate(http.HandlerFunc(server.route))
+ return server, nil
+}
+
+func (s *Server) Handler() http.Handler {
+ return s.handler
+}
+
+func (s *Server) authenticate(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ provided := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
+ if len(provided) != len(s.token) || subtle.ConstantTimeCompare([]byte(provided), []byte(s.token)) != 1 {
+ writeError(w, http.StatusUnauthorized, "unauthorized", "Bearer token is invalid")
+ return
+ }
+ next.ServeHTTP(w, r)
+ })
+}
+
+func (s *Server) route(w http.ResponseWriter, r *http.Request) {
+ path := strings.TrimSuffix(r.URL.Path, "/")
+ if path == "/v1/health" && r.Method == http.MethodGet {
+ writeJSON(w, http.StatusOK, map[string]interface{}{"ok": true, "generation": s.generation})
+ return
+ }
+ if path == "/v1/capabilities" && r.Method == http.MethodGet {
+ writeJSON(w, http.StatusOK, CapabilitiesResponse{
+ ProtocolVersion: ProtocolVersion, ServiceVersion: s.serviceVersion, Generation: s.generation, Stages: allStages(),
+ })
+ return
+ }
+ if path == "/v1/tasks" && r.Method == http.MethodPost {
+ s.createTask(w, r)
+ return
+ }
+ parts := strings.Split(strings.TrimPrefix(path, "/v1/tasks/"), "/")
+ if !strings.HasPrefix(path, "/v1/tasks/") || len(parts) == 0 || validateIdentifier(parts[0]) != nil {
+ writeError(w, http.StatusNotFound, "route_not_found", "Route not found")
+ return
+ }
+ taskID := parts[0]
+ if len(parts) == 1 && r.Method == http.MethodGet {
+ task, err := s.manager.Get(taskID)
+ writeTaskResult(w, task, err)
+ return
+ }
+ if len(parts) == 2 && parts[1] == "cancel" && r.Method == http.MethodPost {
+ task, err := s.manager.Cancel(taskID)
+ writeTaskResult(w, task, err)
+ return
+ }
+ if len(parts) == 2 && parts[1] == "events" && r.Method == http.MethodGet {
+ afterSeq, err := strconv.ParseInt(defaultString(r.URL.Query().Get("afterSeq"), "0"), 10, 64)
+ if err != nil || afterSeq < 0 {
+ writeError(w, http.StatusBadRequest, "invalid_event_cursor", "afterSeq must be a non-negative integer")
+ return
+ }
+ response, err := s.manager.Events(taskID, afterSeq)
+ if err != nil {
+ writeManagerError(w, err)
+ return
+ }
+ writeJSON(w, http.StatusOK, response)
+ return
+ }
+ if len(parts) == 2 && parts[1] == "result" && r.Method == http.MethodGet {
+ manifest, err := s.manager.Result(taskID)
+ if err != nil {
+ writeManagerError(w, err)
+ return
+ }
+ writeJSON(w, http.StatusOK, manifest)
+ return
+ }
+ writeError(w, http.StatusNotFound, "route_not_found", "Route not found")
+}
+
+func (s *Server) createTask(w http.ResponseWriter, r *http.Request) {
+ defer r.Body.Close()
+ decoder := json.NewDecoder(io.LimitReader(r.Body, 2<<20))
+ decoder.DisallowUnknownFields()
+ var req CreateTaskRequest
+ if err := decoder.Decode(&req); err != nil {
+ writeError(w, http.StatusBadRequest, "invalid_request", "Request body does not match Protocol V1")
+ return
+ }
+ if err := decoder.Decode(&struct{}{}); err != io.EOF {
+ writeError(w, http.StatusBadRequest, "invalid_request", "Request body must contain one JSON object")
+ return
+ }
+ task, replay, err := s.manager.Create(req)
+ if err != nil {
+ writeManagerError(w, err)
+ return
+ }
+ status := http.StatusAccepted
+ if replay {
+ status = http.StatusOK
+ }
+ writeJSON(w, status, task)
+}
+
+func writeTaskResult(w http.ResponseWriter, task Task, err error) {
+ if err != nil {
+ writeManagerError(w, err)
+ return
+ }
+ writeJSON(w, http.StatusOK, task)
+}
+
+func writeManagerError(w http.ResponseWriter, err error) {
+ if errors.Is(err, ErrTaskNotFound) {
+ writeError(w, http.StatusNotFound, "task_not_found", "Task was not found")
+ return
+ }
+ if errors.Is(err, ErrIdempotencyKeyReuse) {
+ writeError(w, http.StatusConflict, "idempotency_key_reused", "Idempotency key was reused with a different request hash")
+ return
+ }
+ var runErr *RunError
+ if errors.As(err, &runErr) {
+ writeError(w, http.StatusBadRequest, runErr.Code, runErr.Message)
+ return
+ }
+ if err.Error() == "result_not_ready" {
+ writeError(w, http.StatusConflict, "result_not_ready", "Task result is not ready")
+ return
+ }
+ writeError(w, http.StatusInternalServerError, "internal_error", "KrillinAI service request failed")
+}
+
+func writeError(w http.ResponseWriter, status int, code, message string) {
+ writeJSON(w, status, APIError{Error: TaskError{Code: code, Message: message, Retryable: status >= 500}})
+}
+
+func writeJSON(w http.ResponseWriter, status int, value interface{}) {
+ w.Header().Set("Content-Type", "application/json")
+ w.Header().Set("Cache-Control", "no-store")
+ w.WriteHeader(status)
+ _ = json.NewEncoder(w).Encode(value)
+}
diff --git a/internal/opencreatorapi/server_test.go b/internal/opencreatorapi/server_test.go
new file mode 100644
index 00000000..3cef984a
--- /dev/null
+++ b/internal/opencreatorapi/server_test.go
@@ -0,0 +1,308 @@
+package opencreatorapi
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+ "time"
+)
+
+const testToken = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+
+type fakeRunner struct {
+ block <-chan struct{}
+}
+
+func (r fakeRunner) Run(ctx context.Context, req CreateTaskRequest, workdir string, report ProgressReporter) (RunResult, error) {
+ if report != nil {
+ report("translating_subtitles", 45, "正在翻译字幕")
+ }
+ if r.block != nil {
+ select {
+ case <-r.block:
+ case <-ctx.Done():
+ return RunResult{}, ctx.Err()
+ }
+ }
+ path := filepath.Join(workdir, "target.srt")
+ if err := os.WriteFile(path, []byte("1\n00:00:00,000 --> 00:00:01,000\n你好\n"), 0600); err != nil {
+ return RunResult{}, err
+ }
+ relative, err := filepath.Rel(filepath.Dir(filepath.Dir(filepath.Dir(workdir))), path)
+ if err != nil {
+ return RunResult{}, err
+ }
+ return RunResult{Artifacts: []ResultArtifact{{
+ ID: req.StageRunID + "_target_subtitle", Kind: "target_subtitle", RelativePath: filepath.ToSlash(relative),
+ }}, Metadata: map[string]interface{}{"captionSource": "test"}}, nil
+}
+
+func TestServerRequiresBearerAuthForEveryRoute(t *testing.T) {
+ server, manager := newTestServer(t, fakeRunner{})
+ defer manager.Close()
+ for _, path := range []string{"/v1/health", "/v1/capabilities", "/v1/tasks/task_missing", "/api/config"} {
+ req := httptest.NewRequest(http.MethodGet, path, nil)
+ response := httptest.NewRecorder()
+ server.Handler().ServeHTTP(response, req)
+ if response.Code != http.StatusUnauthorized {
+ t.Fatalf("%s status = %d, want 401", path, response.Code)
+ }
+ }
+}
+
+func TestCreateTaskIsIdempotentAndEventsResumeAfterCursor(t *testing.T) {
+ server, manager := newTestServer(t, fakeRunner{})
+ defer manager.Close()
+ request := validRequest()
+ first := callJSON(t, server.Handler(), http.MethodPost, "/v1/tasks", request, testToken)
+ if first.Code != http.StatusAccepted {
+ t.Fatalf("first create status = %d: %s", first.Code, first.Body.String())
+ }
+ var task Task
+ decodeResponse(t, first, &task)
+ waitForStatus(t, manager, task.ID, StatusSucceeded)
+
+ replay := callJSON(t, server.Handler(), http.MethodPost, "/v1/tasks", request, testToken)
+ if replay.Code != http.StatusOK {
+ t.Fatalf("replay status = %d: %s", replay.Code, replay.Body.String())
+ }
+ var replayed Task
+ decodeResponse(t, replay, &replayed)
+ if replayed.ID != task.ID {
+ t.Fatalf("replayed task id = %s, want %s", replayed.ID, task.ID)
+ }
+
+ events := callJSON(t, server.Handler(), http.MethodGet, "/v1/tasks/"+task.ID+"/events?afterSeq=1", nil, testToken)
+ var page TaskEventsResponse
+ decodeResponse(t, events, &page)
+ if len(page.Events) < 2 || page.Events[0].Seq != 2 || page.NextSeq != page.Events[len(page.Events)-1].Seq {
+ t.Fatalf("unexpected event page: %+v", page)
+ }
+
+ request.RequestHash = strings.Repeat("b", 64)
+ conflict := callJSON(t, server.Handler(), http.MethodPost, "/v1/tasks", request, testToken)
+ if conflict.Code != http.StatusConflict || !strings.Contains(conflict.Body.String(), "idempotency_key_reused") {
+ t.Fatalf("conflict = %d: %s", conflict.Code, conflict.Body.String())
+ }
+}
+
+func TestRunnerProgressIsPersistedInOrder(t *testing.T) {
+ server, manager := newTestServer(t, fakeRunner{})
+ defer manager.Close()
+ response := callJSON(t, server.Handler(), http.MethodPost, "/v1/tasks", validRequest(), testToken)
+ var task Task
+ decodeResponse(t, response, &task)
+ waitForStatus(t, manager, task.ID, StatusSucceeded)
+
+ events, err := manager.Events(task.ID, 0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(events.Events) != 4 {
+ t.Fatalf("event count = %d, want 4: %+v", len(events.Events), events.Events)
+ }
+ progress := events.Events[2]
+ if progress.Type != "progress" || progress.Payload["phase"] != "translating_subtitles" || progress.Payload["percent"] != 45 {
+ t.Fatalf("progress event = %+v", progress)
+ }
+ for index, event := range events.Events {
+ if event.Seq != int64(index+1) {
+ t.Fatalf("event sequence at %d = %d", index, event.Seq)
+ }
+ }
+}
+
+func TestProviderConfigNeverPersistsAndResultPrecedesSuccess(t *testing.T) {
+ root := t.TempDir()
+ manager, err := NewManager(root, fakeRunner{})
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer manager.Close()
+ req := validRequest()
+ req.ProviderConfig = map[string]interface{}{
+ "transcription": map[string]interface{}{
+ "provider": "openai",
+ "openai": map[string]interface{}{"apiKey": "super-secret-provider-key"},
+ },
+ }
+ task, _, err := manager.Create(req)
+ if err != nil {
+ t.Fatal(err)
+ }
+ task = waitForStatus(t, manager, task.ID, StatusSucceeded)
+ manifest, err := manager.Result(task.ID)
+ if err != nil || manifest.ID != task.ResultManifestID {
+ t.Fatalf("manifest must exist before succeeded is observable: %+v, %v", manifest, err)
+ }
+ err = filepath.Walk(root, func(path string, info os.FileInfo, walkErr error) error {
+ if walkErr != nil || info.IsDir() {
+ return walkErr
+ }
+ data, readErr := os.ReadFile(path)
+ if readErr != nil {
+ return readErr
+ }
+ if bytes.Contains(data, []byte("super-secret-provider-key")) {
+ t.Fatalf("provider secret persisted in %s", path)
+ }
+ return nil
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+}
+
+func TestCancelIsTerminalAndDoesNotAppendDuplicateEvent(t *testing.T) {
+ block := make(chan struct{})
+ manager, err := NewManager(t.TempDir(), fakeRunner{block: block})
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer manager.Close()
+ task, _, err := manager.Create(validRequest())
+ if err != nil {
+ t.Fatal(err)
+ }
+ waitForStatus(t, manager, task.ID, StatusRunning)
+ canceled, err := manager.Cancel(task.ID)
+ if err != nil || canceled.Status != StatusCanceled {
+ t.Fatalf("cancel = %+v, %v", canceled, err)
+ }
+ seq := canceled.LastEventSeq
+ again, err := manager.Cancel(task.ID)
+ if err != nil || again.LastEventSeq != seq {
+ t.Fatalf("duplicate cancel changed terminal task: %+v, %v", again, err)
+ }
+}
+
+func TestRestartInterruptsRunningTask(t *testing.T) {
+ guard, err := NewPathGuard(t.TempDir())
+ if err != nil {
+ t.Fatal(err)
+ }
+ store, err := NewStore(guard)
+ if err != nil {
+ t.Fatal(err)
+ }
+ task, _, err := store.Create(validRequest())
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := store.Start(task.ID, func() {}); err != nil {
+ t.Fatal(err)
+ }
+ restarted, err := NewStore(guard)
+ if err != nil {
+ t.Fatal(err)
+ }
+ recovered, err := restarted.Get(task.ID)
+ if err != nil || recovered.Status != StatusInterrupted {
+ t.Fatalf("recovered = %+v, %v", recovered, err)
+ }
+ events, err := restarted.Events(task.ID, 0)
+ if err != nil || fmt.Sprint(events.Events[len(events.Events)-1].Payload["status"]) != string(StatusInterrupted) {
+ t.Fatalf("restart events = %+v, %v", events, err)
+ }
+}
+
+func TestPathGuardRejectsAbsoluteEscapeAndCrossJobArtifact(t *testing.T) {
+ guard, err := NewPathGuard(t.TempDir())
+ if err != nil {
+ t.Fatal(err)
+ }
+ jobA, _ := guard.JobDir("job_a")
+ jobB, _ := guard.JobDir("job_b")
+ outside := filepath.Join(jobB, "video.mp4")
+ if err := os.WriteFile(outside, []byte("video"), 0600); err != nil {
+ t.Fatal(err)
+ }
+ index := artifactIndex{Artifacts: []artifactIndexEntry{{ID: "source_1", Kind: "source_video", RelativePath: outside}}}
+ data, _ := json.Marshal(index)
+ if err := os.WriteFile(filepath.Join(jobA, "artifact-index.json"), data, 0600); err != nil {
+ t.Fatal(err)
+ }
+ if _, _, err := guard.ResolveArtifact("job_a", "source_1"); err == nil {
+ t.Fatal("absolute cross-job artifact path was accepted")
+ }
+
+ if err := os.Symlink(outside, filepath.Join(jobA, "linked.mp4")); err == nil {
+ index.Artifacts[0].RelativePath = "linked.mp4"
+ data, _ = json.Marshal(index)
+ _ = os.WriteFile(filepath.Join(jobA, "artifact-index.json"), data, 0600)
+ if _, _, err := guard.ResolveArtifact("job_a", "source_1"); err == nil {
+ t.Fatal("symlink escape was accepted")
+ }
+ }
+}
+
+func newTestServer(t *testing.T, runner StageRunner) (*Server, *Manager) {
+ t.Helper()
+ manager, err := NewManager(t.TempDir(), runner)
+ if err != nil {
+ t.Fatal(err)
+ }
+ server, err := NewServer(ServerConfig{Token: testToken, ServiceVersion: "test", Generation: 1, Manager: manager})
+ if err != nil {
+ manager.Close()
+ t.Fatal(err)
+ }
+ return server, manager
+}
+
+func validRequest() CreateTaskRequest {
+ return CreateTaskRequest{
+ ProtocolVersion: ProtocolVersion, JobID: "job_1", StageRunID: "stage_1", StageType: StageSubtitle,
+ IdempotencyKey: "stage_1", RequestHash: strings.Repeat("a", 64), InputArtifactIDs: []string{},
+ Options: map[string]interface{}{"sourceUrl": "https://www.youtube.com/watch?v=test"},
+ }
+}
+
+func callJSON(t *testing.T, handler http.Handler, method, path string, body interface{}, token string) *httptest.ResponseRecorder {
+ t.Helper()
+ var reader io.Reader
+ if body != nil {
+ data, err := json.Marshal(body)
+ if err != nil {
+ t.Fatal(err)
+ }
+ reader = bytes.NewReader(data)
+ }
+ req := httptest.NewRequest(method, path, reader)
+ if token != "" {
+ req.Header.Set("Authorization", "Bearer "+token)
+ }
+ response := httptest.NewRecorder()
+ handler.ServeHTTP(response, req)
+ return response
+}
+
+func decodeResponse(t *testing.T, response *httptest.ResponseRecorder, value interface{}) {
+ t.Helper()
+ if err := json.Unmarshal(response.Body.Bytes(), value); err != nil {
+ t.Fatalf("decode response: %v: %s", err, response.Body.String())
+ }
+}
+
+func waitForStatus(t *testing.T, manager *Manager, taskID string, status TaskStatus) Task {
+ t.Helper()
+ deadline := time.Now().Add(3 * time.Second)
+ for time.Now().Before(deadline) {
+ task, err := manager.Get(taskID)
+ if err == nil && task.Status == status {
+ return task
+ }
+ time.Sleep(10 * time.Millisecond)
+ }
+ task, _ := manager.Get(taskID)
+ t.Fatalf("task status = %s, want %s", task.Status, status)
+ return Task{}
+}
diff --git a/internal/opencreatorapi/store.go b/internal/opencreatorapi/store.go
new file mode 100644
index 00000000..38a0f45e
--- /dev/null
+++ b/internal/opencreatorapi/store.go
@@ -0,0 +1,457 @@
+package opencreatorapi
+
+import (
+ "bufio"
+ "context"
+ "crypto/rand"
+ "encoding/hex"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "os"
+ "path/filepath"
+ "sort"
+ "sync"
+ "time"
+)
+
+var (
+ ErrTaskNotFound = errors.New("task_not_found")
+ ErrIdempotencyKeyReuse = errors.New("idempotency_key_reused")
+)
+
+type storedTask struct {
+ Task Task `json:"task"`
+ IdempotencyKey string `json:"idempotencyKey"`
+ RequestHash string `json:"requestHash"`
+ InputArtifactIDs []string `json:"inputArtifactIds"`
+ Options map[string]interface{} `json:"options"`
+}
+
+type Store struct {
+ mu sync.Mutex
+ guard *PathGuard
+ tasks map[string]*storedTask
+ idempotency map[string]string
+ events map[string][]TaskEvent
+ cancels map[string]context.CancelFunc
+}
+
+func NewStore(guard *PathGuard) (*Store, error) {
+ store := &Store{
+ guard: guard,
+ tasks: make(map[string]*storedTask),
+ idempotency: make(map[string]string),
+ events: make(map[string][]TaskEvent),
+ cancels: make(map[string]context.CancelFunc),
+ }
+ if err := store.load(); err != nil {
+ return nil, err
+ }
+ return store, nil
+}
+
+func (s *Store) Create(req CreateTaskRequest) (Task, bool, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ key := req.JobID + "\x00" + req.IdempotencyKey
+ if existingID, ok := s.idempotency[key]; ok {
+ existing := s.tasks[existingID]
+ if existing.RequestHash != req.RequestHash {
+ return Task{}, false, ErrIdempotencyKeyReuse
+ }
+ return existing.Task, true, nil
+ }
+ now := time.Now().UTC()
+ id, err := randomID("task")
+ if err != nil {
+ return Task{}, false, err
+ }
+ record := &storedTask{
+ Task: Task{
+ ID: id,
+ JobID: req.JobID,
+ StageRunID: req.StageRunID,
+ StageType: req.StageType,
+ Status: StatusQueued,
+ LastEventSeq: 0,
+ CreatedAt: now,
+ UpdatedAt: now,
+ },
+ IdempotencyKey: req.IdempotencyKey,
+ RequestHash: req.RequestHash,
+ InputArtifactIDs: append([]string(nil), req.InputArtifactIDs...),
+ Options: cloneMap(req.Options),
+ }
+ if err := s.persistRecord(record); err != nil {
+ return Task{}, false, err
+ }
+ s.tasks[id] = record
+ s.idempotency[key] = id
+ if err := s.appendEventLocked(record, "status", map[string]interface{}{"status": StatusQueued}); err != nil {
+ delete(s.tasks, id)
+ delete(s.idempotency, key)
+ return Task{}, false, err
+ }
+ return record.Task, false, nil
+}
+
+func (s *Store) Get(taskID string) (Task, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ record := s.tasks[taskID]
+ if record == nil {
+ return Task{}, ErrTaskNotFound
+ }
+ return record.Task, nil
+}
+
+func (s *Store) Record(taskID string) (storedTask, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ record := s.tasks[taskID]
+ if record == nil {
+ return storedTask{}, ErrTaskNotFound
+ }
+ copy := *record
+ copy.InputArtifactIDs = append([]string(nil), record.InputArtifactIDs...)
+ copy.Options = cloneMap(record.Options)
+ return copy, nil
+}
+
+func (s *Store) Events(taskID string, afterSeq int64) (TaskEventsResponse, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ if s.tasks[taskID] == nil {
+ return TaskEventsResponse{}, ErrTaskNotFound
+ }
+ result := make([]TaskEvent, 0)
+ for _, event := range s.events[taskID] {
+ if event.Seq > afterSeq {
+ result = append(result, event)
+ }
+ }
+ next := afterSeq
+ if len(result) > 0 {
+ next = result[len(result)-1].Seq
+ } else if task := s.tasks[taskID]; task != nil && task.Task.LastEventSeq > next {
+ next = task.Task.LastEventSeq
+ }
+ return TaskEventsResponse{Events: result, NextSeq: next}, nil
+}
+
+func (s *Store) Start(taskID string, cancel context.CancelFunc) (Task, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ record := s.tasks[taskID]
+ if record == nil {
+ return Task{}, ErrTaskNotFound
+ }
+ if record.Task.Status != StatusQueued {
+ return record.Task, nil
+ }
+ s.cancels[taskID] = cancel
+ if err := s.transitionLocked(record, StatusRunning, nil, "status", map[string]interface{}{"status": StatusRunning}); err != nil {
+ delete(s.cancels, taskID)
+ return Task{}, err
+ }
+ return record.Task, nil
+}
+
+func (s *Store) Progress(taskID, phase string, percent int, message string) (Task, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ record := s.tasks[taskID]
+ if record == nil {
+ return Task{}, ErrTaskNotFound
+ }
+ if record.Task.Status != StatusRunning {
+ return record.Task, nil
+ }
+ if percent < 0 {
+ percent = 0
+ }
+ if percent > 100 {
+ percent = 100
+ }
+ payload := map[string]interface{}{
+ "phase": phase,
+ "percent": percent,
+ "message": message,
+ }
+ if events := s.events[taskID]; len(events) > 0 {
+ last := events[len(events)-1]
+ if last.Type == "progress" &&
+ fmt.Sprint(last.Payload["phase"]) == phase &&
+ fmt.Sprint(last.Payload["percent"]) == fmt.Sprint(percent) &&
+ fmt.Sprint(last.Payload["message"]) == message {
+ return record.Task, nil
+ }
+ }
+ if err := s.appendEventLocked(record, "progress", payload); err != nil {
+ return Task{}, err
+ }
+ return record.Task, nil
+}
+
+func (s *Store) Complete(taskID, manifestID string) (Task, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ record := s.tasks[taskID]
+ if record == nil {
+ return Task{}, ErrTaskNotFound
+ }
+ if record.Task.Status == StatusCanceled {
+ return record.Task, nil
+ }
+ if record.Task.Status != StatusRunning {
+ return Task{}, fmt.Errorf("invalid task transition: %s to %s", record.Task.Status, StatusSucceeded)
+ }
+ record.Task.ResultManifestID = manifestID
+ delete(s.cancels, taskID)
+ if err := s.transitionLocked(record, StatusSucceeded, nil, "result", map[string]interface{}{
+ "status": StatusSucceeded, "resultManifestId": manifestID,
+ }); err != nil {
+ return Task{}, err
+ }
+ return record.Task, nil
+}
+
+func (s *Store) Fail(taskID string, taskError TaskError) (Task, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ record := s.tasks[taskID]
+ if record == nil {
+ return Task{}, ErrTaskNotFound
+ }
+ if record.Task.Status == StatusCanceled {
+ return record.Task, nil
+ }
+ if record.Task.Status != StatusRunning && record.Task.Status != StatusQueued {
+ return record.Task, nil
+ }
+ delete(s.cancels, taskID)
+ if err := s.transitionLocked(record, StatusFailed, &taskError, "error", map[string]interface{}{
+ "status": StatusFailed, "error": taskError,
+ }); err != nil {
+ return Task{}, err
+ }
+ return record.Task, nil
+}
+
+func (s *Store) Cancel(taskID string) (Task, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ record := s.tasks[taskID]
+ if record == nil {
+ return Task{}, ErrTaskNotFound
+ }
+ if isTerminal(record.Task.Status) {
+ return record.Task, nil
+ }
+ if cancel := s.cancels[taskID]; cancel != nil {
+ cancel()
+ }
+ delete(s.cancels, taskID)
+ if err := s.transitionLocked(record, StatusCanceled, nil, "status", map[string]interface{}{"status": StatusCanceled}); err != nil {
+ return Task{}, err
+ }
+ return record.Task, nil
+}
+
+func (s *Store) Result(taskID string) (ResultManifest, error) {
+ s.mu.Lock()
+ record := s.tasks[taskID]
+ if record == nil {
+ s.mu.Unlock()
+ return ResultManifest{}, ErrTaskNotFound
+ }
+ if record.Task.Status != StatusSucceeded || record.Task.ResultManifestID == "" {
+ s.mu.Unlock()
+ return ResultManifest{}, errors.New("result_not_ready")
+ }
+ dir, err := s.guard.TaskDir(record.Task.JobID, record.Task.ID)
+ s.mu.Unlock()
+ if err != nil {
+ return ResultManifest{}, err
+ }
+ data, err := os.ReadFile(filepath.Join(dir, "result-manifest.json"))
+ if err != nil {
+ return ResultManifest{}, err
+ }
+ var manifest ResultManifest
+ if err := json.Unmarshal(data, &manifest); err != nil {
+ return ResultManifest{}, err
+ }
+ return manifest, nil
+}
+
+func (s *Store) transitionLocked(record *storedTask, status TaskStatus, taskError *TaskError, eventType string, payload map[string]interface{}) error {
+ record.Task.Status = status
+ record.Task.Error = taskError
+ record.Task.UpdatedAt = time.Now().UTC()
+ return s.appendEventLocked(record, eventType, payload)
+}
+
+func (s *Store) appendEventLocked(record *storedTask, eventType string, payload map[string]interface{}) error {
+ event := TaskEvent{
+ TaskID: record.Task.ID,
+ Seq: record.Task.LastEventSeq + 1,
+ Type: eventType,
+ Payload: payload,
+ CreatedAt: time.Now().UTC(),
+ }
+ record.Task.LastEventSeq = event.Seq
+ record.Task.UpdatedAt = event.CreatedAt
+ events := append(append([]TaskEvent(nil), s.events[record.Task.ID]...), event)
+ if err := s.persistEvents(record, events); err != nil {
+ return err
+ }
+ if err := s.persistRecord(record); err != nil {
+ return err
+ }
+ s.events[record.Task.ID] = events
+ return nil
+}
+
+func (s *Store) persistRecord(record *storedTask) error {
+ dir, err := s.guard.TaskDir(record.Task.JobID, record.Task.ID)
+ if err != nil {
+ return err
+ }
+ return atomicWriteJSON(filepath.Join(dir, "task.json"), record)
+}
+
+func (s *Store) persistEvents(record *storedTask, events []TaskEvent) error {
+ dir, err := s.guard.TaskDir(record.Task.JobID, record.Task.ID)
+ if err != nil {
+ return err
+ }
+ return atomicWriteJSON(filepath.Join(dir, "events.json"), events)
+}
+
+func (s *Store) load() error {
+ jobs, err := os.ReadDir(s.guard.Root())
+ if err != nil {
+ return err
+ }
+ for _, job := range jobs {
+ if !job.IsDir() || validateIdentifier(job.Name()) != nil {
+ continue
+ }
+ tasksRoot := filepath.Join(s.guard.Root(), job.Name(), "krillin-tasks")
+ tasks, err := os.ReadDir(tasksRoot)
+ if errors.Is(err, os.ErrNotExist) {
+ continue
+ }
+ if err != nil {
+ return err
+ }
+ for _, entry := range tasks {
+ if !entry.IsDir() || validateIdentifier(entry.Name()) != nil {
+ continue
+ }
+ if err := s.loadTask(filepath.Join(tasksRoot, entry.Name())); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+func (s *Store) loadTask(dir string) error {
+ data, err := os.ReadFile(filepath.Join(dir, "task.json"))
+ if err != nil {
+ return err
+ }
+ var record storedTask
+ if err := json.Unmarshal(data, &record); err != nil {
+ return err
+ }
+ events := []TaskEvent{}
+ if data, err = os.ReadFile(filepath.Join(dir, "events.json")); err == nil {
+ if err := json.Unmarshal(data, &events); err != nil {
+ return err
+ }
+ } else if !errors.Is(err, os.ErrNotExist) {
+ return err
+ }
+ s.tasks[record.Task.ID] = &record
+ s.idempotency[record.Task.JobID+"\x00"+record.IdempotencyKey] = record.Task.ID
+ s.events[record.Task.ID] = events
+ if record.Task.Status == StatusRunning {
+ return s.transitionLocked(&record, StatusInterrupted, &TaskError{
+ Code: "service_restarted", Message: "KrillinAI service restarted while the task was running", Retryable: true,
+ }, "error", map[string]interface{}{"status": StatusInterrupted, "code": "service_restarted"})
+ }
+ return nil
+}
+
+func atomicWriteJSON(path string, value interface{}) error {
+ if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
+ return err
+ }
+ temp, err := os.CreateTemp(filepath.Dir(path), ".opencreator-*.tmp")
+ if err != nil {
+ return err
+ }
+ tempName := temp.Name()
+ defer os.Remove(tempName)
+ writer := bufio.NewWriter(temp)
+ encoder := json.NewEncoder(writer)
+ encoder.SetIndent("", " ")
+ if err := encoder.Encode(value); err != nil {
+ temp.Close()
+ return err
+ }
+ if err := writer.Flush(); err != nil {
+ temp.Close()
+ return err
+ }
+ if err := temp.Sync(); err != nil {
+ temp.Close()
+ return err
+ }
+ if err := temp.Close(); err != nil {
+ return err
+ }
+ if err := os.Rename(tempName, path); err != nil {
+ return err
+ }
+ if dir, err := os.Open(filepath.Dir(path)); err == nil {
+ _ = dir.Sync()
+ _ = dir.Close()
+ }
+ return nil
+}
+
+func randomID(prefix string) (string, error) {
+ value := make([]byte, 12)
+ if _, err := rand.Read(value); err != nil {
+ return "", err
+ }
+ return prefix + "_" + hex.EncodeToString(value), nil
+}
+
+func cloneMap(input map[string]interface{}) map[string]interface{} {
+ if input == nil {
+ return map[string]interface{}{}
+ }
+ data, _ := json.Marshal(input)
+ var result map[string]interface{}
+ _ = json.Unmarshal(data, &result)
+ return result
+}
+
+func isTerminal(status TaskStatus) bool {
+ return status == StatusSucceeded || status == StatusFailed || status == StatusCanceled || status == StatusInterrupted
+}
+
+func sortedTaskIDs(tasks map[string]*storedTask) []string {
+ ids := make([]string, 0, len(tasks))
+ for id := range tasks {
+ ids = append(ids, id)
+ }
+ sort.Strings(ids)
+ return ids
+}
diff --git a/internal/pipeline/manifest.go b/internal/pipeline/manifest.go
index b4e0c509..ea1c9e6e 100644
--- a/internal/pipeline/manifest.go
+++ b/internal/pipeline/manifest.go
@@ -67,7 +67,32 @@ func (m *Manifest) Save() error {
if err != nil {
return err
}
- return os.WriteFile(ManifestPath(m.Workdir), append(data, '\n'), 0644)
+ path := ManifestPath(m.Workdir)
+ temp, err := os.CreateTemp(m.Workdir, ".krillinai-manifest-*.tmp")
+ if err != nil {
+ return err
+ }
+ tempName := temp.Name()
+ defer os.Remove(tempName)
+ if _, err := temp.Write(append(data, '\n')); err != nil {
+ temp.Close()
+ return err
+ }
+ if err := temp.Sync(); err != nil {
+ temp.Close()
+ return err
+ }
+ if err := temp.Close(); err != nil {
+ return err
+ }
+ if err := os.Rename(tempName, path); err != nil {
+ return err
+ }
+ if dir, err := os.Open(m.Workdir); err == nil {
+ _ = dir.Sync()
+ _ = dir.Close()
+ }
+ return nil
}
func (m *Manifest) ApplyDefaultOutputs() error {
diff --git a/internal/pipeline/srt.go b/internal/pipeline/srt.go
index c45bb36e..e9bf09e2 100644
--- a/internal/pipeline/srt.go
+++ b/internal/pipeline/srt.go
@@ -3,10 +3,15 @@ package pipeline
import (
"bufio"
"fmt"
+ "krillin-ai/internal/service"
"os"
+ "regexp"
+ "strconv"
"strings"
)
+var pipelineSRTTimestampPattern = regexp.MustCompile(`^(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s+-->\s+(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$`)
+
type srtBlock struct {
Index string
Timestamp string
@@ -96,3 +101,79 @@ func targetLine(lines []string, mode LineMode) (string, error) {
return "", fmt.Errorf("unsupported line mode: %s", mode)
}
}
+
+func validateExistingSubtitleOutputs(outputs Outputs) error {
+ candidates := []struct {
+ path string
+ allowOverlaps bool
+ }{
+ {path: outputs.OriginSRT},
+ {path: outputs.TargetSRT},
+ {path: outputs.BilingualSRT},
+ {path: outputs.ShortOriginSRT},
+ {path: outputs.ShortOriginMixedSRT, allowOverlaps: true},
+ }
+ for _, candidate := range candidates {
+ if candidate.path == "" {
+ continue
+ }
+ if _, err := os.Stat(candidate.path); err != nil {
+ if os.IsNotExist(err) {
+ continue
+ }
+ return err
+ }
+ if err := service.NormalizeSRTFile(candidate.path, candidate.allowOverlaps); err != nil {
+ return fmt.Errorf("%s: normalize timeline: %w", candidate.path, err)
+ }
+ if err := validateSRTTimelineFile(candidate.path, candidate.allowOverlaps); err != nil {
+ return fmt.Errorf("%s: %w", candidate.path, err)
+ }
+ }
+ return nil
+}
+
+func validateSRTTimelineFile(path string, allowOverlaps bool) error {
+ blocks, err := readSRTBlocks(path)
+ if err != nil {
+ return err
+ }
+ if len(blocks) == 0 {
+ return fmt.Errorf("invalid_srt: empty subtitle")
+ }
+ var previousEnd int64 = -1
+ for index, block := range blocks {
+ start, end, err := parsePipelineSRTTimeline(block.Timestamp)
+ if err != nil {
+ return fmt.Errorf("invalid_srt: cue %d: %w", index+1, err)
+ }
+ if end <= start || (!allowOverlaps && previousEnd >= 0 && start < previousEnd) {
+ return fmt.Errorf("invalid_srt: timeline %d", index+1)
+ }
+ if end > previousEnd {
+ previousEnd = end
+ }
+ }
+ return nil
+}
+
+func parsePipelineSRTTimeline(value string) (int64, int64, error) {
+ match := pipelineSRTTimestampPattern.FindStringSubmatch(value)
+ if match == nil {
+ return 0, 0, fmt.Errorf("invalid timestamp %q", value)
+ }
+ values := make([]int64, 8)
+ for index := range values {
+ parsed, err := strconv.ParseInt(match[index+1], 10, 64)
+ if err != nil {
+ return 0, 0, err
+ }
+ values[index] = parsed
+ }
+ if values[1] >= 60 || values[2] >= 60 || values[5] >= 60 || values[6] >= 60 {
+ return 0, 0, fmt.Errorf("timestamp component out of range")
+ }
+ start := ((values[0]*60+values[1])*60+values[2])*1000 + values[3]
+ end := ((values[4]*60+values[5])*60+values[6])*1000 + values[7]
+ return start, end, nil
+}
diff --git a/internal/pipeline/srt_test.go b/internal/pipeline/srt_test.go
index 3edcb59d..d804c56b 100644
--- a/internal/pipeline/srt_test.go
+++ b/internal/pipeline/srt_test.go
@@ -60,3 +60,30 @@ func TestExtractBilingualTargetBottom(t *testing.T) {
t.Fatalf("target bottom not extracted: %q", string(got))
}
}
+
+func TestValidateSRTTimelineRejectsInvalidDuration(t *testing.T) {
+ dir := t.TempDir()
+ path := filepath.Join(dir, "invalid.srt")
+ content := "1\n00:00:01,000 --> 00:00:01,000\nhello\n\n"
+ if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+ t.Fatal(err)
+ }
+ if err := validateSRTTimelineFile(path, false); err == nil {
+ t.Fatal("validateSRTTimelineFile() error = nil, want invalid duration")
+ }
+}
+
+func TestValidateSRTTimelineAllowsOverlapOnlyWhenRequested(t *testing.T) {
+ dir := t.TempDir()
+ path := filepath.Join(dir, "mixed.srt")
+ content := "1\n00:00:01,000 --> 00:00:02,000\ntarget\n\n2\n00:00:01,200 --> 00:00:01,500\norigin\n\n"
+ if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+ t.Fatal(err)
+ }
+ if err := validateSRTTimelineFile(path, false); err == nil {
+ t.Fatal("validateSRTTimelineFile() error = nil, want overlap error")
+ }
+ if err := validateSRTTimelineFile(path, true); err != nil {
+ t.Fatalf("validateSRTTimelineFile(allow overlap) error = %v", err)
+ }
+}
diff --git a/internal/pipeline/subtitle.go b/internal/pipeline/subtitle.go
index 635455d3..0af7d841 100644
--- a/internal/pipeline/subtitle.go
+++ b/internal/pipeline/subtitle.go
@@ -3,6 +3,7 @@ package pipeline
import (
"context"
"errors"
+ "fmt"
"krillin-ai/internal/service"
subtitlestyle "krillin-ai/internal/subtitle_style"
"krillin-ai/internal/types"
@@ -23,6 +24,8 @@ type SubtitleRequest struct {
BilingualTop bool
MaxWordOneLine int
SubtitleStyle *subtitlestyle.StyleSet
+ PrepareVideo bool
+ ReportProgress func(phase string, percent int, message string)
}
func GenerateSubtitles(ctx context.Context, svc StageService, req SubtitleRequest) (Response, error) {
@@ -44,42 +47,117 @@ func GenerateSubtitles(ctx context.Context, svc StageService, req SubtitleReques
return subtitleFailureResponse(req, manifest, ErrorKindInternal, "apply_outputs_failed", err), err
}
+ reportSubtitleProgress(req, "preparing_source", 10, "正在准备视频来源")
stepParam := subtitleStepParam(req)
+ stepParam.TaskPtr.SetProgressReporter(func(percent uint8) {
+ reportSubtitleProgress(req, "preparing_source", 10+minInt(int(percent), 10), "正在准备视频来源")
+ })
if err := svc.PrepareMedia(ctx, stepParam); err != nil {
return failSubtitleStage(req, manifest, ErrorKindRetryable, "prepare_media_failed", err)
}
+ var platformCaptionErr error
if isYouTubeInput(req.Input) && req.CaptionSource != CaptionSourceWhisper {
+ reportSubtitleProgress(req, "reading_platform_captions", 20, "正在获取平台字幕")
+ stepParam.TaskPtr.SetProgressReporter(func(percent uint8) {
+ phase, message, overall := platformSubtitleProgress(percent)
+ reportSubtitleProgress(req, phase, overall, message)
+ })
youtubeReq := subtitleYouTubeReq(req, stepParam.TaskPtr)
vttFile, err := svc.DownloadYouTubeSubtitle(ctx, youtubeReq)
if err == nil {
+ reportSubtitleProgress(req, "processing_platform_captions", 25, "正在解析平台字幕")
youtubeReq.VttFile = vttFile
_, err = svc.ProcessYouTubeSubtitle(ctx, youtubeReq)
}
if err == nil {
manifest.CaptionSource = "youtube_vtt"
+ reportSubtitleProgress(req, "preparing_original_media", 76, "正在补齐原始视频")
+ stepParam.TaskPtr.SetProgressReporter(func(percent uint8) {
+ overall := 76 + minInt(int(percent), 10)*14/10
+ reportSubtitleProgress(req, "preparing_original_media", overall, "正在补齐原始视频")
+ })
if err := prepareOriginalMediaForRendering(ctx, svc, stepParam); err != nil {
return failSubtitleStage(req, manifest, ErrorKindRetryable, "prepare_media_for_render_failed", err)
}
+ reportSubtitleProgress(req, "collecting_outputs", 95, "正在整理字幕和视频产物")
return saveSubtitleSuccess(manifest, req, CaptionSource("youtube_vtt"))
}
if req.CaptionSource != CaptionSourceAny {
return failSubtitleStage(req, manifest, ErrorKindRetryable, "platform_caption_failed", err)
}
+ platformCaptionErr = err
manifest.Warnings = append(manifest.Warnings, "平台字幕不可用,回退到转录")
stepParam.VttSwitch = false
+ if req.PrepareVideo {
+ stepParam.EmbedSubtitleVideoType = "all"
+ }
+ reportSubtitleProgress(req, "preparing_audio", 25, "平台字幕不可用,正在准备音频转录")
+ stepParam.TaskPtr.SetProgressReporter(audioSubtitleProgressReporter(req))
if err := svc.PrepareMedia(ctx, stepParam); err != nil {
- return failSubtitleStage(req, manifest, ErrorKindRetryable, "prepare_audio_fallback_failed", err)
+ return failSubtitleStage(req, manifest, ErrorKindRetryable, "prepare_audio_fallback_failed", fmt.Errorf(
+ "platform caption attempt failed: %v; audio fallback preparation failed: %w",
+ platformCaptionErr,
+ err,
+ ))
}
}
+ stepParam.TaskPtr.SetProgressReporter(audioSubtitleProgressReporter(req))
+ reportSubtitleProgress(req, "transcribing_audio", 30, "正在转录并翻译音频字幕")
if err := svc.GenerateSubtitlesFromAudio(ctx, stepParam); err != nil {
return failSubtitleStage(req, manifest, ErrorKindRetryable, "audio_transcription_failed", err)
}
manifest.CaptionSource = string(CaptionSourceWhisper)
+ reportSubtitleProgress(req, "collecting_outputs", 95, "正在整理字幕产物")
return saveSubtitleSuccess(manifest, req, CaptionSourceWhisper)
}
+func reportSubtitleProgress(req SubtitleRequest, phase string, percent int, message string) {
+ if req.ReportProgress == nil {
+ return
+ }
+ req.ReportProgress(phase, percent, message)
+}
+
+func platformSubtitleProgress(percent uint8) (string, string, int) {
+ value := int(percent)
+ if value < 40 {
+ return "processing_platform_captions", "正在解析平台字幕", 25 + value*15/40
+ }
+ if value < 90 {
+ return "translating_subtitles", "正在翻译字幕", 40 + (value-40)*35/50
+ }
+ return "collecting_subtitles", "正在生成双语字幕", 75
+}
+
+func audioSubtitleProgressReporter(req SubtitleRequest) func(uint8) {
+ return func(percent uint8) {
+ value := int(percent)
+ overall := 25 + value*65/100
+ phase := "transcribing_audio"
+ message := "正在转录并翻译音频字幕"
+ if value <= 10 {
+ phase = "preparing_audio"
+ message = "正在准备音频转录"
+ } else if value >= 53 && value < 90 {
+ phase = "translating_subtitles"
+ message = "正在翻译字幕"
+ } else if value >= 90 {
+ phase = "collecting_subtitles"
+ message = "正在生成字幕文件"
+ }
+ reportSubtitleProgress(req, phase, overall, message)
+ }
+}
+
+func minInt(left, right int) int {
+ if left < right {
+ return left
+ }
+ return right
+}
+
func subtitleManifest(req SubtitleRequest) (*Manifest, error) {
manifest, err := LoadManifest(req.Workdir)
if err == nil {
@@ -110,6 +188,11 @@ func subtitleStepParam(req SubtitleRequest) *types.SubtitleTaskStepParam {
VideoSrc: req.Input,
Status: types.SubtitleTaskStatusProcessing,
}
+ vttSwitch := isYouTubeInput(req.Input) && req.CaptionSource != CaptionSourceWhisper
+ embedSubtitleVideoType := "none"
+ if req.PrepareVideo && !vttSwitch {
+ embedSubtitleVideoType = "all"
+ }
return &types.SubtitleTaskStepParam{
TaskId: req.TaskID,
TaskPtr: taskPtr,
@@ -120,8 +203,8 @@ func subtitleStepParam(req SubtitleRequest) *types.SubtitleTaskStepParam {
TargetLanguage: types.StandardLanguageCode(req.TargetLang),
UserUILanguage: types.StandardLanguageCode(userLang),
MaxWordOneLine: maxWordOneLine,
- VttSwitch: isYouTubeInput(req.Input) && req.CaptionSource != CaptionSourceWhisper,
- EmbedSubtitleVideoType: "none",
+ VttSwitch: vttSwitch,
+ EmbedSubtitleVideoType: embedSubtitleVideoType,
SubtitleStyle: req.SubtitleStyle,
}
}
@@ -145,6 +228,11 @@ func subtitleYouTubeReq(req SubtitleRequest, taskPtr *types.SubtitleTask) *servi
}
func saveSubtitleSuccess(manifest *Manifest, req SubtitleRequest, captionSource CaptionSource) (Response, error) {
+ if err := validateExistingSubtitleOutputs(manifest.Outputs); err != nil {
+ manifest.MarkStage(StageSubtitle, false, err.Error())
+ _ = manifest.Save()
+ return subtitleFailureResponse(req, manifest, ErrorKindInternal, "invalid_subtitle_timeline", err), err
+ }
manifest.MarkStage(StageSubtitle, true, "")
if err := manifest.Save(); err != nil {
return subtitleFailureResponse(req, manifest, ErrorKindInternal, "save_manifest_failed", err), err
diff --git a/internal/pipeline/subtitle_test.go b/internal/pipeline/subtitle_test.go
index 3f17ebfc..b85dcfb9 100644
--- a/internal/pipeline/subtitle_test.go
+++ b/internal/pipeline/subtitle_test.go
@@ -51,8 +51,13 @@ func (f *fakeStageService) DownloadYouTubeSubtitle(context.Context, *service.You
return "demo.en.vtt", f.downloadErr
}
-func (f *fakeStageService) ProcessYouTubeSubtitle(context.Context, *service.YoutubeSubtitleReq) (string, error) {
+func (f *fakeStageService) ProcessYouTubeSubtitle(_ context.Context, req *service.YoutubeSubtitleReq) (string, error) {
f.calls = append(f.calls, "process-youtube")
+ if req.TaskPtr != nil {
+ req.TaskPtr.SetProgress(40)
+ req.TaskPtr.SetProgress(65)
+ req.TaskPtr.SetProgress(90)
+ }
return "bilingual_srt.srt", f.processErr
}
@@ -202,6 +207,44 @@ func TestGenerateSubtitlesYouTubeCaptionsPrepareOriginalMediaForRendering(t *tes
}
}
+func TestGenerateSubtitlesReportsPlatformTranslationAndMediaProgress(t *testing.T) {
+ dir := t.TempDir()
+ fake := &fakeStageService{}
+ type update struct {
+ phase string
+ percent int
+ }
+ updates := []update{}
+ req := SubtitleRequest{
+ Input: "https://www.youtube.com/watch?v=abc",
+ Workdir: dir,
+ TaskID: "demo",
+ OriginLang: "en",
+ TargetLang: "zh_cn",
+ CaptionSource: CaptionSourceAny,
+ PrepareVideo: true,
+ ReportProgress: func(phase string, percent int, _ string) {
+ updates = append(updates, update{phase: phase, percent: percent})
+ },
+ }
+
+ if _, err := GenerateSubtitles(context.Background(), fake, req); err != nil {
+ t.Fatal(err)
+ }
+ assertProgress := func(phase string, percent int) {
+ t.Helper()
+ for _, candidate := range updates {
+ if candidate.phase == phase && candidate.percent == percent {
+ return
+ }
+ }
+ t.Fatalf("missing progress %s/%d in %+v", phase, percent, updates)
+ }
+ assertProgress("translating_subtitles", 57)
+ assertProgress("preparing_original_media", 76)
+ assertProgress("collecting_outputs", 95)
+}
+
func TestGenerateSubtitlesWhisperSkipsYouTubeDownload(t *testing.T) {
dir := t.TempDir()
fake := &fakeStageService{}
@@ -227,3 +270,53 @@ func TestGenerateSubtitlesWhisperSkipsYouTubeDownload(t *testing.T) {
t.Fatalf("prepare VttSwitch values = %v, want [false]", got)
}
}
+
+func TestGenerateSubtitlesWhisperPreparesVideoWhenRequested(t *testing.T) {
+ dir := t.TempDir()
+ fake := &fakeStageService{}
+ req := SubtitleRequest{
+ Input: "https://www.youtube.com/watch?v=abc",
+ Workdir: dir,
+ TaskID: "demo",
+ OriginLang: "en",
+ TargetLang: "zh_cn",
+ CaptionSource: CaptionSourceWhisper,
+ PrepareVideo: true,
+ }
+
+ resp, err := GenerateSubtitles(context.Background(), fake, req)
+ if err != nil {
+ t.Fatalf("GenerateSubtitles() error = %v", err)
+ }
+ if !resp.OK {
+ t.Fatalf("OK = false, want true")
+ }
+ if got := fake.prepareEmbedTypes; len(got) != 1 || got[0] != "all" {
+ t.Fatalf("prepare EmbedSubtitleVideoType values = %v, want [all]", got)
+ }
+}
+
+func TestGenerateSubtitlesFallbackPreparesVideoWhenRequested(t *testing.T) {
+ dir := t.TempDir()
+ fake := &fakeStageService{downloadErr: errors.New("no captions")}
+ req := SubtitleRequest{
+ Input: "https://www.youtube.com/watch?v=abc",
+ Workdir: dir,
+ TaskID: "demo",
+ OriginLang: "en",
+ TargetLang: "zh_cn",
+ CaptionSource: CaptionSourceAny,
+ PrepareVideo: true,
+ }
+
+ resp, err := GenerateSubtitles(context.Background(), fake, req)
+ if err != nil {
+ t.Fatalf("GenerateSubtitles() error = %v", err)
+ }
+ if !resp.OK {
+ t.Fatalf("OK = false, want true")
+ }
+ if got := fake.prepareEmbedTypes; len(got) != 2 || got[0] != "none" || got[1] != "all" {
+ t.Fatalf("prepare EmbedSubtitleVideoType values = %v, want [none all]", got)
+ }
+}
diff --git a/internal/pipeline/types.go b/internal/pipeline/types.go
index 887ba16c..684cd126 100644
--- a/internal/pipeline/types.go
+++ b/internal/pipeline/types.go
@@ -5,6 +5,7 @@ import "encoding/json"
type Stage string
const (
+ StageDownload Stage = "download"
StageSubtitle Stage = "subtitle"
StageTTS Stage = "tts"
StageRenderHorizontal Stage = "render-horizontal"
diff --git a/internal/resourcepath/resourcepath.go b/internal/resourcepath/resourcepath.go
new file mode 100644
index 00000000..c70fac48
--- /dev/null
+++ b/internal/resourcepath/resourcepath.go
@@ -0,0 +1,70 @@
+package resourcepath
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+)
+
+const RootEnv = "KRILLINAI_RESOURCE_ROOT"
+const OfflineEnv = "KRILLINAI_OFFLINE_DEPENDENCIES"
+
+func Offline() bool {
+ return os.Getenv(OfflineEnv) == "1"
+}
+
+func Root() (string, bool, error) {
+ value := os.Getenv(RootEnv)
+ if value == "" {
+ return "", false, nil
+ }
+ root, err := filepath.Abs(filepath.Clean(value))
+ if err != nil {
+ return "", false, err
+ }
+ return root, true, nil
+}
+
+func Resolve(parts ...string) (string, error) {
+ root, configured, err := Root()
+ if err != nil {
+ return "", err
+ }
+ if !configured {
+ return filepath.Join(parts...), nil
+ }
+ path := filepath.Join(append([]string{root}, parts...)...)
+ resolved, err := filepath.Abs(filepath.Clean(path))
+ if err != nil {
+ return "", err
+ }
+ relative, err := filepath.Rel(root, resolved)
+ if err != nil || relative == ".." || filepath.IsAbs(relative) {
+ return "", fmt.Errorf("resource path escapes root")
+ }
+ return resolved, nil
+}
+
+func RequireFile(parts ...string) (string, error) {
+ path, err := Resolve(parts...)
+ if err != nil {
+ return "", err
+ }
+ info, err := os.Stat(path)
+ if err != nil || !info.Mode().IsRegular() {
+ return "", fmt.Errorf("dependency_not_packaged: %s", filepath.Join(parts...))
+ }
+ return path, nil
+}
+
+func RequireDir(parts ...string) (string, error) {
+ path, err := Resolve(parts...)
+ if err != nil {
+ return "", err
+ }
+ info, err := os.Stat(path)
+ if err != nil || !info.IsDir() {
+ return "", fmt.Errorf("dependency_not_packaged: %s", filepath.Join(parts...))
+ }
+ return path, nil
+}
diff --git a/internal/resourcepath/resourcepath_test.go b/internal/resourcepath/resourcepath_test.go
new file mode 100644
index 00000000..f5d62849
--- /dev/null
+++ b/internal/resourcepath/resourcepath_test.go
@@ -0,0 +1,27 @@
+package resourcepath
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+func TestResolveUsesConfiguredRoot(t *testing.T) {
+ root := t.TempDir()
+ t.Setenv(RootEnv, root)
+ path, err := Resolve("bin", "ffmpeg")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if path != filepath.Join(root, "bin", "ffmpeg") {
+ t.Fatalf("path = %q", path)
+ }
+}
+
+func TestRequireFileReturnsDependencyNotPackaged(t *testing.T) {
+ t.Setenv(RootEnv, t.TempDir())
+ if _, err := RequireFile("bin", "missing"); err == nil {
+ t.Fatal("expected missing packaged dependency error")
+ }
+ _ = os.Getenv(OfflineEnv)
+}
diff --git a/internal/service/audio2subtitle.go b/internal/service/audio2subtitle.go
index d16dc024..388d0b98 100644
--- a/internal/service/audio2subtitle.go
+++ b/internal/service/audio2subtitle.go
@@ -16,12 +16,13 @@ import (
"runtime/debug"
"strconv"
"strings"
- "sync"
"go.uber.org/zap"
"golang.org/x/sync/errgroup"
)
+const translationBatchSize = 12
+
// filterStandaloneQuotes 过滤单独的双引号行
func filterStandaloneQuotes(text string) string {
if strings.TrimSpace(text) == "\"" {
@@ -49,6 +50,15 @@ type AudioSegment struct {
SrtNoTsFile string
}
+type TranslationProgress struct {
+ Completed int
+ Total int
+}
+
+type contextChatCompleter interface {
+ ChatCompletionContext(context.Context, string) (string, error)
+}
+
func (s Service) audioToSubtitle(ctx context.Context, stepParam *types.SubtitleTaskStepParam) error {
var err error
err = s.audioToSrt(ctx, stepParam) // 这里进度更新到90%了
@@ -60,7 +70,7 @@ func (s Service) audioToSubtitle(ctx context.Context, stepParam *types.SubtitleT
return fmt.Errorf("audioToSubtitle splitSrt error: %w", err)
}
// 更新字幕任务信息
- stepParam.TaskPtr.ProcessPct = 95
+ stepParam.TaskPtr.SetProgress(95)
return nil
}
@@ -143,7 +153,14 @@ func IsSplitUseSpace(language types.StandardLanguageCode) bool {
return false
}
-func (s Service) splitTextAndTranslateV2(basePath, inputText string, originLang, targetLang types.StandardLanguageCode, enableModalFilter bool, id int) ([]*TranslatedItem, error) {
+func (s Service) splitTextAndTranslateV2(
+ ctx context.Context,
+ basePath, inputText string,
+ originLang, targetLang types.StandardLanguageCode,
+ enableModalFilter bool,
+ id int,
+ reportProgress func(completed, total int) error,
+) ([]*TranslatedItem, error) {
sentences := util.SplitTextSentences(inputText, config.Conf.App.MaxSentenceLength)
if len(sentences) == 0 {
return []*TranslatedItem{}, nil
@@ -180,75 +197,168 @@ func (s Service) splitTextAndTranslateV2(basePath, inputText string, originLang,
}
sentences = shortSentences
-
- var (
- signal = make(chan struct{}, config.Conf.App.TranslateParallelNum) // 控制最大并发数
- wg sync.WaitGroup
- results = make([]*TranslatedItem, len(sentences))
- // errChan = make(chan error, 1)
- // mutex sync.Mutex
- )
-
- for i, sentence := range sentences {
- wg.Add(1)
- signal <- struct{}{}
-
- go func(index int, originText string) {
- defer wg.Done()
- defer func() { <-signal }()
-
- contextSentenceNum := 3
-
- // 生成前面3个句子的string
- var previousSentences string
- if index > 0 {
- start := 0
- if index-contextSentenceNum > 0 {
- start = index - contextSentenceNum
- }
- for i := start; i < index; i++ {
- previousSentences += sentences[i] + "\n"
- }
+ results := make([]*TranslatedItem, len(sentences))
+ completed := 0
+ checkpoint := func(count int) error {
+ completed += count
+ if basePath != "" {
+ path := filepath.Join(basePath, fmt.Sprintf(types.SubtitleTaskTranslationDataPersistenceFileNamePattern, id))
+ if err := util.SaveToDisk(results, path); err != nil {
+ return fmt.Errorf("save translation checkpoint: %w", err)
}
+ }
+ if reportProgress != nil {
+ return reportProgress(completed, len(sentences))
+ }
+ return nil
+ }
- // 生成后面3个句子的string
- var nextSentences string
- if index < len(sentences)-1 {
- end := len(sentences) - 1
- if index+contextSentenceNum < end {
- end = index + contextSentenceNum
- }
- for i := index + 1; i <= end; i++ {
- if i > index+1 {
- nextSentences += "\n"
+ for start := 0; start < len(sentences); start += translationBatchSize {
+ end := start + translationBatchSize
+ if end > len(sentences) {
+ end = len(sentences)
+ }
+ if err := s.translateSentenceRange(ctx, sentences, results, start, end, targetLang, enableModalFilter, checkpoint); err != nil {
+ return nil, err
+ }
+ }
+ return results, nil
+}
+
+func (s Service) translateSentenceRange(
+ ctx context.Context,
+ sentences []string,
+ results []*TranslatedItem,
+ start, end int,
+ targetLang types.StandardLanguageCode,
+ enableModalFilter bool,
+ onCompleted func(int) error,
+) error {
+ prompt, err := buildTranslationBatchPrompt(sentences, start, end, targetLang, enableModalFilter)
+ if err == nil {
+ var response string
+ response, err = chatCompletionWithContext(ctx, s.ChatCompleter, prompt)
+ if err == nil {
+ var translations []string
+ translations, err = parseTranslationBatch(response, end-start)
+ if err == nil {
+ for offset, translatedText := range translations {
+ results[start+offset] = &TranslatedItem{
+ OriginText: sentences[start+offset],
+ TranslatedText: translatedText,
}
- nextSentences += sentences[i]
}
+ return onCompleted(end - start)
}
+ }
+ }
- prompt := fmt.Sprintf(types.SplitTextWithContextPrompt, types.GetStandardLanguageName(targetLang), previousSentences, originText, nextSentences)
+ if end-start <= 1 {
+ return fmt.Errorf("translate subtitle sentence %d: %w", start+1, err)
+ }
+ log.GetLogger().Warn("translation batch failed, splitting batch",
+ zap.Int("start", start),
+ zap.Int("end", end),
+ zap.Error(err))
+ middle := start + (end-start)/2
+ if err := s.translateSentenceRange(ctx, sentences, results, start, middle, targetLang, enableModalFilter, onCompleted); err != nil {
+ return err
+ }
+ return s.translateSentenceRange(ctx, sentences, results, middle, end, targetLang, enableModalFilter, onCompleted)
+}
- translatedText, err := s.ChatCompleter.ChatCompletion(prompt)
- if err != nil {
- log.GetLogger().Error("splitTextAndTranslateV2 llm translate error", zap.Error(err), zap.Any("original text", originText))
- results[index] = &TranslatedItem{
- OriginText: originText,
- TranslatedText: originText,
- }
- } else {
- translatedText = strings.TrimSpace(translatedText)
- results[index] = &TranslatedItem{
- OriginText: originText,
- TranslatedText: translatedText,
- }
- }
- }(i, sentence)
+func buildTranslationBatchPrompt(
+ sentences []string,
+ start, end int,
+ targetLang types.StandardLanguageCode,
+ enableModalFilter bool,
+) (string, error) {
+ type inputItem struct {
+ Index int `json:"index"`
+ Text string `json:"text"`
+ }
+ type batchInput struct {
+ ContextBefore []string `json:"context_before,omitempty"`
+ Items []inputItem `json:"items"`
+ ContextAfter []string `json:"context_after,omitempty"`
+ }
+ input := batchInput{Items: make([]inputItem, 0, end-start)}
+ contextStart := start - 2
+ if contextStart < 0 {
+ contextStart = 0
+ }
+ input.ContextBefore = append(input.ContextBefore, sentences[contextStart:start]...)
+ contextEnd := end + 2
+ if contextEnd > len(sentences) {
+ contextEnd = len(sentences)
+ }
+ input.ContextAfter = append(input.ContextAfter, sentences[end:contextEnd]...)
+ for index := start; index < end; index++ {
+ input.Items = append(input.Items, inputItem{Index: index - start + 1, Text: sentences[index]})
+ }
+ payload, err := json.Marshal(input)
+ if err != nil {
+ return "", err
+ }
+ modalRule := "保留有实际语义的语气词。"
+ if enableModalFilter {
+ modalRule = "忽略 um、uh、ah、oh 等无实际语义的语气词。"
}
+ return fmt.Sprintf(`你是专业字幕翻译员。把 items 中每条字幕翻译为%s。
- wg.Wait()
- // close(errChan)
+要求:
+1. 只返回一个 JSON 对象,不要 Markdown,不要解释。
+2. 格式必须是 {"translations":[{"index":1,"text":"译文"}]}。
+3. translations 必须与 items 数量完全相同,index 必须逐一对应,不能合并、拆分、遗漏或改变顺序。
+4. 译文自然、简洁,并结合 context_before、items 和 context_after 保持术语与上下文一致。
+5. 目标语言为中文时只能使用简体中文。
+6. %s
- return results, nil
+输入 JSON:
+%s`, types.GetStandardLanguageName(targetLang), modalRule, payload), nil
+}
+
+func chatCompletionWithContext(ctx context.Context, completer types.ChatCompleter, prompt string) (string, error) {
+ if contextual, ok := completer.(contextChatCompleter); ok {
+ return contextual.ChatCompletionContext(ctx, prompt)
+ }
+ if err := ctx.Err(); err != nil {
+ return "", err
+ }
+ return completer.ChatCompletion(prompt)
+}
+
+func parseTranslationBatch(response string, expected int) ([]string, error) {
+ cleaned := strings.TrimSpace(response)
+ if first, last := strings.Index(cleaned, "{"), strings.LastIndex(cleaned, "}"); first >= 0 && last > first {
+ cleaned = cleaned[first : last+1]
+ }
+ var payload struct {
+ Translations []struct {
+ Index int `json:"index"`
+ Text string `json:"text"`
+ } `json:"translations"`
+ }
+ if err := json.Unmarshal([]byte(cleaned), &payload); err != nil {
+ return nil, fmt.Errorf("invalid translation JSON: %w", err)
+ }
+ if len(payload.Translations) != expected {
+ return nil, fmt.Errorf("translation count %d, want %d", len(payload.Translations), expected)
+ }
+ translations := make([]string, expected)
+ seen := make([]bool, expected)
+ for _, item := range payload.Translations {
+ if item.Index < 1 || item.Index > expected || seen[item.Index-1] {
+ return nil, fmt.Errorf("invalid translation index %d", item.Index)
+ }
+ text := strings.TrimSpace(item.Text)
+ if text == "" {
+ return nil, fmt.Errorf("translation %d is empty", item.Index)
+ }
+ seen[item.Index-1] = true
+ translations[item.Index-1] = text
+ }
+ return translations, nil
}
func (s Service) audioToSrt(ctx context.Context, stepParam *types.SubtitleTaskStepParam) (err error) {
@@ -279,7 +389,7 @@ func (s Service) audioToSrt(ctx context.Context, stepParam *types.SubtitleTaskSt
}
// 更新字幕任务信息
- stepParam.TaskPtr.ProcessPct = 90
+ stepParam.TaskPtr.SetProgress(90)
log.GetLogger().Info("audioToSubtitle.audioToSrt end", zap.Any("taskId", stepParam.TaskId))
return nil
@@ -295,7 +405,7 @@ func (s Service) getSplitPointsForAudio(stepParam *types.SubtitleTaskStepParam)
log.GetLogger().Info("audioToSubtitle getSplitPointsForAudio completed", zap.Any("taskId", stepParam.TaskId), zap.Any("timePoints", timePoints))
// 更新字幕任务信息
- stepParam.TaskPtr.ProcessPct = 15
+ stepParam.TaskPtr.SetProgress(15)
return timePoints, nil
}
@@ -308,6 +418,7 @@ func (s Service) processAudioSegments(ctx context.Context, stepParam *types.Subt
pendingTranscriptionQueue := make(chan DataWithId[string], segmentNum)
transcribedQueue := make(chan DataWithId[*types.TranscriptionData], segmentNum)
pendingTranslationQueue := make(chan DataWithId[string], segmentNum)
+ translationProgressQueue := make(chan DataWithId[TranslationProgress], segmentNum*2)
translatedQueue := make(chan DataWithId[[]*TranslatedItem], segmentNum)
eg, ctx := errgroup.WithContext(ctx)
@@ -330,12 +441,12 @@ func (s Service) processAudioSegments(ctx context.Context, stepParam *types.Subt
s.startTranscribeWorkers(ctx, eg, stepParam, pendingTranscriptionQueue, transcribedQueue)
// 启动翻译协程
- s.startTranslateWorker(ctx, eg, stepParam, pendingTranslationQueue, translatedQueue)
+ s.startTranslateWorker(ctx, eg, stepParam, pendingTranslationQueue, translationProgressQueue, translatedQueue)
// 处理结果协程
s.startResultHandler(ctx, eg, stepParam, segmentNum, timePoints, audioSegments,
splitResultQueue, pendingTranscriptionQueue, transcribedQueue,
- pendingTranslationQueue, translatedQueue, pendingSplitQueue)
+ pendingTranslationQueue, translationProgressQueue, translatedQueue, pendingSplitQueue)
if err := eg.Wait(); err != nil {
log.GetLogger().Error("audioToSubtitle processAudioSegments errgroup wait err", zap.Any("taskId", stepParam.TaskId), zap.Error(err))
@@ -423,7 +534,8 @@ func (s Service) startTranscribeWorkers(ctx context.Context, eg *errgroup.Group,
// 启动翻译工作协程
func (s Service) startTranslateWorker(ctx context.Context, eg *errgroup.Group, stepParam *types.SubtitleTaskStepParam,
- pendingTranslationQueue chan DataWithId[string], translatedQueue chan DataWithId[[]*TranslatedItem]) {
+ pendingTranslationQueue chan DataWithId[string], translationProgressQueue chan DataWithId[TranslationProgress],
+ translatedQueue chan DataWithId[[]*TranslatedItem]) {
eg.Go(func() error {
for {
@@ -438,8 +550,23 @@ func (s Service) startTranslateWorker(ctx context.Context, eg *errgroup.Group, s
var err error
// 翻译文本
log.GetLogger().Info("Begin to translate", zap.Any("taskId", stepParam.TaskId), zap.Any("splitId", translateItem.Id))
- for range config.Conf.App.TranslateMaxAttempts {
- translatedResults, err = s.splitTextAndTranslateV2(stepParam.TaskBasePath, translateItem.Data, stepParam.OriginLanguage, stepParam.TargetLanguage, stepParam.EnableModalFilter, translateItem.Id)
+ attempts := config.Conf.App.TranslateMaxAttempts
+ if attempts < 1 {
+ attempts = 1
+ }
+ reportProgress := func(completed, total int) error {
+ select {
+ case translationProgressQueue <- DataWithId[TranslationProgress]{
+ Data: TranslationProgress{Completed: completed, Total: total},
+ Id: translateItem.Id,
+ }:
+ return nil
+ case <-ctx.Done():
+ return ctx.Err()
+ }
+ }
+ for range attempts {
+ translatedResults, err = s.splitTextAndTranslateV2(ctx, stepParam.TaskBasePath, translateItem.Data, stepParam.OriginLanguage, stepParam.TargetLanguage, stepParam.EnableModalFilter, translateItem.Id, reportProgress)
if err == nil {
break
}
@@ -474,7 +601,8 @@ func (s Service) startResultHandler(ctx context.Context, eg *errgroup.Group, ste
segmentNum int, timePoints []float64, audioSegments []AudioSegment,
splitResultQueue chan DataWithId[string], pendingTranscriptionQueue chan DataWithId[string],
transcribedQueue chan DataWithId[*types.TranscriptionData], pendingTranslationQueue chan DataWithId[string],
- translatedQueue chan DataWithId[[]*TranslatedItem], pendingSplitQueue chan DataWithId[[2]float64]) {
+ translationProgressQueue chan DataWithId[TranslationProgress], translatedQueue chan DataWithId[[]*TranslatedItem],
+ pendingSplitQueue chan DataWithId[[2]float64]) {
eg.Go(func() error {
// SPLIT_WEIGHT + TRANSCRIBE_WEIGHT + TRANSLATE_WEIGHT == 1
@@ -483,9 +611,20 @@ func (s Service) startResultHandler(ctx context.Context, eg *errgroup.Group, ste
TRANSCRIBE_WEIGHT = 0.4
TRANSLATE_WEIGHT = 0.5
)
- // 总体任务在进度条中的占比
- taskWeight := (90 - 15) / float64(segmentNum)
- processPct := 15.0
+ splitCompleted := 0
+ transcriptionCompleted := 0
+ translationProgress := make(map[int]float64, segmentNum)
+ updateProgress := func() {
+ translationTotal := 0.0
+ for _, progress := range translationProgress {
+ translationTotal += progress
+ }
+ processPct := 15.0 +
+ float64(splitCompleted)/float64(segmentNum)*75*SPLIT_WEIGHT +
+ float64(transcriptionCompleted)/float64(segmentNum)*75*TRANSCRIBE_WEIGHT +
+ translationTotal/float64(segmentNum)*75*TRANSLATE_WEIGHT
+ stepParam.TaskPtr.SetProgress(uint8(processPct))
+ }
// 完成的任务数量
completedTasks := 0
for {
@@ -493,9 +632,8 @@ func (s Service) startResultHandler(ctx context.Context, eg *errgroup.Group, ste
case <-ctx.Done():
return nil
case splitResultItem := <-splitResultQueue:
- // 更新字幕任务信息
- processPct += taskWeight * SPLIT_WEIGHT
- stepParam.TaskPtr.ProcessPct = uint8(processPct)
+ splitCompleted++
+ updateProgress()
// 处理分割结果
audioSegments[splitResultItem.Id].AudioFile = splitResultItem.Data
// 发送转录任务
@@ -504,9 +642,8 @@ func (s Service) startResultHandler(ctx context.Context, eg *errgroup.Group, ste
Id: splitResultItem.Id,
}
case transcribedItem := <-transcribedQueue:
- // 更新字幕任务信息
- processPct += taskWeight * TRANSCRIBE_WEIGHT
- stepParam.TaskPtr.ProcessPct = uint8(processPct)
+ transcriptionCompleted++
+ updateProgress()
// 处理转录结果
audioSegments[transcribedItem.Id].TranscriptionData = transcribedItem.Data
// 发送翻译任务
@@ -514,10 +651,20 @@ func (s Service) startResultHandler(ctx context.Context, eg *errgroup.Group, ste
Data: transcribedItem.Data.Text,
Id: transcribedItem.Id,
}
+ case progressItem := <-translationProgressQueue:
+ if progressItem.Data.Total > 0 {
+ fraction := float64(progressItem.Data.Completed) / float64(progressItem.Data.Total)
+ if fraction > 1 {
+ fraction = 1
+ }
+ if fraction > translationProgress[progressItem.Id] {
+ translationProgress[progressItem.Id] = fraction
+ updateProgress()
+ }
+ }
case translatedItems := <-translatedQueue:
- // 更新字幕任务信息
- processPct += taskWeight * TRANSLATE_WEIGHT
- stepParam.TaskPtr.ProcessPct = uint8(processPct)
+ translationProgress[translatedItems.Id] = 1
+ updateProgress()
// 处理翻译结果,保存不带时间戳的原始字幕
originNoTsSrtFileName := filepath.Join(stepParam.TaskBasePath, fmt.Sprintf(types.SubtitleTaskSplitSrtNoTimestampFileNamePattern, translatedItems.Id))
originNoTsSrtFile, err := os.Create(originNoTsSrtFileName)
@@ -566,6 +713,7 @@ func (s Service) startResultHandler(ctx context.Context, eg *errgroup.Group, ste
close(pendingTranscriptionQueue)
close(transcribedQueue)
close(pendingTranslationQueue)
+ close(translationProgressQueue)
close(translatedQueue)
return nil
}
@@ -1020,6 +1168,9 @@ func generateSrtWithTimestamps(srtBlocks []*util.SrtBlock, tsOffset float64, wor
if err != nil {
return fmt.Errorf("audioToSubtitle generateTimestamps GenerateTimestamps error: %w", err)
}
+ for index := range srtBlocks {
+ srtBlocks[index].Timestamp = newSrtBlocks[index].Timestamp
+ }
for _, srtBlock := range srtBlocks {
if srtBlock.OriginLanguageSentence == "" {
@@ -1116,6 +1267,23 @@ func generateSrtWithTimestamps(srtBlocks []*util.SrtBlock, tsOffset float64, wor
}
lastTs = ts
}
+ if err := normalizeSrtBlocks(newSrtBlocks, false); err != nil {
+ return fmt.Errorf("normalize bilingual subtitle timeline: %w", err)
+ }
+ if err := normalizeSrtBlocks(srtBlocks, true); err != nil {
+ return fmt.Errorf("normalize mixed subtitle timeline: %w", err)
+ }
+ shortTimeline := make([]*util.SrtBlock, 0)
+ for _, srtBlock := range srtBlocks {
+ blocks := shortOriginSrtMap[srtBlock.Index]
+ for index := range blocks {
+ shortTimeline = append(shortTimeline, &blocks[index])
+ }
+ shortOriginSrtMap[srtBlock.Index] = blocks
+ }
+ if err := normalizeSrtBlocks(shortTimeline, false); err != nil {
+ return fmt.Errorf("normalize vertical subtitle timeline: %w", err)
+ }
// 保存带时间戳的原始字幕
finalBilingualSrtFileName := fmt.Sprintf("%s/%s", stepParam.TaskBasePath, fmt.Sprintf(types.SubtitleTaskSplitBilingualSrtFileNamePattern, segmentIdx))
diff --git a/internal/service/audio2subtitle_test.go b/internal/service/audio2subtitle_test.go
index d250d1e7..791ea78c 100644
--- a/internal/service/audio2subtitle_test.go
+++ b/internal/service/audio2subtitle_test.go
@@ -1,11 +1,16 @@
package service
import (
+ "context"
+ "encoding/json"
+ "errors"
"fmt"
"krillin-ai/config"
+ "krillin-ai/internal/types"
"krillin-ai/log"
"os"
"path/filepath"
+ "strings"
"testing"
"github.com/BurntSushi/toml"
@@ -66,10 +71,16 @@ func initService() *Service {
return NewService()
}
+type fixedSplitCompleter struct{}
+
+func (fixedSplitCompleter) ChatCompletion(string) (string, error) {
+ return `{"short_sentences":[{"text":"then one more thing is search for file count"},{"text":"file explorer note count is the name of the plug in"}]}`, nil
+}
+
func Test_splitOriginLongSentence(t *testing.T) {
// 固定的测试文件路径
testText := "then one more thing is search for file count file explorer note count is the name of the plug in install it and once enabled you can see that now I can see how many files are in each are inside each individual folder even the nested folders are showing properly now how many files are in them"
- s := initService()
+ s := &Service{ChatCompleter: fixedSplitCompleter{}}
// 执行测试
splitTextSentences, err := s.splitOriginLongSentence(testText)
if err != nil {
@@ -81,3 +92,147 @@ func Test_splitOriginLongSentence(t *testing.T) {
fmt.Printf("Sentence %d: %s\n", i+1, sentence)
}
}
+
+type echoBatchCompleter struct {
+ batchSizes []int
+}
+
+func (c *echoBatchCompleter) ChatCompletion(prompt string) (string, error) {
+ const marker = "输入 JSON:\n"
+ start := strings.LastIndex(prompt, marker)
+ if start < 0 {
+ return "", errors.New("missing input JSON")
+ }
+ var input struct {
+ Items []struct {
+ Index int `json:"index"`
+ Text string `json:"text"`
+ } `json:"items"`
+ }
+ if err := json.Unmarshal([]byte(prompt[start+len(marker):]), &input); err != nil {
+ return "", err
+ }
+ c.batchSizes = append(c.batchSizes, len(input.Items))
+ output := struct {
+ Translations []struct {
+ Index int `json:"index"`
+ Text string `json:"text"`
+ } `json:"translations"`
+ }{}
+ for _, item := range input.Items {
+ output.Translations = append(output.Translations, struct {
+ Index int `json:"index"`
+ Text string `json:"text"`
+ }{Index: item.Index, Text: "translated: " + item.Text})
+ }
+ data, err := json.Marshal(output)
+ return string(data), err
+}
+
+func TestSplitTextAndTranslateUsesBatchesAndReportsProgress(t *testing.T) {
+ previousMaxSentenceLength := config.Conf.App.MaxSentenceLength
+ config.Conf.App.MaxSentenceLength = 100
+ t.Cleanup(func() { config.Conf.App.MaxSentenceLength = previousMaxSentenceLength })
+
+ parts := make([]string, 13)
+ for index := range parts {
+ parts[index] = fmt.Sprintf("Sentence number %d is here.", index+1)
+ }
+ completer := &echoBatchCompleter{}
+ service := Service{ChatCompleter: completer}
+ var progress []int
+ results, err := service.splitTextAndTranslateV2(
+ context.Background(),
+ t.TempDir(),
+ strings.Join(parts, " "),
+ types.StandardLanguageCode("en"),
+ types.StandardLanguageCode("zh_cn"),
+ false,
+ 0,
+ func(completed, total int) error {
+ if total != 13 {
+ t.Fatalf("progress total = %d, want 13", total)
+ }
+ progress = append(progress, completed)
+ return nil
+ },
+ )
+ if err != nil {
+ t.Fatal(err)
+ }
+ if fmt.Sprint(completer.batchSizes) != "[12 1]" {
+ t.Fatalf("batch sizes = %v, want [12 1]", completer.batchSizes)
+ }
+ if fmt.Sprint(progress) != "[12 13]" {
+ t.Fatalf("progress = %v, want [12 13]", progress)
+ }
+ if len(results) != 13 || results[12].TranslatedText == results[12].OriginText {
+ t.Fatalf("unexpected results: %+v", results)
+ }
+}
+
+type scriptedCompleter struct {
+ responses []string
+ calls int
+}
+
+func (c *scriptedCompleter) ChatCompletion(string) (string, error) {
+ if c.calls >= len(c.responses) {
+ return "", errors.New("unexpected call")
+ }
+ response := c.responses[c.calls]
+ c.calls++
+ return response, nil
+}
+
+func TestTranslateSentenceRangeSplitsFailedBatch(t *testing.T) {
+ log.InitLogger()
+ completer := &scriptedCompleter{responses: []string{
+ `not-json`,
+ `{"translations":[{"index":1,"text":"A"},{"index":2,"text":"B"}]}`,
+ `{"translations":[{"index":1,"text":"C"},{"index":2,"text":"D"}]}`,
+ }}
+ service := Service{ChatCompleter: completer}
+ sentences := []string{"a", "b", "c", "d"}
+ results := make([]*TranslatedItem, len(sentences))
+ var completed []int
+ err := service.translateSentenceRange(
+ context.Background(),
+ sentences,
+ results,
+ 0,
+ len(sentences),
+ types.StandardLanguageCode("zh_cn"),
+ false,
+ func(count int) error {
+ completed = append(completed, count)
+ return nil
+ },
+ )
+ if err != nil {
+ t.Fatal(err)
+ }
+ if completer.calls != 3 || fmt.Sprint(completed) != "[2 2]" {
+ t.Fatalf("calls = %d, completed = %v", completer.calls, completed)
+ }
+ if got := []string{results[0].TranslatedText, results[1].TranslatedText, results[2].TranslatedText, results[3].TranslatedText}; fmt.Sprint(got) != "[A B C D]" {
+ t.Fatalf("translations = %v", got)
+ }
+}
+
+func TestParseTranslationBatchRejectsMissingItems(t *testing.T) {
+ _, err := parseTranslationBatch(`{"translations":[{"index":1,"text":"A"}]}`, 2)
+ if err == nil {
+ t.Fatal("parseTranslationBatch() error = nil, want count error")
+ }
+}
+
+func TestParseTranslationBatchAcceptsFencedJSON(t *testing.T) {
+ translations, err := parseTranslationBatch("```JSON\n{\"translations\":[{\"index\":1,\"text\":\"A\"}]}\n```", 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(translations) != 1 || translations[0] != "A" {
+ t.Fatalf("translations = %v", translations)
+ }
+}
diff --git a/internal/service/get_video_info.go b/internal/service/get_video_info.go
index 02b73b3b..d99ea42d 100644
--- a/internal/service/get_video_info.go
+++ b/internal/service/get_video_info.go
@@ -63,7 +63,7 @@ func (s Service) getVideoInfo(ctx context.Context, stepParam *types.SubtitleTask
taskPtr.Description = description
taskPtr.OriginLanguage = string(stepParam.OriginLanguage)
taskPtr.TargetLanguage = string(stepParam.TargetLanguage)
- taskPtr.ProcessPct = 10
+ taskPtr.SetProgress(10)
splitResult := strings.Split(result, "####")
if len(splitResult) == 1 {
taskPtr.TranslatedTitle = splitResult[0]
diff --git a/internal/service/link2file.go b/internal/service/link2file.go
index c42ee970..e4d5c90f 100644
--- a/internal/service/link2file.go
+++ b/internal/service/link2file.go
@@ -23,7 +23,7 @@ func (s Service) linkToFile(ctx context.Context, stepParam *types.SubtitleTaskSt
link := stepParam.Link
audioPath := fmt.Sprintf("%s/%s", stepParam.TaskBasePath, types.SubtitleTaskAudioFileName)
videoPath := fmt.Sprintf("%s/%s", stepParam.TaskBasePath, types.SubtitleTaskVideoFileName)
- stepParam.TaskPtr.ProcessPct = 3
+ stepParam.TaskPtr.SetProgress(3)
if strings.Contains(link, "local:") {
// 本地文件
videoPath = strings.ReplaceAll(link, "local:", "")
@@ -62,7 +62,7 @@ func (s Service) linkToFile(ctx context.Context, stepParam *types.SubtitleTaskSt
output, err = cmd.CombinedOutput()
if err != nil {
log.GetLogger().Error("linkToFile download audio yt-dlp error", zap.Any("step param", stepParam), zap.String("output", string(output)), zap.Error(err))
- return fmt.Errorf("linkToFile download audio yt-dlp error: %w", err)
+ return fmt.Errorf("linkToFile download audio yt-dlp error: %w: %s", err, compactCommandOutput(output))
}
}
} else if strings.Contains(link, "bilibili.com") {
@@ -82,13 +82,13 @@ func (s Service) linkToFile(ctx context.Context, stepParam *types.SubtitleTaskSt
output, err = cmd.CombinedOutput()
if err != nil {
log.GetLogger().Error("linkToFile download audio yt-dlp error", zap.Any("step param", stepParam), zap.String("output", string(output)), zap.Error(err))
- return fmt.Errorf("linkToFile download audio yt-dlp error: %w", err)
+ return fmt.Errorf("linkToFile download audio yt-dlp error: %w: %s", err, compactCommandOutput(output))
}
} else {
log.GetLogger().Info("linkToFile.unsupported link type", zap.Any("step param", stepParam))
return errors.New("linkToFile error: unsupported link, only support youtube, bilibili and local file")
}
- stepParam.TaskPtr.ProcessPct = 6
+ stepParam.TaskPtr.SetProgress(6)
stepParam.AudioFilePath = audioPath
if !strings.HasPrefix(link, "local:") && stepParam.EmbedSubtitleVideoType != "none" {
@@ -104,12 +104,21 @@ func (s Service) linkToFile(ctx context.Context, stepParam *types.SubtitleTaskSt
output, err = cmd.CombinedOutput()
if err != nil {
log.GetLogger().Error("linkToFile download video yt-dlp error", zap.Any("step param", stepParam), zap.String("output", string(output)), zap.Error(err))
- return fmt.Errorf("linkToFile download video yt-dlp error: %w", err)
+ return fmt.Errorf("linkToFile download video yt-dlp error: %w: %s", err, compactCommandOutput(output))
}
}
stepParam.InputVideoPath = videoPath
// 更新字幕任务信息
- stepParam.TaskPtr.ProcessPct = 10
+ stepParam.TaskPtr.SetProgress(10)
return nil
}
+
+func compactCommandOutput(output []byte) string {
+ const maximum = 1200
+ value := strings.TrimSpace(string(output))
+ if len(value) <= maximum {
+ return value
+ }
+ return value[len(value)-maximum:]
+}
diff --git a/internal/service/render_stage.go b/internal/service/render_stage.go
index 2bc52ef8..276b7f8a 100644
--- a/internal/service/render_stage.go
+++ b/internal/service/render_stage.go
@@ -36,8 +36,14 @@ func renderAssPath(req RenderVideoRequest) string {
func escapeAssFilterPath(path string) string {
p := strings.ReplaceAll(path, "\\", "/")
- p = strings.ReplaceAll(p, ":", `\:`)
- return p
+ return strings.NewReplacer(
+ `\`, `\\`,
+ `'`, `\'`,
+ `:`, `\:`,
+ `,`, `\,`,
+ `[`, `\[`,
+ `]`, `\]`,
+ ).Replace(p)
}
func buildEmbedSubtitleArgs(req RenderVideoRequest) ([]string, string) {
@@ -46,7 +52,7 @@ func buildEmbedSubtitleArgs(req RenderVideoRequest) ([]string, string) {
return []string{
"-y",
"-i", req.InputVideo,
- "-vf", fmt.Sprintf("ass=%s", ass),
+ "-vf", fmt.Sprintf("ass=filename='%s'", ass),
"-c:v", "libx264",
"-preset", "fast",
"-c:a", "aac",
diff --git a/internal/service/render_stage_test.go b/internal/service/render_stage_test.go
index f4d7b408..18dc22d5 100644
--- a/internal/service/render_stage_test.go
+++ b/internal/service/render_stage_test.go
@@ -52,6 +52,20 @@ func TestEscapeAssFilterPathEscapesWindowsDriveAndSeparators(t *testing.T) {
}
}
+func TestBuildEmbedSubtitleArgsQuotesEscapedAssFilename(t *testing.T) {
+ req := RenderVideoRequest{
+ Workdir: `C:\tasks\demo`,
+ InputVideo: `C:\tasks\demo\origin_video.mp4`,
+ OutputFile: `C:\tasks\demo\horizontal.mp4`,
+ Horizontal: true,
+ }
+ args, _ := buildEmbedSubtitleArgs(req)
+ joined := strings.Join(args, " ")
+ if !strings.Contains(joined, `ass=filename='C\:/tasks/demo/formatted_horizontal.ass'`) {
+ t.Fatalf("args do not contain a quoted escaped ASS filename: %v", args)
+ }
+}
+
func TestPrepareRenderVideoInputConvertsHorizontalVerticalRequest(t *testing.T) {
workdir := filepath.Join("tasks", "demo")
req := RenderVideoRequest{
@@ -177,3 +191,16 @@ func TestBuildVerticalFilterEscapesTitleTextAndUsesCompactHeader(t *testing.T) {
t.Fatalf("filter did not escape title text safely: %s", filter)
}
}
+
+func TestBuildVerticalFilterEscapesWindowsFontPathOnce(t *testing.T) {
+ filter := buildVerticalFilter("", "", `C:\Windows\Fonts\msyhbd.ttc`, `C\:/Windows/Fonts/msyh.ttc`)
+ if !strings.Contains(filter, `fontfile='C\:/Windows/Fonts/msyhbd.ttc'`) {
+ t.Fatalf("filter did not normalize native Windows font path: %s", filter)
+ }
+ if !strings.Contains(filter, `fontfile='C\:/Windows/Fonts/msyh.ttc'`) {
+ t.Fatalf("filter did not preserve an already escaped Windows font path: %s", filter)
+ }
+ if strings.Contains(filter, `C\\:/Windows/Fonts`) {
+ t.Fatalf("filter escaped the Windows drive separator twice: %s", filter)
+ }
+}
diff --git a/internal/service/srt2speech.go b/internal/service/srt2speech.go
index 001ffccb..bfed2cd7 100644
--- a/internal/service/srt2speech.go
+++ b/internal/service/srt2speech.go
@@ -88,7 +88,7 @@ func (s Service) srtFileToSpeech(ctx context.Context, stepParam *types.SubtitleT
stepParam.TtsResultFilePath = result.Audio
stepParam.VideoWithTtsFilePath = result.Video
if stepParam.TaskPtr != nil {
- stepParam.TaskPtr.ProcessPct = 98
+ stepParam.TaskPtr.SetProgress(98)
}
return nil
}
diff --git a/internal/service/srt_embed.go b/internal/service/srt_embed.go
index f7ca57c0..5bed51c9 100644
--- a/internal/service/srt_embed.go
+++ b/internal/service/srt_embed.go
@@ -912,9 +912,9 @@ func fontCandidatesForOS(goos string) ([]fontPair, error) {
switch goos {
case "windows":
return []fontPair{
- {bold: "C\\:/Windows/Fonts/msyhbd.ttc", regular: "C\\:/Windows/Fonts/msyh.ttc"},
- {bold: "C\\:/Windows/Fonts/simhei.ttf", regular: "C\\:/Windows/Fonts/msyh.ttc"},
- {bold: "C\\:/Windows/Fonts/simsun.ttc", regular: "C\\:/Windows/Fonts/simsun.ttc"},
+ {bold: "C:/Windows/Fonts/msyhbd.ttc", regular: "C:/Windows/Fonts/msyh.ttc"},
+ {bold: "C:/Windows/Fonts/simhei.ttf", regular: "C:/Windows/Fonts/msyh.ttc"},
+ {bold: "C:/Windows/Fonts/simsun.ttc", regular: "C:/Windows/Fonts/simsun.ttc"},
}, nil
case "darwin":
return []fontPair{
@@ -950,8 +950,7 @@ func chooseFontPair(candidates []fontPair, exists func(string) bool) (string, st
}
func pathExists(path string) bool {
- normalized := strings.ReplaceAll(path, `C\:/`, `C:/`)
- _, err := os.Stat(normalized)
+ _, err := os.Stat(filepath.FromSlash(path))
return err == nil
}
@@ -1048,5 +1047,7 @@ func escapeDrawtextText(text string) string {
}
func escapeFilterPath(path string) string {
- return strings.ReplaceAll(path, ":", `\:`)
+ normalized := strings.ReplaceAll(path, `\:/`, `:/`)
+ normalized = strings.ReplaceAll(normalized, `\`, `/`)
+ return strings.ReplaceAll(normalized, ":", `\:`)
}
diff --git a/internal/service/srt_timeline.go b/internal/service/srt_timeline.go
new file mode 100644
index 00000000..6fa1cb87
--- /dev/null
+++ b/internal/service/srt_timeline.go
@@ -0,0 +1,134 @@
+package service
+
+import (
+ "bufio"
+ "fmt"
+ "krillin-ai/pkg/util"
+ "os"
+ "regexp"
+ "strconv"
+ "strings"
+)
+
+const minimumSRTDurationMillis int64 = 300
+
+var srtTimelinePattern = regexp.MustCompile(`^(\d{2}):(\d{2}):(\d{2}),(\d{3})\s+-->\s+(\d{2}):(\d{2}):(\d{2}),(\d{3})$`)
+
+func normalizeSrtBlocks(blocks []*util.SrtBlock, allowOverlaps bool) error {
+ var previousEnd int64 = -1
+ for index, block := range blocks {
+ if block == nil {
+ return fmt.Errorf("cue %d is nil", index+1)
+ }
+ start, end, err := parseSRTTimeline(block.Timestamp)
+ if err != nil {
+ return fmt.Errorf("cue %d: %w", index+1, err)
+ }
+ if !allowOverlaps && previousEnd >= 0 && start < previousEnd {
+ start = previousEnd
+ }
+ if end <= start {
+ end = start + minimumSRTDurationMillis
+ }
+ block.Timestamp = formatSRTTimeline(start, end)
+ if end > previousEnd {
+ previousEnd = end
+ }
+ }
+ return nil
+}
+
+func NormalizeSRTFile(path string, allowOverlaps bool) error {
+ file, err := os.Open(path)
+ if err != nil {
+ return err
+ }
+ defer func() { _ = file.Close() }()
+
+ var blocks [][]string
+ var current []string
+ scanner := bufio.NewScanner(file)
+ flush := func() error {
+ if len(current) == 0 {
+ return nil
+ }
+ if len(current) < 3 {
+ return fmt.Errorf("invalid SRT block %d", len(blocks)+1)
+ }
+ blocks = append(blocks, append([]string(nil), current...))
+ current = nil
+ return nil
+ }
+ for scanner.Scan() {
+ line := scanner.Text()
+ if strings.TrimSpace(line) == "" {
+ if err := flush(); err != nil {
+ return err
+ }
+ continue
+ }
+ current = append(current, line)
+ }
+ if err := scanner.Err(); err != nil {
+ return err
+ }
+ if err := flush(); err != nil {
+ return err
+ }
+ if err := file.Close(); err != nil {
+ return err
+ }
+ if len(blocks) == 0 {
+ return fmt.Errorf("invalid SRT: empty subtitle")
+ }
+
+ timeline := make([]*util.SrtBlock, len(blocks))
+ for index, block := range blocks {
+ timeline[index] = &util.SrtBlock{Timestamp: strings.TrimSpace(block[1])}
+ }
+ if err := normalizeSrtBlocks(timeline, allowOverlaps); err != nil {
+ return err
+ }
+ var output strings.Builder
+ for index, block := range blocks {
+ block[1] = timeline[index].Timestamp
+ output.WriteString(strings.Join(block, "\n"))
+ output.WriteString("\n\n")
+ }
+ return os.WriteFile(path, []byte(output.String()), 0644)
+}
+
+func parseSRTTimeline(value string) (int64, int64, error) {
+ match := srtTimelinePattern.FindStringSubmatch(value)
+ if match == nil {
+ return 0, 0, fmt.Errorf("invalid SRT timestamp %q", value)
+ }
+ values := make([]int64, 8)
+ for index := range values {
+ parsed, err := strconv.ParseInt(match[index+1], 10, 64)
+ if err != nil {
+ return 0, 0, fmt.Errorf("invalid SRT timestamp %q: %w", value, err)
+ }
+ values[index] = parsed
+ }
+ if values[1] >= 60 || values[2] >= 60 || values[5] >= 60 || values[6] >= 60 {
+ return 0, 0, fmt.Errorf("invalid SRT timestamp range %q", value)
+ }
+ start := ((values[0]*60+values[1])*60+values[2])*1000 + values[3]
+ end := ((values[4]*60+values[5])*60+values[6])*1000 + values[7]
+ return start, end, nil
+}
+
+func formatSRTTimeline(start, end int64) string {
+ return fmt.Sprintf("%s --> %s", formatSRTTime(start), formatSRTTime(end))
+}
+
+func formatSRTTime(value int64) string {
+ hours := value / 3_600_000
+ value %= 3_600_000
+ minutes := value / 60_000
+ value %= 60_000
+ seconds := value / 1_000
+ millis := value % 1_000
+ return fmt.Sprintf("%02d:%02d:%02d,%03d", hours, minutes, seconds, millis)
+}
diff --git a/internal/service/srt_timeline_test.go b/internal/service/srt_timeline_test.go
new file mode 100644
index 00000000..479d8816
--- /dev/null
+++ b/internal/service/srt_timeline_test.go
@@ -0,0 +1,87 @@
+package service
+
+import (
+ "krillin-ai/internal/types"
+ "krillin-ai/pkg/util"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+)
+
+func TestNormalizeSrtBlocksRepairsInvalidDurationsAndOverlap(t *testing.T) {
+ blocks := []*util.SrtBlock{
+ {Timestamp: "00:00:01,000 --> 00:00:01,000"},
+ {Timestamp: "00:00:00,500 --> 00:00:00,400"},
+ }
+ if err := normalizeSrtBlocks(blocks, false); err != nil {
+ t.Fatal(err)
+ }
+ if blocks[0].Timestamp != "00:00:01,000 --> 00:00:01,300" {
+ t.Fatalf("first timestamp = %q", blocks[0].Timestamp)
+ }
+ if blocks[1].Timestamp != "00:00:01,300 --> 00:00:01,600" {
+ t.Fatalf("second timestamp = %q", blocks[1].Timestamp)
+ }
+}
+
+func TestNormalizeSrtBlocksAllowsMixedSubtitleOverlap(t *testing.T) {
+ blocks := []*util.SrtBlock{
+ {Timestamp: "00:00:01,000 --> 00:00:02,000"},
+ {Timestamp: "00:00:01,200 --> 00:00:01,500"},
+ }
+ if err := normalizeSrtBlocks(blocks, true); err != nil {
+ t.Fatal(err)
+ }
+ if blocks[1].Timestamp != "00:00:01,200 --> 00:00:01,500" {
+ t.Fatalf("overlapping timestamp was changed: %q", blocks[1].Timestamp)
+ }
+}
+
+func TestNormalizeSRTFileRepairsMergedTimelineAndPreservesText(t *testing.T) {
+ path := filepath.Join(t.TempDir(), "merged.srt")
+ content := "1\n00:00:01,000 --> 00:00:02,000\nhello\n你好\n\n2\n00:00:01,500 --> 00:00:01,400\nworld\n世界\n\n"
+ if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+ t.Fatal(err)
+ }
+ if err := NormalizeSRTFile(path, false); err != nil {
+ t.Fatal(err)
+ }
+ data, err := os.ReadFile(path)
+ if err != nil {
+ t.Fatal(err)
+ }
+ result := string(data)
+ if !strings.Contains(result, "00:00:02,000 --> 00:00:02,300") {
+ t.Fatalf("timeline was not repaired: %q", result)
+ }
+ if !strings.Contains(result, "hello\n你好") || !strings.Contains(result, "world\n世界") {
+ t.Fatalf("subtitle text changed: %q", result)
+ }
+}
+
+type fixedTimestampMatcher struct{}
+
+func (fixedTimestampMatcher) GetLanguageType() types.StandardLanguageCode {
+ return types.StandardLanguageCode("test")
+}
+
+func (fixedTimestampMatcher) MatchSentenceTimestamp(string, []types.Word, float64) (float64, float64, error) {
+ return 1, 2, nil
+}
+
+func TestTimestampGeneratorDoesNotMutateInputBlocks(t *testing.T) {
+ generator := NewTimestampGenerator()
+ generator.RegisterMatcher(types.StandardLanguageCode("test"), fixedTimestampMatcher{})
+ input := []*util.SrtBlock{{OriginLanguageSentence: "hello"}}
+ output, err := generator.GenerateTimestamps(input, []types.Word{{Text: "hello", Start: 1, End: 2}}, types.StandardLanguageCode("test"), 0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if input[0].Timestamp != "" {
+ t.Fatalf("input timestamp mutated to %q", input[0].Timestamp)
+ }
+ if output[0] == input[0] || output[0].Timestamp != "00:00:01,000 --> 00:00:02,000" {
+ t.Fatalf("unexpected output: %+v", output[0])
+ }
+}
diff --git a/internal/service/stage_exports.go b/internal/service/stage_exports.go
index 0a58075e..27fa02de 100644
--- a/internal/service/stage_exports.go
+++ b/internal/service/stage_exports.go
@@ -3,6 +3,8 @@ package service
import (
"context"
"errors"
+ "krillin-ai/config"
+ "krillin-ai/internal/deps"
"krillin-ai/internal/types"
pkgimage "krillin-ai/pkg/image"
)
@@ -10,11 +12,37 @@ import (
var ErrYouTubeSubtitleServiceNotInitialized = errors.New("youtube subtitle service not initialized")
var ErrImageClientNotInitialized = errors.New("image client not initialized")
+type DownloadMediaResult struct {
+ VideoPath string
+ AudioPath string
+}
+
+func (s Service) DownloadMedia(ctx context.Context, input, workdir, taskID string) (DownloadMediaResult, error) {
+ step := &types.SubtitleTaskStepParam{
+ TaskId: taskID,
+ TaskPtr: &types.SubtitleTask{TaskId: taskID, Status: types.SubtitleTaskStatusProcessing},
+ TaskBasePath: workdir,
+ Link: input,
+ VttSwitch: false,
+ EmbedSubtitleVideoType: "all",
+ }
+ if err := s.PrepareMedia(ctx, step); err != nil {
+ return DownloadMediaResult{}, err
+ }
+ return DownloadMediaResult{VideoPath: step.InputVideoPath, AudioPath: step.AudioFilePath}, nil
+}
+
func (s Service) PrepareMedia(ctx context.Context, stepParam *types.SubtitleTaskStepParam) error {
return s.linkToFile(ctx, stepParam)
}
func (s Service) GenerateSubtitlesFromAudio(ctx context.Context, stepParam *types.SubtitleTaskStepParam) error {
+ if err := config.ValidateTranscriptionConfig(); err != nil {
+ return err
+ }
+ if err := deps.CheckTranscriptionDependency(); err != nil {
+ return err
+ }
return s.audioToSubtitle(ctx, stepParam)
}
diff --git a/internal/service/stage_exports_test.go b/internal/service/stage_exports_test.go
index 313b795b..0ae439c0 100644
--- a/internal/service/stage_exports_test.go
+++ b/internal/service/stage_exports_test.go
@@ -3,6 +3,7 @@ package service
import (
"context"
"errors"
+ "krillin-ai/config"
"krillin-ai/internal/types"
"testing"
)
@@ -22,6 +23,18 @@ func TestStageExportMethodsExist(t *testing.T) {
var _ stageExporter = Service{}
}
+func TestGenerateSubtitlesFromAudioValidatesTranscriptionWhenUsed(t *testing.T) {
+ previous := config.Conf
+ t.Cleanup(func() { config.Conf = previous })
+ config.Conf.Transcribe.Provider = "openai"
+ config.Conf.Transcribe.Openai.ApiKey = ""
+
+ err := (Service{}).GenerateSubtitlesFromAudio(context.Background(), &types.SubtitleTaskStepParam{})
+ if err == nil {
+ t.Fatal("GenerateSubtitlesFromAudio() error = nil, want missing transcription configuration")
+ }
+}
+
func TestYouTubeStageExportsReturnErrorWhenServiceMissing(t *testing.T) {
var svc Service
diff --git a/internal/service/subtitle_service.go b/internal/service/subtitle_service.go
index 59b5cd37..08cef94f 100644
--- a/internal/service/subtitle_service.go
+++ b/internal/service/subtitle_service.go
@@ -217,7 +217,7 @@ func (s Service) StartSubtitleTask(req dto.StartVideoSubtitleTaskReq) (*dto.Star
if err != nil {
return
}
- stepParam.TaskPtr.ProcessPct = 95
+ stepParam.TaskPtr.SetProgress(95)
} else {
// 非YouTube视频,使用原来的音频转录流程
err = s.audioToSubtitle(ctx, &stepParam)
diff --git a/internal/service/timestamps.go b/internal/service/timestamps.go
index 2a33ee23..f0d00fb7 100644
--- a/internal/service/timestamps.go
+++ b/internal/service/timestamps.go
@@ -68,7 +68,8 @@ func (tg *TimestampGenerator) GenerateTimestamps(srtBlocks []*util.SrtBlock, wor
updatedBlocks := make([]*util.SrtBlock, len(srtBlocks))
for i, block := range srtBlocks {
- updatedBlocks[i] = block
+ updatedBlock := *block
+ updatedBlocks[i] = &updatedBlock
if block.OriginLanguageSentence == "" {
// Skip empty sentences
diff --git a/internal/service/translate.go b/internal/service/translate.go
index 6771e9ff..e6349afe 100644
--- a/internal/service/translate.go
+++ b/internal/service/translate.go
@@ -627,7 +627,7 @@ func (t *Translator) BatchTranslateSrtBlocks(blocks []*util.SrtBlock, originLang
// 更新任务进度
if taskPtr != nil {
progress := float64(currentBatchNum) / float64(totalBatches)
- taskPtr.ProcessPct = 40 + uint8(progress*50)
+ taskPtr.SetProgress(40 + uint8(progress*50))
}
continue
}
@@ -647,7 +647,7 @@ func (t *Translator) BatchTranslateSrtBlocks(blocks []*util.SrtBlock, originLang
if taskPtr != nil {
progress := float64(currentBatchNum) / float64(totalBatches)
// 假设翻译在40%-90%之间
- taskPtr.ProcessPct = 40 + uint8(progress*50)
+ taskPtr.SetProgress(40 + uint8(progress*50))
}
}
diff --git a/internal/service/upload_subtitle.go b/internal/service/upload_subtitle.go
index 7470bc70..f87d47bc 100644
--- a/internal/service/upload_subtitle.go
+++ b/internal/service/upload_subtitle.go
@@ -33,7 +33,7 @@ func (s Service) uploadSubtitles(ctx context.Context, stepParam *types.SubtitleT
taskPtr := stepParam.TaskPtr
taskPtr.SubtitleInfos = subtitleInfos
taskPtr.Status = types.SubtitleTaskStatusSuccess
- taskPtr.ProcessPct = 100
+ taskPtr.SetProgress(100)
// 配音文件
if stepParam.TtsResultFilePath != "" {
taskPtr.SpeechDownloadUrl = "/api/file/" + stepParam.TtsResultFilePath
diff --git a/internal/service/youtube_subtitle.go b/internal/service/youtube_subtitle.go
index 67325c33..b5528907 100644
--- a/internal/service/youtube_subtitle.go
+++ b/internal/service/youtube_subtitle.go
@@ -159,6 +159,7 @@ func (s *YouTubeSubtitleService) downloadYouTubeSubtitle(ctx context.Context, re
// 添加重试机制
maxAttempts := 3
var lastErr error
+ var lastOutput []byte
for attempt := 0; attempt < maxAttempts; attempt++ {
log.GetLogger().Info("Attempting to download YouTube subtitle",
@@ -184,6 +185,7 @@ func (s *YouTubeSubtitleService) downloadYouTubeSubtitle(ctx context.Context, re
}
lastErr = err
+ lastOutput = output
log.GetLogger().Warn("downloadYouTubeSubtitle attempt failed",
zap.Any("taskId", req.TaskId),
zap.Int("attempt", attempt+1),
@@ -197,7 +199,12 @@ func (s *YouTubeSubtitleService) downloadYouTubeSubtitle(ctx context.Context, re
}
log.GetLogger().Error("downloadYouTubeSubtitle failed after all attempts", zap.Any("req", req), zap.Error(lastErr))
- return "", fmt.Errorf("downloadYouTubeSubtitle yt-dlp error after %d attempts: %w", maxAttempts, lastErr)
+ return "", fmt.Errorf(
+ "downloadYouTubeSubtitle yt-dlp error after %d attempts: %w: %s",
+ maxAttempts,
+ lastErr,
+ compactCommandOutput(lastOutput),
+ )
}
// 查找下载的字幕文件
@@ -255,7 +262,7 @@ func (s *YouTubeSubtitleService) processYouTubeSubtitle(ctx context.Context, req
// 更新进度:开始处理
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 10
+ req.TaskPtr.SetProgress(10)
}
// 1. 提取VTT单词
@@ -276,7 +283,7 @@ func (s *YouTubeSubtitleService) processYouTubeSubtitle(ctx context.Context, req
// 更新进度:提取完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 20
+ req.TaskPtr.SetProgress(20)
}
// 2. 组织成句子
@@ -288,7 +295,7 @@ func (s *YouTubeSubtitleService) processYouTubeSubtitle(ctx context.Context, req
// 更新进度:句子组织完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 30
+ req.TaskPtr.SetProgress(30)
}
// 3. 生成原始语言SRT文件(origin_language_srt.srt)
@@ -303,7 +310,7 @@ func (s *YouTubeSubtitleService) processYouTubeSubtitle(ctx context.Context, req
// 更新进度:原始SRT生成完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 40
+ req.TaskPtr.SetProgress(40)
}
// 4. 批量翻译生成目标语言SRT(40%-90%进度)
@@ -315,7 +322,7 @@ func (s *YouTubeSubtitleService) processYouTubeSubtitle(ctx context.Context, req
// 更新进度:翻译完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 90
+ req.TaskPtr.SetProgress(90)
}
// 5. 生成目标语言SRT文件(target_language_srt.srt)
@@ -328,7 +335,7 @@ func (s *YouTubeSubtitleService) processYouTubeSubtitle(ctx context.Context, req
// 更新进度:目标语言SRT生成完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 92
+ req.TaskPtr.SetProgress(92)
}
// 6. 生成双语字幕文件(bilingual_srt.srt)
@@ -341,7 +348,7 @@ func (s *YouTubeSubtitleService) processYouTubeSubtitle(ctx context.Context, req
// 更新进度:双语字幕生成完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 95
+ req.TaskPtr.SetProgress(95)
}
// 7. 生成短字幕文件(竖屏用)
@@ -356,7 +363,7 @@ func (s *YouTubeSubtitleService) processYouTubeSubtitle(ctx context.Context, req
// 更新进度:短字幕生成完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 98
+ req.TaskPtr.SetProgress(98)
}
// 8. 生成纯文本文件到output目录
@@ -378,7 +385,7 @@ func (s *YouTubeSubtitleService) processYouTubeSubtitle(ctx context.Context, req
// 更新进度:完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 100
+ req.TaskPtr.SetProgress(100)
}
log.GetLogger().Info("processYouTubeSubtitle 处理完成",
@@ -865,7 +872,7 @@ func (s *YouTubeSubtitleService) writeVttWordsToSrt(vttWords []VttWord, srtFile
// 更新进度到15%
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = baseProgress + uint8(float64(targetProgress-baseProgress)*0.1)
+ req.TaskPtr.SetProgress(baseProgress + uint8(float64(targetProgress-baseProgress)*0.1))
log.GetLogger().Info("Progress updated after grouping sentences",
zap.Uint8("progress", req.TaskPtr.ProcessPct))
}
@@ -947,7 +954,7 @@ func (s *YouTubeSubtitleService) writeVttWordsToSrt(vttWords []VttWord, srtFile
// 实时更新翻译进度
if req.TaskPtr != nil {
currentTranslationProgress := float64(completedTasks) / float64(len(sentences))
- req.TaskPtr.ProcessPct = translationProgressBase + uint8(float64(translationProgressRange)*currentTranslationProgress)
+ req.TaskPtr.SetProgress(translationProgressBase + uint8(float64(translationProgressRange)*currentTranslationProgress))
// 每完成5个或完成所有任务时记录日志
if completedTasks%5 == 0 || completedTasks == len(sentences) {
@@ -977,7 +984,7 @@ func (s *YouTubeSubtitleService) writeVttWordsToSrt(vttWords []VttWord, srtFile
// 更新进度到85%(结果整理完成)
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = baseProgress + uint8(float64(targetProgress-baseProgress)*0.85)
+ req.TaskPtr.SetProgress(baseProgress + uint8(float64(targetProgress-baseProgress)*0.85))
log.GetLogger().Info("Progress updated after organizing results",
zap.Uint8("progress", req.TaskPtr.ProcessPct))
}
@@ -990,7 +997,7 @@ func (s *YouTubeSubtitleService) writeVttWordsToSrt(vttWords []VttWord, srtFile
// 更新进度到88%(正常SRT文件写入完成)
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = baseProgress + uint8(float64(targetProgress-baseProgress)*0.88)
+ req.TaskPtr.SetProgress(baseProgress + uint8(float64(targetProgress-baseProgress)*0.88))
log.GetLogger().Info("Progress updated after writing SRT file",
zap.Uint8("progress", req.TaskPtr.ProcessPct))
}
@@ -1007,7 +1014,7 @@ func (s *YouTubeSubtitleService) writeVttWordsToSrt(vttWords []VttWord, srtFile
// 最终更新进度到90%(所有操作完成)
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = targetProgress
+ req.TaskPtr.SetProgress(targetProgress)
log.GetLogger().Info("writeVttWordsToSrt completed",
zap.Uint8("final_progress", req.TaskPtr.ProcessPct),
zap.Int("total_srt_blocks", len(srtBlocks)))
@@ -3196,7 +3203,7 @@ func (s *YouTubeSubtitleService) ProcessBlockLevelVtt(ctx context.Context, req *
// 更新进度:开始处理
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 20
+ req.TaskPtr.SetProgress(20)
}
// 1. 转换VTT到临时SRT文件
@@ -3209,7 +3216,7 @@ func (s *YouTubeSubtitleService) ProcessBlockLevelVtt(ctx context.Context, req *
// 更新进度:VTT转换完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 30
+ req.TaskPtr.SetProgress(30)
}
// 2. 生成原文SRT文件(origin_language_srt.srt)
@@ -3227,7 +3234,7 @@ func (s *YouTubeSubtitleService) ProcessBlockLevelVtt(ctx context.Context, req *
// 更新进度:原文SRT生成完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 40
+ req.TaskPtr.SetProgress(40)
}
// 3. 解析SRT文件
@@ -3246,7 +3253,7 @@ func (s *YouTubeSubtitleService) ProcessBlockLevelVtt(ctx context.Context, req *
// 更新进度:翻译完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 90
+ req.TaskPtr.SetProgress(90)
}
// 5. 生成目标语言SRT文件(target_language_srt.srt)
@@ -3259,7 +3266,7 @@ func (s *YouTubeSubtitleService) ProcessBlockLevelVtt(ctx context.Context, req *
// 更新进度:目标语言SRT生成完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 95
+ req.TaskPtr.SetProgress(95)
}
// 6. 生成双语字幕文件(bilingual_srt.srt)
@@ -3272,7 +3279,7 @@ func (s *YouTubeSubtitleService) ProcessBlockLevelVtt(ctx context.Context, req *
// 更新进度:完成
if req.TaskPtr != nil {
- req.TaskPtr.ProcessPct = 100
+ req.TaskPtr.SetProgress(100)
}
log.GetLogger().Info("block-level VTT处理完成",
diff --git a/internal/types/subtitle_task.go b/internal/types/subtitle_task.go
index c854a1a6..6d0c05e1 100644
--- a/internal/types/subtitle_task.go
+++ b/internal/types/subtitle_task.go
@@ -400,6 +400,30 @@ type SubtitleTask struct {
SpeechDownloadUrl string `json:"speech_download_url" gorm:"column:speech_download_url"` // 语音文件下载地址
CreateTime int64 `json:"create_time" gorm:"column:create_time;autoCreateTime"` // 创建时间
UpdateTime int64 `json:"update_time" gorm:"column:update_time;autoUpdateTime"` // 更新时间
+ progressReporter func(uint8)
+}
+
+func (t *SubtitleTask) SetProgressReporter(reporter func(uint8)) {
+ if t == nil {
+ return
+ }
+ t.progressReporter = reporter
+}
+
+func (t *SubtitleTask) SetProgress(percent uint8) {
+ if t == nil {
+ return
+ }
+ if percent > 100 {
+ percent = 100
+ }
+ if t.ProcessPct == percent {
+ return
+ }
+ t.ProcessPct = percent
+ if t.progressReporter != nil {
+ t.progressReporter(percent)
+ }
}
type Word struct {
diff --git a/pkg/fasterwhisper/transcription.go b/pkg/fasterwhisper/transcription.go
index e5565069..7954c3fd 100644
--- a/pkg/fasterwhisper/transcription.go
+++ b/pkg/fasterwhisper/transcription.go
@@ -4,6 +4,7 @@ import (
"encoding/json"
"krillin-ai/config"
"krillin-ai/internal/storage"
+ "krillin-ai/internal/resourcepath"
"krillin-ai/internal/types"
"krillin-ai/log"
"krillin-ai/pkg/util"
@@ -15,8 +16,14 @@ import (
)
func (c *FastwhisperProcessor) Transcription(audioFile, language, workDir string) (*types.TranscriptionData, error) {
+ modelDir := "./models/"
+ if root, configured, err := resourcepath.Root(); err != nil {
+ return nil, err
+ } else if configured {
+ modelDir = root + string(os.PathSeparator) + "models" + string(os.PathSeparator) + "fasterwhisper"
+ }
cmdArgs := []string{
- "--model_dir", "./models/",
+ "--model_dir", modelDir,
"--model", c.Model,
"--one_word", "2",
"--output_format", "json",
diff --git a/pkg/openai/init.go b/pkg/openai/init.go
index 901e0496..b94cf1fd 100644
--- a/pkg/openai/init.go
+++ b/pkg/openai/init.go
@@ -1,19 +1,44 @@
package openai
import (
+ "net"
+ "net/http"
+ "net/url"
+ "time"
+
"github.com/sashabaranov/go-openai"
)
+const defaultRequestTimeout = 2 * time.Minute
+
type Client struct {
- client *openai.Client
+ client *openai.Client
+ requestTimeout time.Duration
}
func NewClient(baseUrl, apiKey, proxyAddr string) *Client {
+ return newClient(baseUrl, apiKey, proxyAddr, defaultRequestTimeout)
+}
+
+func newClient(baseUrl, apiKey, proxyAddr string, requestTimeout time.Duration) *Client {
cfg := openai.DefaultConfig(apiKey)
if baseUrl != "" {
cfg.BaseURL = baseUrl
}
+ transport := http.DefaultTransport.(*http.Transport).Clone()
+ transport.DialContext = (&net.Dialer{
+ Timeout: 10 * time.Second,
+ KeepAlive: 30 * time.Second,
+ }).DialContext
+ transport.TLSHandshakeTimeout = 10 * time.Second
+ transport.ResponseHeaderTimeout = 30 * time.Second
+ if proxyAddr != "" {
+ if proxyURL, err := url.Parse(proxyAddr); err == nil {
+ transport.Proxy = http.ProxyURL(proxyURL)
+ }
+ }
+ cfg.HTTPClient = &http.Client{Transport: transport}
client := openai.NewClientWithConfig(cfg)
- return &Client{client: client}
+ return &Client{client: client, requestTimeout: requestTimeout}
}
diff --git a/pkg/openai/openai.go b/pkg/openai/openai.go
index 1707ad34..0d6ea915 100644
--- a/pkg/openai/openai.go
+++ b/pkg/openai/openai.go
@@ -3,6 +3,7 @@ package openai
import (
"context"
"encoding/json"
+ "errors"
"fmt"
openai "github.com/sashabaranov/go-openai"
"go.uber.org/zap"
@@ -15,6 +16,15 @@ import (
)
func (c *Client) ChatCompletion(query string) (string, error) {
+ return c.ChatCompletionContext(context.Background(), query)
+}
+
+func (c *Client) ChatCompletionContext(ctx context.Context, query string) (string, error) {
+ if c.requestTimeout > 0 {
+ var cancel context.CancelFunc
+ ctx, cancel = context.WithTimeout(ctx, c.requestTimeout)
+ defer cancel()
+ }
var responseFormat *openai.ChatCompletionResponseFormat
req := openai.ChatCompletionRequest{
@@ -35,10 +45,10 @@ func (c *Client) ChatCompletion(query string) (string, error) {
ResponseFormat: responseFormat,
}
- stream, err := c.client.CreateChatCompletionStream(context.Background(), req)
+ stream, err := c.client.CreateChatCompletionStream(ctx, req)
if err != nil {
log.GetLogger().Error("openai create chat completion stream failed", zap.Error(err))
- return "", err
+ return "", normalizeChatCompletionError(err)
}
defer stream.Close()
@@ -50,7 +60,7 @@ func (c *Client) ChatCompletion(query string) (string, error) {
}
if err != nil {
log.GetLogger().Error("openai stream receive failed", zap.Error(err))
- return "", err
+ return "", normalizeChatCompletionError(err)
}
if len(response.Choices) == 0 {
log.GetLogger().Info("openai stream receive no choices", zap.Any("response", response))
@@ -63,6 +73,16 @@ func (c *Client) ChatCompletion(query string) (string, error) {
return resContent, nil
}
+func normalizeChatCompletionError(err error) error {
+ if errors.Is(err, context.DeadlineExceeded) {
+ return fmt.Errorf("llm_translation_timeout: %w", err)
+ }
+ if errors.Is(err, context.Canceled) {
+ return fmt.Errorf("llm_translation_canceled: %w", err)
+ }
+ return err
+}
+
func (c *Client) Text2Speech(text, voice string, outputFile string) error {
baseUrl := config.Conf.Tts.Openai.BaseUrl
if baseUrl == "" {
diff --git a/pkg/openai/openai_test.go b/pkg/openai/openai_test.go
new file mode 100644
index 00000000..948b0618
--- /dev/null
+++ b/pkg/openai/openai_test.go
@@ -0,0 +1,88 @@
+package openai
+
+import (
+ "context"
+ "errors"
+ "krillin-ai/config"
+ "krillin-ai/log"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync/atomic"
+ "testing"
+ "time"
+)
+
+func TestChatCompletionTimesOut(t *testing.T) {
+ setTestModel(t)
+ release := make(chan struct{})
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ select {
+ case <-r.Context().Done():
+ case <-release:
+ }
+ }))
+ t.Cleanup(func() {
+ close(release)
+ server.Close()
+ })
+
+ client := newClient(server.URL, "test-key", "", 40*time.Millisecond)
+ _, err := client.ChatCompletion("translate")
+ if err == nil || !strings.Contains(err.Error(), "llm_translation_timeout") {
+ t.Fatalf("ChatCompletion() error = %v, want llm_translation_timeout", err)
+ }
+ if !errors.Is(err, context.DeadlineExceeded) {
+ t.Fatalf("ChatCompletion() error = %v, want context deadline", err)
+ }
+}
+
+func TestChatCompletionHonorsParentCancellation(t *testing.T) {
+ setTestModel(t)
+ release := make(chan struct{})
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ select {
+ case <-r.Context().Done():
+ case <-release:
+ }
+ }))
+ t.Cleanup(func() {
+ close(release)
+ server.Close()
+ })
+
+ ctx, cancel := context.WithCancel(context.Background())
+ cancel()
+ client := newClient(server.URL, "test-key", "", time.Second)
+ _, err := client.ChatCompletionContext(ctx, "translate")
+ if err == nil || !strings.Contains(err.Error(), "llm_translation_canceled") {
+ t.Fatalf("ChatCompletionContext() error = %v, want llm_translation_canceled", err)
+ }
+ if !errors.Is(err, context.Canceled) {
+ t.Fatalf("ChatCompletionContext() error = %v, want context canceled", err)
+ }
+}
+
+func TestNewClientUsesConfiguredProxy(t *testing.T) {
+ setTestModel(t)
+ var requests atomic.Int32
+ proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ requests.Add(1)
+ http.Error(w, "proxy reached", http.StatusBadGateway)
+ }))
+ defer proxy.Close()
+
+ client := newClient("http://upstream.invalid/v1", "test-key", proxy.URL, time.Second)
+ _, _ = client.ChatCompletion("translate")
+ if requests.Load() != 1 {
+ t.Fatalf("proxy requests = %d, want 1", requests.Load())
+ }
+}
+
+func setTestModel(t *testing.T) {
+ t.Helper()
+ log.InitLogger()
+ previous := config.Conf.Llm.Model
+ config.Conf.Llm.Model = "test-model"
+ t.Cleanup(func() { config.Conf.Llm.Model = previous })
+}
diff --git a/pkg/whispercpp/transcription.go b/pkg/whispercpp/transcription.go
index 804e5dcc..8b21e898 100644
--- a/pkg/whispercpp/transcription.go
+++ b/pkg/whispercpp/transcription.go
@@ -4,6 +4,7 @@ import (
"encoding/json"
"fmt"
"krillin-ai/internal/storage"
+ "krillin-ai/internal/resourcepath"
"krillin-ai/internal/types"
"krillin-ai/log"
"krillin-ai/pkg/util"
@@ -18,8 +19,12 @@ import (
func (c *WhispercppProcessor) Transcription(audioFile, language, workDir string) (*types.TranscriptionData, error) {
name := util.ChangeFileExtension(audioFile, "")
+ modelPath, err := resourcepath.Resolve("models", "whispercpp", fmt.Sprintf("ggml-%s.bin", c.Model))
+ if err != nil {
+ return nil, err
+ }
cmdArgs := []string{
- "-m", fmt.Sprintf("./models/whispercpp/ggml-%s.bin", c.Model),
+ "-m", modelPath,
"--output-json-full",
"--flash-attn",
"--split-on-word",