@pippit-dev/cli 1.0.0 → 1.0.2

package/internal/common/submit_run.go

@@ -0,0 +1,29 @@
+package common
+
+import "github.com/Pippit-dev/pippit-cli/internal/config"
+
+// SubmitRunResponse is the shared response envelope returned by submit_run.
+type SubmitRunResponse struct {
+	Ret    string                `json:"ret"`
+	Errmsg string                `json:"errmsg"`
+	LogID  string                `json:"log_id"`
+	Data   SubmitRunResponseData `json:"data"`
+}
+
+type SubmitRunResponseData struct {
+	WebThreadLink string               `json:"web_thread_link"`
+	Run           SubmitRunResponseRun `json:"run"`
+}
+
+type SubmitRunResponseRun struct {
+	ThreadID string `json:"thread_id"`
+	RunID    string `json:"run_id"`
+}
+
+// SubmitRunPath returns the configured submit_run endpoint path.
+func SubmitRunPath(runner *Runner) string {
+	if runner != nil && runner.Config != nil && runner.Config.Paths != nil && runner.Config.Paths.SubmitRun != "" {
+		return runner.Config.Paths.SubmitRun
+	}
+	return config.SubmitRunPath
+}

package/internal/common/upload_file.go

@@ -2,6 +2,7 @@ package common
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"mime"
 	"os"
@@ -35,36 +36,39 @@ type uploadFileResponse struct {
 
 const uploadFileFieldName = "file"
 
-var allowedUploadExtensions = map[string]bool{
-	".doc":  true,
-	".docx": true,
-	".txt":  true,
-}
-
 func UploadFile(ctx context.Context, opts UploadFileOptions, runner *Runner) (*UploadFileResult, error) {
 	if err := ctx.Err(); err != nil {
-		return nil, err
+		if errors.Is(err, context.Canceled) {
+			return nil, fmt.Errorf("上传文件已取消")
+		}
+		if errors.Is(err, context.DeadlineExceeded) {
+			return nil, fmt.Errorf("上传文件超时")
+		}
+		return nil, fmt.Errorf("上传文件上下文异常: %w", err)
 	}
 	if runner == nil || runner.Client == nil {
-		return nil, fmt.Errorf("upload_file runner client is required")
+		return nil, fmt.Errorf("上传文件运行器客户端缺失")
 	}
 
 	path := strings.TrimSpace(opts.Path)
 	if path == "" {
-		return nil, fmt.Errorf("upload file path is required")
+		return nil, fmt.Errorf("上传文件路径不能为空")
 	}
 	info, err := os.Stat(path)
 	if err != nil {
-		return nil, fmt.Errorf("stat upload file: %w", err)
+		if os.IsNotExist(err) {
+			return nil, fmt.Errorf("上传文件不存在: %s", path)
+		}
+		if os.IsPermission(err) {
+			return nil, fmt.Errorf("没有权限读取上传文件: %s", path)
+		}
+		return nil, fmt.Errorf("获取上传文件信息失败: %w", err)
 	}
 	if info.IsDir() {
-		return nil, fmt.Errorf("upload path %q is a directory", path)
+		return nil, fmt.Errorf("上传路径 %q 是目录，请指定文件", path)
 	}
 
 	ext := strings.ToLower(filepath.Ext(path))
-	if !allowedUploadExtensions[ext] {
-		return nil, fmt.Errorf("unsupported file extension %q; only .doc, .docx, and .txt uploads are supported", ext)
-	}
 	fileName := filepath.Base(path)
 	contentType := mime.TypeByExtension(ext)
 
@@ -75,13 +79,13 @@ func UploadFile(ctx context.Context, opts UploadFileOptions, runner *Runner) (*U
 		FileName:    fileName,
 		ContentType: contentType,
 	}, &resp); err != nil {
-		return nil, fmt.Errorf("upload_file request failed: %w", err)
+		return nil, fmt.Errorf("上传文件请求失败: %w", err)
 	}
 	if resp.Ret != "0" {
 		if resp.Errmsg == "" {
-			resp.Errmsg = "unknown error"
+			resp.Errmsg = "未知错误"
 		}
-		return nil, fmt.Errorf("upload_file failed: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+		return nil, fmt.Errorf("上传文件请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
 	}
 
 	assetID := strings.TrimSpace(resp.Data.PippitAssetID)
@@ -89,7 +93,7 @@ func UploadFile(ctx context.Context, opts UploadFileOptions, runner *Runner) (*U
 		assetID = strings.TrimSpace(resp.Data.AssetID)
 	}
 	if assetID == "" {
-		return nil, fmt.Errorf("upload_file response missing pippit_asset_id")
+		return nil, fmt.Errorf("上传文件响应缺少 pippit_asset_id")
 	}
 
 	return &UploadFileResult{

package/internal/config/config.go

@@ -8,7 +8,7 @@ import (
 
 const (
 	DefaultBaseURL              = "https://xyq.jianying.com"
-	DefaultHTTPTimeout          = 30 * time.Second
+	DefaultHTTPTimeout          = 30 * time.Minute
 	DefaultAuthTTL              = 30 * time.Second
 	DefaultOAuthClientKey       = "mock-cli"
 	DefaultOAuthBaseURL         = "https://passport.bytedance.com"

package/internal/generate_video/generate_video.go

@@ -0,0 +1,199 @@
+package generate_video
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
+
+const (
+	agentNameVideoPart = "pippit_video_part_agent"
+	maxReferenceImages = 9
+	maxReferenceVideos = 3
+)
+
+var (
+	allowedImageExtensionList = []string{".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg"}
+	allowedVideoExtensionList = []string{".mp4", ".avi", ".mov", ".wmv", ".flv", ".webm", ".mkv", ".m4v"}
+	allowedImageExtensions    = makeExtensionSet(allowedImageExtensionList)
+	allowedVideoExtensions    = makeExtensionSet(allowedVideoExtensionList)
+)
+
+// Options is the stable command-facing request shape for generate-video.
+type Options struct {
+	Prompt      string
+	ImagePaths  []string
+	VideoPaths  []string
+	DurationSec *int
+	Ratio       string
+	Model       string
+	Resolution  string
+}
+
+type mediaAsset struct {
+	PippitAssetID string `json:"pippit_asset_id"`
+}
+
+type videoPartToolParam struct {
+	Images      []mediaAsset `json:"images,omitempty"`
+	Prompt      string       `json:"prompt"`
+	DurationSec *int         `json:"duration_sec,omitempty"`
+	Ratio       string       `json:"ratio,omitempty"`
+	Videos      []mediaAsset `json:"videos,omitempty"`
+	Model       string       `json:"model,omitempty"`
+	Resolution  string       `json:"resolution,omitempty"`
+}
+
+// Result is the JSON envelope printed by `pippit-tool-cli generate-video`.
+type Result struct {
+	ThreadID      string `json:"thread_id"`
+	RunID         string `json:"run_id"`
+	WebThreadLink string `json:"web_thread_link"`
+}
+
+func Run(ctx context.Context, opts *Options, runner *common.Runner) (*Result, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("generate-video 运行器客户端缺失")
+	}
+	if err := ValidateOptions(opts); err != nil {
+		return nil, err
+	}
+
+	imageAssetIDs, err := uploadMediaList(ctx, opts.ImagePaths, runner)
+	if err != nil {
+		return nil, fmt.Errorf("上传图片失败: %w", err)
+	}
+	videoAssetIDs, err := uploadMediaList(ctx, opts.VideoPaths, runner)
+	if err != nil {
+		return nil, fmt.Errorf("上传视频失败: %w", err)
+	}
+
+	body := buildSubmitRunBody(opts, imageAssetIDs, videoAssetIDs)
+
+	var resp common.SubmitRunResponse
+	if err := runner.Client.SendRequest(ctx, common.SubmitRunPath(runner), body, &resp); err != nil {
+		return nil, fmt.Errorf("提交 generate-video 请求失败: %w", err)
+	}
+	if resp.Ret != "0" {
+		if resp.Errmsg == "" {
+			resp.Errmsg = "未知错误"
+		}
+		return nil, common.NewLogIDError(fmt.Sprintf("generate-video 请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
+	}
+	if resp.Data.Run.ThreadID == "" {
+		return nil, fmt.Errorf("generate-video 响应缺少 data.run.thread_id")
+	}
+	if resp.Data.Run.RunID == "" {
+		return nil, fmt.Errorf("generate-video 响应缺少 data.run.run_id")
+	}
+
+	return &Result{
+		ThreadID:      resp.Data.Run.ThreadID,
+		RunID:         resp.Data.Run.RunID,
+		WebThreadLink: resp.Data.WebThreadLink,
+	}, nil
+}
+
+func ValidateOptions(opts *Options) error {
+	if opts == nil {
+		return fmt.Errorf("缺少必填参数 --prompt")
+	}
+	if strings.TrimSpace(opts.Prompt) == "" {
+		return fmt.Errorf("缺少必填参数 --prompt")
+	}
+	if len(opts.ImagePaths) > maxReferenceImages {
+		return fmt.Errorf("参考图片最多支持 %d 个，当前传入 %d 个", maxReferenceImages, len(opts.ImagePaths))
+	}
+	if len(opts.VideoPaths) > maxReferenceVideos {
+		return fmt.Errorf("参考视频最多支持 %d 个，当前传入 %d 个", maxReferenceVideos, len(opts.VideoPaths))
+	}
+	if err := validateMediaExtensions("图片", opts.ImagePaths, allowedImageExtensions, allowedImageExtensionList); err != nil {
+		return err
+	}
+	if err := validateMediaExtensions("视频", opts.VideoPaths, allowedVideoExtensions, allowedVideoExtensionList); err != nil {
+		return err
+	}
+	return nil
+}
+
+func validateMediaExtensions(kind string, paths []string, allowed map[string]struct{}, allowedList []string) error {
+	for _, path := range paths {
+		ext := strings.ToLower(filepath.Ext(strings.TrimSpace(path)))
+		if _, ok := allowed[ext]; !ok {
+			return fmt.Errorf("不支持的%s文件后缀 %q，文件：%q；支持的后缀：%s", kind, ext, path, strings.Join(allowedList, ", "))
+		}
+	}
+	return nil
+}
+
+func makeExtensionSet(list []string) map[string]struct{} {
+	set := make(map[string]struct{}, len(list))
+	for _, ext := range list {
+		set[ext] = struct{}{}
+	}
+	return set
+}
+
+func uploadMediaList(ctx context.Context, paths []string, runner *common.Runner) ([]string, error) {
+	assetIDs := make([]string, 0, len(paths))
+	for _, path := range paths {
+		expanded, err := expandPath(path)
+		if err != nil {
+			return nil, err
+		}
+		result, err := common.UploadFile(ctx, common.UploadFileOptions{Path: expanded}, runner)
+		if err != nil {
+			return nil, err
+		}
+		assetIDs = append(assetIDs, result.AssetID)
+	}
+	return assetIDs, nil
+}
+
+func buildSubmitRunBody(opts *Options, imageAssetIDs []string, videoAssetIDs []string) map[string]any {
+	param := videoPartToolParam{
+		Images:      assetRefs(imageAssetIDs),
+		Prompt:      strings.TrimSpace(opts.Prompt),
+		DurationSec: opts.DurationSec,
+		Ratio:       strings.TrimSpace(opts.Ratio),
+		Videos:      assetRefs(videoAssetIDs),
+		Model:       strings.TrimSpace(opts.Model),
+		Resolution:  strings.TrimSpace(opts.Resolution),
+	}
+
+	return map[string]any{
+		"agent_name":            agentNameVideoPart,
+		"message":               strings.TrimSpace(opts.Prompt),
+		"video_part_tool_param": param,
+	}
+}
+
+func assetRefs(assetIDs []string) []mediaAsset {
+	if len(assetIDs) == 0 {
+		return nil
+	}
+	refs := make([]mediaAsset, 0, len(assetIDs))
+	for _, assetID := range assetIDs {
+		refs = append(refs, mediaAsset{PippitAssetID: assetID})
+	}
+	return refs
+}
+
+func expandPath(path string) (string, error) {
+	path = strings.TrimSpace(path)
+	if path == "~" {
+		return os.UserHomeDir()
+	}
+	if strings.HasPrefix(path, "~/") || strings.HasPrefix(path, `~\`) {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", fmt.Errorf("解析用户主目录失败: %w", err)
+		}
+		return filepath.Join(home, path[2:]), nil
+	}
+	return path, nil
+}

package/internal/generate_video/query_result.go

@@ -0,0 +1,291 @@
+package generate_video
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
+
+const completedRunState = 3
+
+// QueryResultOptions is the command-facing request shape for query-result.
+type QueryResultOptions struct {
+	ThreadID    string
+	RunID       string
+	DownloadDir string
+}
+
+// QueryResultResult describes the user-facing query-result outcome.
+type QueryResultResult struct {
+	Completed    bool
+	State        int
+	OutputPaths  []string
+	DownloadURLs []string
+}
+
+type queryThread struct {
+	ThreadID string     `json:"thread_id"`
+	RunList  []queryRun `json:"run_list"`
+}
+
+type queryRun struct {
+	RunID     string       `json:"run_id"`
+	State     int          `json:"state"`
+	EntryList []queryEntry `json:"entry_list"`
+}
+
+type queryEntry struct {
+	Artifact queryArtifact `json:"artifact"`
+}
+
+type queryArtifact struct {
+	Content []queryContent `json:"content"`
+}
+
+type queryContent struct {
+	SubType string           `json:"sub_type"`
+	Data    queryContentData `json:"data"`
+}
+
+type queryContentData struct {
+	Video *queryVideo `json:"video"`
+}
+
+type queryVideo struct {
+	DownloadURL string `json:"download_url"`
+	Title       string `json:"title"`
+	VID         string `json:"vid"`
+	AssetID     string `json:"asset_id"`
+}
+
+func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.Runner) (*QueryResultResult, error) {
+	if err := validateQueryResultOptions(opts); err != nil {
+		return nil, err
+	}
+
+	threadResult, err := common.GetThread(ctx, &common.GetThreadOptions{
+		ThreadID: opts.ThreadID,
+		RunID:    opts.RunID,
+	}, runner)
+	if err != nil {
+		return nil, fmt.Errorf("查询失败：%w", err)
+	}
+
+	thread, err := parseQueryThread(threadResult)
+	if err != nil {
+		return nil, fmt.Errorf("查询失败：%w", err)
+	}
+
+	run, ok := findQueryRun(thread, opts.RunID)
+	if !ok {
+		return nil, fmt.Errorf("查询失败：未找到 run_id=%s 对应的 Run", opts.RunID)
+	}
+	if run.State != completedRunState {
+		return &QueryResultResult{
+			Completed: false,
+			State:     run.State,
+		}, nil
+	}
+
+	videos := extractQueryVideos(run)
+	if len(videos) == 0 {
+		return nil, fmt.Errorf("下载失败：未找到可下载的视频产物")
+	}
+
+	downloadDir, err := expandPath(opts.DownloadDir)
+	if err != nil {
+		return nil, fmt.Errorf("下载失败：解析下载目录失败：%w", err)
+	}
+
+	outputPaths := make([]string, 0, len(videos))
+	downloadURLs := make([]string, 0, len(videos))
+	usedNames := make(map[string]int, len(videos))
+	for i, video := range videos {
+		if strings.TrimSpace(video.DownloadURL) == "" {
+			return nil, fmt.Errorf("下载失败：第 %d 个视频产物 download_url 为空", i+1)
+		}
+		downloadURLs = append(downloadURLs, video.DownloadURL)
+		outputPath := filepath.Join(downloadDir, uniqueQueryResultFileName(videoFileName(video, i+1), usedNames))
+		download, err := common.DownloadResult(ctx, common.DownloadResultOptions{
+			URL:        video.DownloadURL,
+			OutputPath: outputPath,
+			Workers:    5,
+		}, runner)
+		if err != nil {
+			return nil, fmt.Errorf("下载失败：%w", err)
+		}
+		if len(download.Downloaded) > 0 {
+			outputPaths = append(outputPaths, download.Downloaded...)
+			continue
+		}
+		if len(download.AlreadyExist) > 0 {
+			outputPaths = append(outputPaths, download.AlreadyExist...)
+			continue
+		}
+		outputPaths = append(outputPaths, outputPath)
+	}
+
+	return &QueryResultResult{
+		Completed:    true,
+		State:        run.State,
+		OutputPaths:  outputPaths,
+		DownloadURLs: downloadURLs,
+	}, nil
+}
+
+func validateQueryResultOptions(opts *QueryResultOptions) error {
+	if opts == nil {
+		return fmt.Errorf("查询失败：缺少必填参数 --thread-id")
+	}
+	opts.ThreadID = strings.TrimSpace(opts.ThreadID)
+	opts.RunID = strings.TrimSpace(opts.RunID)
+	opts.DownloadDir = strings.TrimSpace(opts.DownloadDir)
+	if opts.ThreadID == "" {
+		return fmt.Errorf("查询失败：缺少必填参数 --thread-id")
+	}
+	if opts.RunID == "" {
+		return fmt.Errorf("查询失败：缺少必填参数 --run-id")
+	}
+	if opts.DownloadDir == "" {
+		return fmt.Errorf("查询失败：缺少必填参数 --download-dir")
+	}
+	return nil
+}
+
+func parseQueryThread(result *common.GetThreadResult) (*queryThread, error) {
+	if result == nil {
+		return nil, fmt.Errorf("get_thread 响应为空")
+	}
+	if len(result.RawData) > 0 {
+		var data map[string]json.RawMessage
+		if err := json.Unmarshal(result.RawData, &data); err == nil {
+			if raw := data["thread"]; len(raw) > 0 {
+				if thread, ok := decodeQueryThread(raw); ok {
+					return thread, nil
+				}
+			}
+		}
+	}
+	return nil, fmt.Errorf("get_thread 响应中未找到 data.thread")
+}
+
+func decodeQueryThread(raw []byte) (*queryThread, bool) {
+	var thread queryThread
+	if err := json.Unmarshal(raw, &thread); err != nil {
+		return nil, false
+	}
+	if thread.ThreadID == "" && len(thread.RunList) == 0 {
+		return nil, false
+	}
+	return &thread, true
+}
+
+func findQueryRun(thread *queryThread, runID string) (queryRun, bool) {
+	for _, run := range thread.RunList {
+		if run.RunID == runID {
+			return run, true
+		}
+	}
+	return queryRun{}, false
+}
+
+func (data *queryContentData) UnmarshalJSON(raw []byte) error {
+	raw = []byte(strings.TrimSpace(string(raw)))
+	if len(raw) == 0 || string(raw) == "null" {
+		return nil
+	}
+	if raw[0] == '"' {
+		var encoded string
+		if err := json.Unmarshal(raw, &encoded); err != nil {
+			return err
+		}
+		encoded = strings.TrimSpace(encoded)
+		if encoded == "" {
+			return nil
+		}
+		raw = []byte(encoded)
+	}
+	if len(raw) == 0 || raw[0] != '{' {
+		return nil
+	}
+	type alias queryContentData
+	return json.Unmarshal(raw, (*alias)(data))
+}
+
+func extractQueryVideos(run queryRun) []queryVideo {
+	videos := make([]queryVideo, 0)
+	for _, entry := range run.EntryList {
+		artifact := entry.Artifact
+		for _, content := range artifact.Content {
+			if content.SubType != "biz/x_data_video" {
+				continue
+			}
+			data := content.Data
+			if data.Video != nil {
+				videos = append(videos, *data.Video)
+			}
+		}
+	}
+	return videos
+}
+
+func videoFileName(video queryVideo, index int) string {
+	name := firstNonEmpty(video.VID, video.Title, video.AssetID)
+	if name == "" {
+		name = "result_" + strconv.Itoa(index)
+	}
+	name = sanitizeFileName(name)
+	if !hasVideoExtension(name) {
+		name += ".mp4"
+	}
+	return name
+}
+
+func hasVideoExtension(name string) bool {
+	switch strings.ToLower(strings.TrimSpace(filepath.Ext(name))) {
+	case ".mp4", ".mov", ".m4v", ".webm":
+		return true
+	default:
+		return false
+	}
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		value = strings.TrimSpace(value)
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func sanitizeFileName(name string) string {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		return "result.mp4"
+	}
+	return strings.Map(func(r rune) rune {
+		if unicode.IsControl(r) || r == '/' || r == '\\' || strings.ContainsRune(`<>:"|?*`, r) {
+			return '_'
+		}
+		return r
+	}, name)
+}
+
+func uniqueQueryResultFileName(name string, used map[string]int) string {
+	count := used[name] + 1
+	used[name] = count
+	if count == 1 {
+		return name
+	}
+	ext := filepath.Ext(name)
+	base := strings.TrimSuffix(name, ext)
+	return fmt.Sprintf("%s-%d%s", base, count, ext)
+}

package/internal/generate_video/query_result_test.go

@@ -0,0 +1,31 @@
+package generate_video
+
+import "testing"
+
+func TestVideoFileNameUsesVIDBeforeTimestampTitle(t *testing.T) {
+	got := videoFileName(queryVideo{
+		Title: "v03c76g10004d8jp38iljhtepa11k25g_2026-06-09T120814.516",
+		VID:   "v03c76g10004d8jp38iljhtepa11k25g",
+	}, 1)
+	want := "v03c76g10004d8jp38iljhtepa11k25g.mp4"
+	if got != want {
+		t.Fatalf("videoFileName() = %q, want %q", got, want)
+	}
+}
+
+func TestVideoFileNameAddsMP4ForTimestampTitleWithoutVID(t *testing.T) {
+	got := videoFileName(queryVideo{
+		Title: "v03c76g10004d8jp38iljhtepa11k25g_2026-06-09T120814.516",
+	}, 1)
+	want := "v03c76g10004d8jp38iljhtepa11k25g_2026-06-09T120814.516.mp4"
+	if got != want {
+		t.Fatalf("videoFileName() = %q, want %q", got, want)
+	}
+}
+
+func TestVideoFileNameKeepsVideoExtension(t *testing.T) {
+	got := videoFileName(queryVideo{Title: "cat_video.mp4"}, 1)
+	if got != "cat_video.mp4" {
+		t.Fatalf("videoFileName() = %q, want cat_video.mp4", got)
+	}
+}