@pippit-dev/cli 1.0.2 → 1.0.4

package/README.md

@@ -238,7 +238,7 @@ pippit-tool-cli query-result \
   --download-dir "./output"
 ```
 
-`query-result` 会查询指定 Run；Run 完成后下载视频产物并输出本地结果路径，未完成时输出当前状态和重试提示。
+`query-result` 会查询指定 Run 并输出 JSON。Run 成功完成后下载视频产物，`completed=true`，`videos` 中只包含 `download_url` 和 `output_path`；Run 失败也视为终态，`completed=true` 且填充 `error_message`；Run 未到终态时 `completed=false`。
 
 ## HTTP 客户端
 

package/checksums.txt

@@ -1,6 +1,6 @@
-2674fbc4cf095e321dcba42a0e7ed44ecb50c14236a07c97dbc522227c8819e1  pippit-tool-cli-1.0.2-darwin-amd64.tar.gz
-f58a8babc317bef904699938b69574bb26d28cf191fff5123be305be77e27c3b  pippit-tool-cli-1.0.2-darwin-arm64.tar.gz
-3b33fbf6bc66f77b54e1436c5e231f355fe10787d41fe1310b6575b36e7c7cee  pippit-tool-cli-1.0.2-linux-amd64.tar.gz
-f5e73a43c79d5d4a35872a05ad9d14c1260753042a004ef358c475e7e7c4e764  pippit-tool-cli-1.0.2-linux-arm64.tar.gz
-36f48c0db0f6524d43fd49d2e2cea014166c9dad85834f1cd498c2e8ebfeafd4  pippit-tool-cli-1.0.2-windows-amd64.zip
-b45999f5e9412a2d7728e538b9cedbb715f4ffc397c667e610bcb964311db8f0  pippit-tool-cli-1.0.2-windows-arm64.zip
+889fabfbe3bd94cfeb34f9e3ee5fd9c2b39d5ab57f13e8b2c257dfca142bb2ce  pippit-tool-cli-1.0.4-darwin-amd64.tar.gz
+8c54acc247b9f7050697fd2c52f3df84558fcfe01db3c7e186b4741294738236  pippit-tool-cli-1.0.4-darwin-arm64.tar.gz
+45de9614ed9b4241775f0451e603ab833484810def2eed31e4b3673a9cfe283d  pippit-tool-cli-1.0.4-linux-amd64.tar.gz
+44852e1542b44085d543f2f2672ae9793e6e6bf7457ec90f7efcf46e3e252820  pippit-tool-cli-1.0.4-linux-arm64.tar.gz
+4b921069137fbe129973dbceae7fdbaa8a8f5cc2803ff3347b1e21452c3b9946  pippit-tool-cli-1.0.4-windows-amd64.zip
+adf357fab99845e47933669d0fef8395189e023f69546454f61e4aca14392195  pippit-tool-cli-1.0.4-windows-arm64.zip

package/cmd/generate_video/query_result.go

@@ -1,7 +1,7 @@
 package generate_video
 
 import (
-	"fmt"
+	"encoding/json"
 	"io"
 	"strings"
 
@@ -26,27 +26,11 @@ func NewQueryResultCommand(stdout, stderr io.Writer, runner *common.Runner) *cob
 					"run_id":       strings.TrimSpace(opts.RunID),
 					"download_dir": strings.TrimSpace(opts.DownloadDir),
 				})
-				return err
+				result = queryResultFromError(err, opts)
 			}
-			if !result.Completed {
-				_, err = fmt.Fprintf(stdout, "Run 尚未完成，当前状态：%d\n请稍后重试 query-result。\n", result.State)
-				return err
-			}
-			_, err = fmt.Fprintln(stdout, "Run 已完成，产物已下载：")
-			if err != nil {
-				return err
-			}
-			for i, path := range result.OutputPaths {
-				if _, err := fmt.Fprintln(stdout, path); err != nil {
-					return err
-				}
-				if i < len(result.DownloadURLs) && strings.TrimSpace(result.DownloadURLs[i]) != "" {
-					if _, err := fmt.Fprintf(stdout, "download_url: %s\n", result.DownloadURLs[i]); err != nil {
-						return err
-					}
-				}
-			}
-			return nil
+			encoder := json.NewEncoder(stdout)
+			encoder.SetIndent("", "  ")
+			return encoder.Encode(result)
 		},
 	}
 	cmd.SetOut(stdout)
@@ -56,3 +40,15 @@ func NewQueryResultCommand(stdout, stderr io.Writer, runner *common.Runner) *cob
 	cmd.Flags().StringVar(&opts.DownloadDir, "download-dir", "", "directory to download completed videos into")
 	return cmd
 }
+
+func queryResultFromError(err error, opts *internalgen.QueryResultOptions) *internalgen.QueryResultResult {
+	result := &internalgen.QueryResultResult{
+		ErrorMessage: err.Error(),
+		Videos:       []internalgen.QueryResultVideo{},
+	}
+	if opts != nil {
+		result.ThreadID = strings.TrimSpace(opts.ThreadID)
+		result.RunID = strings.TrimSpace(opts.RunID)
+	}
+	return result
+}

package/cmd/generate_video_test.go

@@ -332,10 +332,34 @@ func TestQueryResultDownloadsCompletedVideo(t *testing.T) {
 	if !requestedDownload {
 		t.Fatal("download endpoint was not requested")
 	}
-	if got := stdout.String(); !strings.Contains(got, "Run 已完成，产物已下载：") ||
-		!strings.Contains(got, outputPath) ||
-		!strings.Contains(got, "download_url: "+downloadURL) {
-		t.Fatalf("stdout = %q, want download path and download url", got)
+	got := decodeJSON(t, stdout.Bytes())
+	if got["completed"] != true {
+		t.Fatalf("completed = %v, want true", got["completed"])
+	}
+	if got["thread_id"] != "thread_123" || got["run_id"] != "run_456" {
+		t.Fatalf("ids = (%v, %v), want thread/run ids", got["thread_id"], got["run_id"])
+	}
+	if _, ok := got["state"]; ok {
+		t.Fatalf("state should not be returned: %#v", got)
+	}
+	if got["error_message"] != "" {
+		t.Fatalf("error_message = %v, want empty", got["error_message"])
+	}
+	videos, ok := got["videos"].([]any)
+	if !ok || len(videos) != 1 {
+		t.Fatalf("videos = %#v, want one video", got["videos"])
+	}
+	video, ok := videos[0].(map[string]any)
+	if !ok {
+		t.Fatalf("video = %#v, want object", videos[0])
+	}
+	if video["download_url"] != downloadURL || video["output_path"] != outputPath {
+		t.Fatalf("video = %#v, want download_url/output_path", video)
+	}
+	for _, unwanted := range []string{"vid", "asset_id", "title"} {
+		if _, ok := video[unwanted]; ok {
+			t.Fatalf("video = %#v, should not contain %s", video, unwanted)
+		}
 	}
 	assertFileContent(t, outputPath, "video-data")
 }
@@ -360,30 +384,64 @@ func TestQueryResultIgnoresVideoDataWithoutVideoSubType(t *testing.T) {
 		"--download-dir", t.TempDir(),
 	})
 
-	err := root.Execute()
-	if err == nil {
-		t.Fatal("Execute() error = nil, want no downloadable video error")
+	if err := root.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
+	}
+	got := decodeJSON(t, stdout.Bytes())
+	if got["completed"] != false {
+		t.Fatalf("completed = %v, want false", got["completed"])
+	}
+	if got["thread_id"] != "thread_123" || got["run_id"] != "run_456" {
+		t.Fatalf("ids = (%v, %v), want thread/run ids", got["thread_id"], got["run_id"])
 	}
-	if !strings.Contains(err.Error(), "下载失败：未找到可下载的视频产物") {
-		t.Fatalf("error = %q, want no downloadable video error", err)
+	if got["error_message"] != "下载失败：未找到可下载的视频产物" {
+		t.Fatalf("error_message = %v, want no downloadable video error", got["error_message"])
 	}
-	if stdout.Len() != 0 {
-		t.Fatalf("stdout = %q, want empty", stdout.String())
+	videos, ok := got["videos"].([]any)
+	if !ok || len(videos) != 0 {
+		t.Fatalf("videos = %#v, want empty", got["videos"])
 	}
 }
 
-func TestQueryResultErrorLogIncludesLogID(t *testing.T) {
+func TestQueryResultValidationErrorReturnsJSON(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, "http://127.0.0.1")
+	root.SetArgs([]string{
+		"query-result",
+		"--run-id", "run_456",
+		"--download-dir", t.TempDir(),
+	})
+
+	if err := root.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
+	}
+	got := decodeJSON(t, stdout.Bytes())
+	if got["completed"] != false {
+		t.Fatalf("completed = %v, want false", got["completed"])
+	}
+	if got["thread_id"] != "" || got["run_id"] != "run_456" {
+		t.Fatalf("ids = (%v, %v), want empty thread_id and run_id", got["thread_id"], got["run_id"])
+	}
+	if got["error_message"] != "查询失败：缺少必填参数 --thread-id" {
+		t.Fatalf("error_message = %v, want validation error", got["error_message"])
+	}
+	videos, ok := got["videos"].([]any)
+	if !ok || len(videos) != 0 {
+		t.Fatalf("videos = %#v, want empty", got["videos"])
+	}
+}
+
+func TestQueryResultGetThreadBusinessErrorReturnsErrorMessage(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/api/biz/v1/skill/get_thread":
-			_, _ = w.Write([]byte(`{"ret":"5","errmsg":"创作失败","log_id":"log_456"}`))
+			_, _ = w.Write([]byte(`{"ret":"5","errmsg":"创作失败：暂时无法生成","log_id":"log_456"}`))
 		default:
 			t.Fatalf("unexpected path %s", r.URL.Path)
 		}
 	}))
 	defer server.Close()
 
-	clearDailyErrorLog(t)
 	var stdout, stderr bytes.Buffer
 	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
 	root.SetArgs([]string{
@@ -393,23 +451,61 @@ func TestQueryResultErrorLogIncludesLogID(t *testing.T) {
 		"--download-dir", t.TempDir(),
 	})
 
-	err := root.Execute()
-	if err == nil {
-		t.Fatal("Execute() error = nil, want get_thread error")
+	if err := root.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
 	}
-	entries := readDailyErrorLog(t)
-	if len(entries) != 1 {
-		t.Fatalf("log entries = %d, want 1: %#v", len(entries), entries)
+	got := decodeJSON(t, stdout.Bytes())
+	if got["completed"] != true {
+		t.Fatalf("completed = %v, want true", got["completed"])
 	}
-	fields, ok := entries[0]["fields"].(map[string]any)
-	if !ok {
-		t.Fatalf("fields = %#v, want object", entries[0]["fields"])
+	if got["thread_id"] != "thread_123" || got["run_id"] != "run_456" {
+		t.Fatalf("ids = (%v, %v), want thread/run ids", got["thread_id"], got["run_id"])
+	}
+	if got["error_message"] != "创作失败：暂时无法生成 log_id=log_456" {
+		t.Fatalf("error_message = %v, want get_thread business error", got["error_message"])
+	}
+	videos, ok := got["videos"].([]any)
+	if !ok || len(videos) != 0 {
+		t.Fatalf("videos = %#v, want empty", got["videos"])
+	}
+}
+
+func TestQueryResultFailedReturnsErrorMessage(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/biz/v1/skill/get_thread":
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"thread":{"thread_id":"thread_123","run_list":[{"run_id":"run_456","state":4,"entry_list":[{"artifact":{"content":[{"sub_type":"biz/x_data_video","data":"{\"error_message\":\"生成失败\",\"error_code\":\"11001\"}"}]}}]}]}}}`))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"query-result",
+		"--thread-id", "thread_123",
+		"--run-id", "run_456",
+		"--download-dir", t.TempDir(),
+	})
+
+	if err := root.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
+	}
+	got := decodeJSON(t, stdout.Bytes())
+	if got["completed"] != true {
+		t.Fatalf("completed = %v, want true", got["completed"])
 	}
-	if fields["log_id"] != "log_456" {
-		t.Fatalf("log_id = %v, want log_456", fields["log_id"])
+	if _, ok := got["state"]; ok {
+		t.Fatalf("state should not be returned: %#v", got)
 	}
-	if fields["thread_id"] != "thread_123" || fields["run_id"] != "run_456" {
-		t.Fatalf("fields = %#v, want thread/run ids", fields)
+	if got["error_message"] != "生成失败 (error_code=11001)" {
+		t.Fatalf("error_message = %v, want failure message", got["error_message"])
+	}
+	videos, ok := got["videos"].([]any)
+	if !ok || len(videos) != 0 {
+		t.Fatalf("videos = %#v, want empty", got["videos"])
 	}
 }
 
@@ -436,8 +532,19 @@ func TestQueryResultPendingDoesNotDownload(t *testing.T) {
 	if err := root.Execute(); err != nil {
 		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
 	}
-	if got := stdout.String(); !strings.Contains(got, "Run 尚未完成，当前状态：1") {
-		t.Fatalf("stdout = %q, want pending state", got)
+	got := decodeJSON(t, stdout.Bytes())
+	if got["completed"] != false {
+		t.Fatalf("completed = %v, want false", got["completed"])
+	}
+	if _, ok := got["state"]; ok {
+		t.Fatalf("state should not be returned: %#v", got)
+	}
+	if got["error_message"] != "" {
+		t.Fatalf("error_message = %v, want empty", got["error_message"])
+	}
+	videos, ok := got["videos"].([]any)
+	if !ok || len(videos) != 0 {
+		t.Fatalf("videos = %#v, want empty", got["videos"])
 	}
 }
 

package/internal/generate_video/query_result.go

@@ -3,6 +3,7 @@ package generate_video
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"path/filepath"
 	"strconv"
@@ -12,7 +13,10 @@ import (
 	"github.com/Pippit-dev/pippit-cli/internal/common"
 )
 
-const completedRunState = 3
+const (
+	successRunState = 3
+	failedRunState  = 4
+)
 
 // QueryResultOptions is the command-facing request shape for query-result.
 type QueryResultOptions struct {
@@ -23,10 +27,17 @@ type QueryResultOptions struct {
 
 // QueryResultResult describes the user-facing query-result outcome.
 type QueryResultResult struct {
-	Completed    bool
-	State        int
-	OutputPaths  []string
-	DownloadURLs []string
+	Completed    bool               `json:"completed"`
+	ThreadID     string             `json:"thread_id"`
+	RunID        string             `json:"run_id"`
+	ErrorMessage string             `json:"error_message"`
+	Videos       []QueryResultVideo `json:"videos"`
+}
+
+// QueryResultVideo describes a downloaded video from query-result.
+type QueryResultVideo struct {
+	DownloadURL string `json:"download_url"`
+	OutputPath  string `json:"output_path"`
 }
 
 type queryThread struct {
@@ -35,9 +46,12 @@ type queryThread struct {
 }
 
 type queryRun struct {
-	RunID     string       `json:"run_id"`
-	State     int          `json:"state"`
-	EntryList []queryEntry `json:"entry_list"`
+	RunID        string       `json:"run_id"`
+	State        int          `json:"state"`
+	ErrorMessage string       `json:"error_message"`
+	ErrorMsg     string       `json:"error_msg"`
+	Errmsg       string       `json:"errmsg"`
+	EntryList    []queryEntry `json:"entry_list"`
 }
 
 type queryEntry struct {
@@ -54,7 +68,9 @@ type queryContent struct {
 }
 
 type queryContentData struct {
-	Video *queryVideo `json:"video"`
+	Video        *queryVideo     `json:"video"`
+	ErrorMessage string          `json:"error_message"`
+	ErrorCode    json.RawMessage `json:"error_code"`
 }
 
 type queryVideo struct {
@@ -74,6 +90,9 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 		RunID:    opts.RunID,
 	}, runner)
 	if err != nil {
+		if result, ok := queryResultFromGetThreadBusinessError(err, opts); ok {
+			return result, nil
+		}
 		return nil, fmt.Errorf("查询失败：%w", err)
 	}
 
@@ -86,11 +105,17 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 	if !ok {
 		return nil, fmt.Errorf("查询失败：未找到 run_id=%s 对应的 Run", opts.RunID)
 	}
-	if run.State != completedRunState {
-		return &QueryResultResult{
-			Completed: false,
-			State:     run.State,
-		}, nil
+	if run.State != successRunState {
+		result := &QueryResultResult{
+			Completed: run.State == failedRunState,
+			ThreadID:  firstNonEmpty(thread.ThreadID, opts.ThreadID),
+			RunID:     opts.RunID,
+			Videos:    []QueryResultVideo{},
+		}
+		if run.State == failedRunState {
+			result.ErrorMessage = firstNonEmpty(extractQueryErrorMessage(run), "Run 失败")
+		}
+		return result, nil
 	}
 
 	videos := extractQueryVideos(run)
@@ -103,14 +128,12 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 		return nil, fmt.Errorf("下载失败：解析下载目录失败：%w", err)
 	}
 
-	outputPaths := make([]string, 0, len(videos))
-	downloadURLs := make([]string, 0, len(videos))
+	resultVideos := make([]QueryResultVideo, 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,
@@ -120,25 +143,55 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 		if err != nil {
 			return nil, fmt.Errorf("下载失败：%w", err)
 		}
+		actualOutputPath := outputPath
 		if len(download.Downloaded) > 0 {
-			outputPaths = append(outputPaths, download.Downloaded...)
-			continue
+			actualOutputPath = download.Downloaded[0]
+		} else if len(download.AlreadyExist) > 0 {
+			actualOutputPath = download.AlreadyExist[0]
 		}
-		if len(download.AlreadyExist) > 0 {
-			outputPaths = append(outputPaths, download.AlreadyExist...)
-			continue
-		}
-		outputPaths = append(outputPaths, outputPath)
+		resultVideos = append(resultVideos, QueryResultVideo{
+			DownloadURL: video.DownloadURL,
+			OutputPath:  actualOutputPath,
+		})
 	}
 
 	return &QueryResultResult{
-		Completed:    true,
-		State:        run.State,
-		OutputPaths:  outputPaths,
-		DownloadURLs: downloadURLs,
+		Completed: true,
+		ThreadID:  firstNonEmpty(thread.ThreadID, opts.ThreadID),
+		RunID:     opts.RunID,
+		Videos:    resultVideos,
 	}, nil
 }
 
+func queryResultFromGetThreadBusinessError(err error, opts *QueryResultOptions) (*QueryResultResult, bool) {
+	var logErr *common.LogIDError
+	if !errors.As(err, &logErr) {
+		return nil, false
+	}
+	message := getThreadBusinessErrorMessage(logErr.Message)
+	if message == "" {
+		message = "查询失败"
+	}
+	if logID := logErr.LogID(); logID != "" {
+		message = fmt.Sprintf("%s log_id=%s", message, logID)
+	}
+	return &QueryResultResult{
+		Completed:    true,
+		ThreadID:     opts.ThreadID,
+		RunID:        opts.RunID,
+		ErrorMessage: message,
+		Videos:       []QueryResultVideo{},
+	}, true
+}
+
+func getThreadBusinessErrorMessage(message string) string {
+	message = strings.TrimSpace(message)
+	if idx := strings.Index(message, "errmsg="); idx >= 0 {
+		return strings.TrimSpace(message[idx+len("errmsg="):])
+	}
+	return message
+}
+
 func validateQueryResultOptions(opts *QueryResultOptions) error {
 	if opts == nil {
 		return fmt.Errorf("查询失败：缺少必填参数 --thread-id")
@@ -235,6 +288,39 @@ func extractQueryVideos(run queryRun) []queryVideo {
 	return videos
 }
 
+func extractQueryErrorMessage(run queryRun) string {
+	if message := firstNonEmpty(run.ErrorMessage, run.ErrorMsg, run.Errmsg); message != "" {
+		return message
+	}
+	for _, entry := range run.EntryList {
+		for _, content := range entry.Artifact.Content {
+			data := content.Data
+			if message := firstNonEmpty(data.ErrorMessage); message != "" {
+				if code := rawMessageString(data.ErrorCode); code != "" {
+					return fmt.Sprintf("%s (error_code=%s)", message, code)
+				}
+				return message
+			}
+			if code := rawMessageString(data.ErrorCode); code != "" {
+				return "error_code=" + code
+			}
+		}
+	}
+	return ""
+}
+
+func rawMessageString(raw json.RawMessage) string {
+	raw = json.RawMessage(strings.TrimSpace(string(raw)))
+	if len(raw) == 0 || string(raw) == "null" {
+		return ""
+	}
+	var value string
+	if err := json.Unmarshal(raw, &value); err == nil {
+		return strings.TrimSpace(value)
+	}
+	return strings.TrimSpace(string(raw))
+}
+
 func videoFileName(video queryVideo, index int) string {
 	name := firstNonEmpty(video.VID, video.Title, video.AssetID)
 	if name == "" {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pippit-dev/cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Pippit CLI",
   "bin": {
     "pippit-tool-cli": "scripts/run.js"