@pippit-dev/cli 1.0.44 → 1.0.46

package/checksums.txt

@@ -1,6 +1,6 @@
-8bf338b7fc4bb3de289778896059f364f91743e7fe3127380e193f29bb10fecf  pippit-tool-cli-1.0.44-darwin-amd64.tar.gz
-fd7aac74fda167481b76e3a7aa2f30e45271670cad11f0e969080db1b135411a  pippit-tool-cli-1.0.44-darwin-arm64.tar.gz
-526e3641047d7e997fb5c271d795337692b0a47c092622747f6e2b4e9d22e473  pippit-tool-cli-1.0.44-linux-amd64.tar.gz
-6170436a3ec60dc2a2681e6f790c6a52d9daa4248ce8c3eede83136a62ccb4b6  pippit-tool-cli-1.0.44-linux-arm64.tar.gz
-d3c7166314bb52deae5e0caf383ac7e3cdde27c61325d6556de43f8f46aa9963  pippit-tool-cli-1.0.44-windows-amd64.zip
-9cb3d470688cd89a42a2267d9d181159dd624937c9590d3b744db25a66edbac9  pippit-tool-cli-1.0.44-windows-arm64.zip
+a22b8aaebe337a2617f238dfcdd425a4133a9c63bebf812f15b834955881233b  pippit-tool-cli-1.0.46-darwin-amd64.tar.gz
+a28e74b130adb63620bd3bb5d382d621e7dfc8a826c7e4663b1fba7f4a623449  pippit-tool-cli-1.0.46-darwin-arm64.tar.gz
+6c7e1a7998e48de298bb1c0263ff26e06a9acd55c8469edc6a7731914109aa3d  pippit-tool-cli-1.0.46-linux-amd64.tar.gz
+1641f4cc8161e4b1f012211c690db07a3fd100ff18845130f77f603e06298cd4  pippit-tool-cli-1.0.46-linux-arm64.tar.gz
+938743186947edac0e27627891066c946d99d8facc80f27b6395eaab88fda0f9  pippit-tool-cli-1.0.46-windows-amd64.zip
+1f8903e4c94214e21c5e86556243a8e95175e076f41261da6210fb51fdca72c2  pippit-tool-cli-1.0.46-windows-arm64.zip

package/cmd/generate_video_test.go

@@ -8,14 +8,18 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync/atomic"
 	"testing"
 
 	"github.com/bytedance/sonic"
 )
 
 func TestGenerateVideo(t *testing.T) {
-	assetIDs := []string{"image_asset_1", "image_asset_2", "video_asset_1", "video_asset_2", "audio_asset_1"}
-	uploadIndex := 0
+	assetIDs := map[string]string{
+		"cat1.jpg": "image_asset_1", "cat2.jpg": "image_asset_2",
+		"video1.mp4": "video_asset_1", "video2.mp4": "video_asset_2", "bgm.wav": "audio_asset_1",
+	}
+	var uploadCount atomic.Int32
 
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.Header.Get("Authorization") != "Bearer test-token" {
@@ -26,9 +30,6 @@ func TestGenerateVideo(t *testing.T) {
 			if r.Method != http.MethodPost {
 				t.Fatalf("upload method = %s, want POST", r.Method)
 			}
-			if uploadIndex >= len(assetIDs) {
-				t.Fatalf("unexpected upload %d", uploadIndex)
-			}
 			if err := r.ParseMultipartForm(1 << 20); err != nil {
 				t.Fatalf("ParseMultipartForm(): %v", err)
 			}
@@ -39,11 +40,15 @@ func TestGenerateVideo(t *testing.T) {
 			if files[0].Filename == "bgm.wav" && !strings.HasPrefix(files[0].Header.Get("Content-Type"), "audio/") {
 				t.Fatalf("audio content type = %q, want audio content type", files[0].Header.Get("Content-Type"))
 			}
-			uploadIndex++
-			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"pippit_asset_id":"` + assetIDs[uploadIndex-1] + `"}}`))
+			assetID, ok := assetIDs[files[0].Filename]
+			if !ok {
+				t.Errorf("unexpected upload %q", files[0].Filename)
+			}
+			uploadCount.Add(1)
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"pippit_asset_id":"` + assetID + `"}}`))
 		case "/api/biz/v1/skill/submit_run":
-			if uploadIndex != len(assetIDs) {
-				t.Fatalf("submit called after %d uploads, want %d", uploadIndex, len(assetIDs))
+			if got := uploadCount.Load(); int(got) != len(assetIDs) {
+				t.Fatalf("submit called after %d uploads, want %d", got, len(assetIDs))
 			}
 			data, err := io.ReadAll(r.Body)
 			if err != nil {
@@ -288,19 +293,24 @@ func TestGenerateVideoAcceptsReferencesBeyondFormerLimits(t *testing.T) {
 		}
 	}
 
-	uploadIndex := 0
+	var uploadCount atomic.Int32
 	submitted := false
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/api/biz/v1/skill/upload_file":
-			if uploadIndex >= len(assetIDs) {
-				t.Fatalf("unexpected upload %d", uploadIndex)
-			}
-			_, _ = w.Write([]byte(`{"ret":"0","data":{"pippit_asset_id":"` + assetIDs[uploadIndex] + `"}}`))
-			uploadIndex++
+			file, header, err := r.FormFile("file")
+			if err != nil {
+				t.Errorf("FormFile(): %v", err)
+				http.Error(w, "invalid upload", http.StatusBadRequest)
+				return
+			}
+			file.Close()
+			defer r.MultipartForm.RemoveAll()
+			uploadCount.Add(1)
+			_, _ = w.Write([]byte(`{"ret":"0","data":{"pippit_asset_id":"` + header.Filename + `"}}`))
 		case "/api/biz/v1/skill/submit_run":
-			if uploadIndex != len(assetIDs) {
-				t.Fatalf("uploaded %d references, want %d", uploadIndex, len(assetIDs))
+			if got := uploadCount.Load(); int(got) != len(assetIDs) {
+				t.Fatalf("uploaded %d references, want %d", got, len(assetIDs))
 			}
 			data, err := io.ReadAll(r.Body)
 			if err != nil {

package/cmd/media_upload_test.go

@@ -0,0 +1,132 @@
+package cmd
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+func TestGenerationCollectsUploadFailuresBeforeReturning(t *testing.T) {
+	for _, command := range []string{"generate-image", "generate-video"} {
+		t.Run(command, func(t *testing.T) {
+			t.Setenv("HOME", t.TempDir())
+			t.Setenv("XDG_CACHE_HOME", t.TempDir())
+			t.Setenv("LocalAppData", t.TempDir())
+			type material struct {
+				flag, name, failure string
+				missing             bool
+			}
+			materials := []material{
+				{flag: "image", name: "rejected-a.jpg", failure: `第1张参考图片 "rejected-a.jpg" 上传失败: 上传文件请求返回失败: ret=1 errmsg=图片不符合社区规范 log_id=log-rejected-a.jpg`},
+				{flag: "image", name: "accepted.jpg"},
+				{flag: "image", name: "rejected-b.jpg", failure: `第3张参考图片 "rejected-b.jpg" 上传失败: 上传文件请求返回失败: ret=1 errmsg=图片不符合社区规范 log_id=log-rejected-b.jpg`},
+			}
+			if command == "generate-video" {
+				materials = append(materials,
+					material{flag: "video", name: "rejected.mp4", failure: `第1个参考视频 "rejected.mp4" 上传失败: 上传文件请求返回失败: ret=1 errmsg=视频不符合社区规范 log_id=log-rejected.mp4`},
+					material{flag: "video", name: "accepted.mp4"},
+					material{flag: "audio", name: "missing.wav", missing: true, failure: `第1段参考音频 "missing.wav" 上传失败: 上传文件不存在:`},
+					material{flag: "audio", name: "unavailable.wav", failure: `第2段参考音频 "unavailable.wav" 上传失败: 上传文件请求返回失败: ret=1 errmsg=服务暂不可用 log_id=log-unavailable.wav`},
+				)
+			}
+			args := []string{command, "--prompt", "test"}
+			if command == "generate-image" {
+				args = append(args, "--model", "Seedream 5.0 Pro")
+			}
+			dir := t.TempDir()
+			for _, item := range materials {
+				path := filepath.Join(dir, item.name)
+				if !item.missing {
+					if err := os.WriteFile(path, []byte("media"), 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				args = append(args, "--"+item.flag, path)
+			}
+			var mu sync.Mutex
+			seen := make(map[string]int)
+			var submits atomic.Int32
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				switch r.URL.Path {
+				case config.GetAvailableModelListPath:
+					_, _ = w.Write([]byte(`{"ret":"0","data":{"scene":"web_image_agent","config_key":"image-key","config":{"models":[{"key":"seedream_5.0_pro","name":"Seedream 5.0 Pro","kind":"image"}]}}}`))
+				case config.UploadFilePath:
+					file, header, err := r.FormFile("file")
+					if err != nil {
+						t.Errorf("FormFile(): %v", err)
+						http.Error(w, "invalid upload", http.StatusBadRequest)
+						return
+					}
+					file.Close()
+					defer r.MultipartForm.RemoveAll()
+					mu.Lock()
+					seen[header.Filename]++
+					mu.Unlock()
+					switch {
+					case strings.HasPrefix(header.Filename, "accepted"):
+						fmt.Fprintf(w, `{"ret":"0","data":{"pippit_asset_id":%q}}`, header.Filename)
+					case header.Filename == "unavailable.wav":
+						fmt.Fprintf(w, `{"ret":"1","errmsg":"服务暂不可用","log_id":%q}`, "log-"+header.Filename)
+					default:
+						reason := "图片不符合社区规范"
+						if strings.HasSuffix(header.Filename, ".mp4") {
+							reason = "视频不符合社区规范"
+						}
+						fmt.Fprintf(w, `{"ret":"1","errmsg":%q,"log_id":%q}`, reason, "log-"+header.Filename)
+					}
+				case config.SubmitRunPath:
+					submits.Add(1)
+					http.Error(w, "must not submit", http.StatusInternalServerError)
+				default:
+					t.Errorf("unexpected request %s", r.URL.Path)
+					http.NotFound(w, r)
+				}
+			}))
+			defer server.Close()
+			var stdout, stderr bytes.Buffer
+			root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+			root.SetArgs(args)
+			err := root.Execute()
+			if err == nil || !strings.Contains(err.Error(), "未提交生成") {
+				t.Fatalf("error = %v, want upload failure summary", err)
+			}
+			var logErr *common.LogIDError
+			if !errors.As(err, &logErr) || logErr.LogID() != "log-rejected-a.jpg" {
+				t.Errorf("aggregated error lost the original LogID error chain: %v", err)
+			}
+			lastPosition := -1
+			mu.Lock()
+			defer mu.Unlock()
+			for _, item := range materials {
+				wantRequests := 1
+				if item.missing {
+					wantRequests = 0
+				}
+				if seen[item.name] != wantRequests {
+					t.Errorf("%s uploaded %d times, want %d", item.name, seen[item.name], wantRequests)
+				}
+				if item.failure != "" {
+					position := strings.Index(err.Error(), item.failure)
+					if position <= lastPosition {
+						t.Errorf("failure missing or out of order: %s; error: %v", item.failure, err)
+					}
+					lastPosition = position
+				}
+			}
+			if submits.Load() != 0 || stdout.Len() != 0 {
+				t.Fatalf("failed uploads created a task: submits=%d stdout=%s", submits.Load(), stdout.String())
+			}
+		})
+	}
+}

package/internal/common/upload_file.go

@@ -94,12 +94,12 @@ func UploadFile(ctx context.Context, opts UploadFileOptions, runner *Runner) (*U
 		if resp.Errmsg == "" {
 			resp.Errmsg = "未知错误"
 		}
-		return nil, fmt.Errorf("上传文件请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+		return nil, NewLogIDError(fmt.Sprintf("上传文件请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
 	}
 
 	assetID := strings.TrimSpace(resp.Data.PippitAssetID)
 	if assetID == "" {
-		return nil, fmt.Errorf("上传文件响应缺少 pippit_asset_id")
+		return nil, NewLogIDError("上传文件响应缺少 pippit_asset_id", resp.LogID)
 	}
 
 	return &UploadFileResult{

package/internal/common/upload_media.go

@@ -0,0 +1,69 @@
+package common
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"sync"
+)
+
+const mediaUploadWorkers = 10
+
+// UploadMediaGroup keeps the original order and type-local numbering of references.
+type UploadMediaGroup struct {
+	Label string
+	Paths []string
+}
+
+// UploadMediaGroups waits for every upload, preserving group and path order even
+// when requests finish out of order. Any failure prevents generation callers
+// from receiving a partial set of asset IDs.
+func UploadMediaGroups(ctx context.Context, runner *Runner, groups ...UploadMediaGroup) ([][]string, error) {
+	type task struct {
+		group int
+		index int
+		slot  int
+	}
+	assetIDs := make([][]string, len(groups))
+	var tasks []task
+	for g, group := range groups {
+		assetIDs[g] = make([]string, len(group.Paths))
+		for i := range group.Paths {
+			tasks = append(tasks, task{group: g, index: i, slot: len(tasks)})
+		}
+	}
+	errs := make([]error, len(tasks))
+	taskCh := make(chan task)
+	var wg sync.WaitGroup
+	for worker := 0; worker < min(mediaUploadWorkers, len(tasks)); worker++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for task := range taskCh {
+				group := groups[task.group]
+				path := group.Paths[task.index]
+				expanded, err := ExpandPath(path)
+				if err != nil {
+					errs[task.slot] = fmt.Errorf("第%d%s %q 路径解析失败: %w", task.index+1, group.Label, filepath.Base(path), err)
+					continue
+				}
+				result, err := UploadFile(ctx, UploadFileOptions{Path: expanded}, runner)
+				if err != nil {
+					errs[task.slot] = fmt.Errorf("第%d%s %q 上传失败: %w", task.index+1, group.Label, filepath.Base(path), err)
+					continue
+				}
+				assetIDs[task.group][task.index] = result.AssetID
+			}
+		}()
+	}
+	for _, task := range tasks {
+		taskCh <- task
+	}
+	close(taskCh)
+	wg.Wait()
+	if err := errors.Join(errs...); err != nil {
+		return nil, fmt.Errorf("参考素材上传失败，未提交生成：\n%w", err)
+	}
+	return assetIDs, nil
+}

package/internal/common/upload_media_test.go

@@ -0,0 +1,192 @@
+package common
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+	"github.com/Pippit-dev/pippit-cli/internal/space"
+)
+
+type mediaUploadClient struct {
+	Client
+	upload func(context.Context, MultipartFile, any) error
+}
+
+func (c mediaUploadClient) SendMultipartRequest(ctx context.Context, _ string, _ map[string]string, file MultipartFile, out any) error {
+	return c.upload(ctx, file, out)
+}
+
+func TestUploadMediaGroupsConcurrentAndOrdered(t *testing.T) {
+	const wantConcurrency = 10
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	groups := []UploadMediaGroup{{Label: "张参考图片"}, {Label: "个参考视频"}, {Label: "段参考音频"}}
+	want := [][]string{
+		{"a.jpg", "b.jpg", "c.jpg", "d.jpg"},
+		{"a.mp4", "b.mp4", "c.mp4", "d.mp4"},
+		{"a.wav", "b.wav", "c.wav", "d.wav"},
+	}
+	release := make(map[string]chan struct{})
+	dir := t.TempDir()
+	for g, names := range want {
+		for _, name := range names {
+			path := filepath.Join(dir, name)
+			if err := os.WriteFile(path, []byte("media"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			groups[g].Paths = append(groups[g].Paths, path)
+			release[name] = make(chan struct{})
+		}
+	}
+	started := make(chan string, len(release))
+	var active, peak atomic.Int32
+	client := mediaUploadClient{upload: func(ctx context.Context, file MultipartFile, out any) error {
+		n := active.Add(1)
+		defer active.Add(-1)
+		for old := peak.Load(); n > old; old = peak.Load() {
+			if peak.CompareAndSwap(old, n) {
+				break
+			}
+		}
+		started <- file.FileName
+		select {
+		case <-release[file.FileName]:
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+		response := out.(*uploadFileResponse)
+		response.Ret = "0"
+		response.Data.PippitAssetID = file.FileName
+		return nil
+	}}
+	type outcome struct {
+		ids [][]string
+		err error
+	}
+	done := make(chan outcome, 1)
+	go func() {
+		ids, err := UploadMediaGroups(ctx, &Runner{Client: client}, groups...)
+		done <- outcome{ids, err}
+	}()
+	var first []string
+	for i := 0; i < wantConcurrency; i++ {
+		select {
+		case name := <-started:
+			first = append(first, name)
+		case <-ctx.Done():
+			t.Fatal("uploads did not start concurrently")
+		}
+	}
+	// Release the first requests in reverse order; IDs must still match inputs.
+	for i := len(first) - 1; i >= 0; i-- {
+		close(release[first[i]])
+	}
+	for i := len(first); i < len(release); i++ {
+		select {
+		case name := <-started:
+			close(release[name])
+		case <-ctx.Done():
+			t.Fatal("remaining uploads did not start")
+		}
+	}
+	select {
+	case got := <-done:
+		if got.err != nil || !reflect.DeepEqual(got.ids, want) {
+			t.Fatalf("UploadMediaGroups() = %v, %v; want %v", got.ids, got.err, want)
+		}
+	case <-ctx.Done():
+		t.Fatal("uploads did not finish")
+	}
+	if got := peak.Load(); got != wantConcurrency {
+		t.Fatalf("peak uploads = %d, want %d", got, wantConcurrency)
+	}
+}
+
+func TestUploadMediaGroupsPreservesSpace(t *testing.T) {
+	for _, teamID := range []string{"0", "12"} {
+		t.Run(teamID, func(t *testing.T) {
+			api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				wantHeader := teamID
+				if teamID == "0" {
+					wantHeader = ""
+				}
+				if r.Header.Get("X-Team-Id") != wantHeader || r.Header.Get("Authorization") != "Bearer test-key" {
+					t.Error("upload lost selected space or authentication")
+				}
+				if r.URL.Path != config.UploadFilePath {
+					t.Errorf("unexpected path %s", r.URL.Path)
+				}
+				file, header, err := r.FormFile("file")
+				if err != nil {
+					t.Errorf("FormFile(): %v", err)
+					http.Error(w, "invalid upload", http.StatusBadRequest)
+					return
+				}
+				file.Close()
+				defer r.MultipartForm.RemoveAll()
+				fmt.Fprintf(w, `{"ret":"0","data":{"pippit_asset_id":%q}}`, header.Filename)
+			}))
+			defer api.Close()
+			store := &space.Store{Dir: t.TempDir(), Account: "account", Origin: api.URL}
+			var stderr bytes.Buffer
+			session := &space.Session{Store: store, Explicit: &teamID, Stderr: &stderr}
+			ctx := WithSpace(context.Background(), session)
+			var paths []string
+			dir := t.TempDir()
+			for i := 0; i < 7; i++ {
+				path := filepath.Join(dir, fmt.Sprintf("image-%d.jpg", i))
+				if err := os.WriteFile(path, []byte("image"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				paths = append(paths, path)
+			}
+			runner := &Runner{Client: NewHTTPClient(api.URL, 5*time.Second, NewAccessKeyAuthorizer("test-key"))}
+			ids, err := UploadMediaGroups(ctx, runner, UploadMediaGroup{Label: "张参考图片", Paths: paths})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Count(stderr.String(), "本次空间：") != 1 || session.TeamID() != teamID {
+				t.Fatalf("space selected more than once or changed: %s", stderr.String())
+			}
+			binding, err := space.DecodeBinding(session.Token())
+			if err != nil || binding.TeamID != teamID {
+				t.Fatalf("space token changed: %+v, %v", binding, err)
+			}
+			for _, id := range ids[0] {
+				ref := space.References{AssetIDs: []string{id}}
+				selected, err := (&space.Session{Store: store, Explicit: &teamID}).Resolve(ref)
+				if err != nil || selected.TeamID != teamID {
+					t.Fatalf("asset %s lost its space: %+v, %v", id, selected, err)
+				}
+				other := "34"
+				if _, err := (&space.Session{Store: store, Explicit: &other}).Resolve(ref); err == nil {
+					t.Fatalf("asset %s accepted in another team", id)
+				}
+			}
+		})
+	}
+}
+
+func TestUploadMediaGroupsCanceledBeforeUpload(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	client := mediaUploadClient{upload: func(context.Context, MultipartFile, any) error {
+		t.Error("canceled batch sent an upload request")
+		return nil
+	}}
+	ids, err := UploadMediaGroups(ctx, &Runner{Client: client}, UploadMediaGroup{Label: "张参考图片", Paths: []string{"a.jpg", "b.jpg"}})
+	if ids != nil || err == nil || strings.Count(err.Error(), "上传文件已取消") != 2 {
+		t.Fatalf("canceled batch = %v, %v", ids, err)
+	}
+}

package/internal/generate_image/generate_image.go

@@ -58,12 +58,14 @@ func Run(ctx context.Context, opts *Options, runner *common.Runner) (*common.Sub
 		return nil, err
 	}
 
-	imageAssetIDs, err := uploadImageList(ctx, opts.ImagePaths, runner)
+	assetIDs, err := common.UploadMediaGroups(ctx, runner,
+		common.UploadMediaGroup{Label: "张参考图片", Paths: opts.ImagePaths},
+	)
 	if err != nil {
-		return nil, fmt.Errorf("上传图片失败: %w", err)
+		return nil, err
 	}
 
-	body := buildSubmitRunBody(opts, modelKey, imageAssetIDs)
+	body := buildSubmitRunBody(opts, modelKey, assetIDs[0])
 
 	var resp common.SubmitRunResponse
 	if err := runner.Client.SendRequest(ctx, common.SubmitRunPath(runner), body, &resp); err != nil {
@@ -126,22 +128,6 @@ func SupportedRatioUsage() string {
 	return ratioUsage
 }
 
-func uploadImageList(ctx context.Context, paths []string, runner *common.Runner) ([]string, error) {
-	assetIDs := make([]string, 0, len(paths))
-	for _, path := range paths {
-		expanded, err := common.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, modelKey string, imageAssetIDs []string) map[string]any {
 	ratio, _ := parseRatio(opts.Ratio)
 	body := map[string]any{

package/internal/generate_video/generate_video.go

@@ -45,20 +45,16 @@ func Run(ctx context.Context, opts *Options, runner *common.Runner) (*Result, er
 		return nil, err
 	}
 
-	imageAssetIDs, err := uploadMediaList(ctx, opts.ImagePaths, runner)
+	assetIDs, err := common.UploadMediaGroups(ctx, runner,
+		common.UploadMediaGroup{Label: "张参考图片", Paths: opts.ImagePaths},
+		common.UploadMediaGroup{Label: "个参考视频", Paths: opts.VideoPaths},
+		common.UploadMediaGroup{Label: "段参考音频", Paths: opts.AudioPaths},
+	)
 	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)
-	}
-	audioAssetIDs, err := uploadMediaList(ctx, opts.AudioPaths, runner)
-	if err != nil {
-		return nil, fmt.Errorf("上传音频失败: %w", err)
+		return nil, err
 	}
 
-	body := buildSubmitRunBody(opts, imageAssetIDs, videoAssetIDs, audioAssetIDs)
+	body := buildSubmitRunBody(opts, assetIDs[0], assetIDs[1], assetIDs[2])
 	// Business attribution belongs to this command, regardless of the selected model.
 	return common.SubmitRunWithBabiParam(ctx, "generate-video", body, runner, map[string]string{
 		"scene_lv1":  "ai_agent",
@@ -99,22 +95,6 @@ func validateMediaExtensions(kind string, paths []string, allowed map[string]str
 	return nil
 }
 
-func uploadMediaList(ctx context.Context, paths []string, runner *common.Runner) ([]string, error) {
-	assetIDs := make([]string, 0, len(paths))
-	for _, path := range paths {
-		expanded, err := common.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, audioAssetIDs []string) map[string]any {
 	prompt := strings.TrimSpace(opts.Prompt)
 	param := common.VideoPartToolParam{

package/internal/space/session.go

@@ -6,17 +6,21 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"sync"
 )
 
 // Session is one command's immutable account/origin/team choice. It is not an
 // authorization grant: every request still uses the current credential.
 // Store is optional when a command explicitly selects its space.
+// Concurrent requests share one selection; local records and diagnostics are
+// serialized without holding the lock during network uploads.
 type Session struct {
 	Store    *Store
 	Explicit *string
 	Expected *Binding
 	Identity func(context.Context) (string, error)
 	Stderr   io.Writer
+	mu       sync.Mutex
 	selected *Selection
 }
 
@@ -49,6 +53,9 @@ func (s *Session) CheckIdentity(ctx context.Context) error {
 // Resolve selects and freezes the command's space, checking each request's
 // records even after freezing. CheckIdentity belongs at the request boundary.
 func (s *Session) Resolve(ref References) (Selection, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
 	explicit := s.Explicit
 	fixed := s.selected
 	if s.Expected != nil {
@@ -129,25 +136,40 @@ func (s *Session) Resolve(ref References) (Selection, error) {
 }
 
 func (s *Session) TeamID() string {
-	if s == nil || s.selected == nil {
+	if s == nil {
+		return "0"
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.selected == nil {
 		return "0"
 	}
 	return s.selected.TeamID
 }
 
 func (s *Session) Token() string {
-	if s == nil || s.selected == nil || s.Store == nil {
+	if s == nil {
 		return ""
 	}
-	data, _ := json.Marshal(Binding{Selection: Selection{TeamID: s.TeamID()}, Account: s.Store.Account, Origin: s.Store.Origin})
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.selected == nil || s.Store == nil {
+		return ""
+	}
+	data, _ := json.Marshal(Binding{Selection: Selection{TeamID: s.selected.TeamID}, Account: s.Store.Account, Origin: s.Store.Origin})
 	return base64.RawURLEncoding.EncodeToString(data)
 }
 
 func (s *Session) Remember(ref References) {
-	if s == nil || s.selected == nil || s.Store == nil || s.Store.Account == "" {
+	if s == nil {
+		return
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.selected == nil || s.Store == nil || s.Store.Account == "" {
 		return
 	}
 	if err := s.Store.Remember(ref, *s.selected); err != nil && s.Stderr != nil {
-		fmt.Fprintf(s.Stderr, "请求已成功，但空间记录保存失败：%v；保留 thread_id=%s run_id=%s asset_ids=%v，后续使用 --team-id %s 查询，不要重复提交。\n", err, ref.ThreadID, ref.RunID, ref.AssetIDs, s.TeamID())
+		fmt.Fprintf(s.Stderr, "请求已成功，但空间记录保存失败：%v；保留 thread_id=%s run_id=%s asset_ids=%v，后续使用 --team-id %s 查询，不要重复提交。\n", err, ref.ThreadID, ref.RunID, ref.AssetIDs, s.selected.TeamID)
 	}
 }

package/package.json

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

package/skills/xyq-nest-skill/SKILL.md

@@ -58,6 +58,8 @@ metadata:
 - 用户明确要求生成或处理，即可在该范围内执行；仅咨询用法、费用或方案时不提交。范围、必填信息或消耗 credits 的授权不明确时，先确认，不重复索要已给出的授权。
 - 提问优先使用宿主实际提供且当前模式允许的工具：Codex 的 `request_user_input` 或 `request_user_input_async`，WorkBuddy 的 `ask_user_question`；不可用时用普通聊天。需要答案时等待答复。
 - 素材参数接收本地文件路径，CLI 内部上传。远程链接不能冒充本地路径；缺少可访问文件时先解决素材获取。单文件必须小于 500 MB（500000000 字节）。
+- `generate-image` / `generate-video` 上传素材失败时，向用户说明 CLI 返回的素材类型、类型内序号、文件名、原始原因和可用的 LogID，并说明尚未提交生成任务。序号按同类型参数的传入顺序从 1 开始，不是所有附件的混合序号；只有服务端明确返回审核拒绝时才说明审核未通过，不能把网络、权限等失败都归为审核问题。
+- `generate-image` / `generate-video` 将所有参考素材按最多 10 个并发上传，等待本批上传结束后统一返回全部失败项；某个素材失败不会跳过其他素材。错误按图片、视频、音频分组及各自输入顺序列出，生成引用也保留输入顺序，不按上传完成先后排序。任一素材失败均不提交生成；向用户一次性列全失败素材，不只转述第一项。网络失败、取消或超时不代表审核通过。根据失败原因等待用户替换对应素材或解决问题，不自动删减素材、重传或重新提交生成。旧 CLI 如首错即停或未返回文件定位，须如实说明其结果范围，不凭图片内容猜测未检查素材的审核结论。
 - 提交成功后立即展示真实 `web_thread_link`；未返回链接时如实说明，保留任务 ID。后续查询和下载失败不能触发重复生成。
 - 每个最终图片/视频都通过宿主文件交付或媒体渲染能力展示为真实附件或可预览媒体。URL、路径列表仅作补充；详细完成标准见共用交付流程。
 

package/dist/checksums.txt

@@ -1,6 +0,0 @@
-8bf338b7fc4bb3de289778896059f364f91743e7fe3127380e193f29bb10fecf  pippit-tool-cli-1.0.44-darwin-amd64.tar.gz
-fd7aac74fda167481b76e3a7aa2f30e45271670cad11f0e969080db1b135411a  pippit-tool-cli-1.0.44-darwin-arm64.tar.gz
-526e3641047d7e997fb5c271d795337692b0a47c092622747f6e2b4e9d22e473  pippit-tool-cli-1.0.44-linux-amd64.tar.gz
-6170436a3ec60dc2a2681e6f790c6a52d9daa4248ce8c3eede83136a62ccb4b6  pippit-tool-cli-1.0.44-linux-arm64.tar.gz
-d3c7166314bb52deae5e0caf383ac7e3cdde27c61325d6556de43f8f46aa9963  pippit-tool-cli-1.0.44-windows-amd64.zip
-9cb3d470688cd89a42a2267d9d181159dd624937c9590d3b744db25a66edbac9  pippit-tool-cli-1.0.44-windows-arm64.zip