@pippit-dev/cli 1.0.45 → 1.0.47

package/dist/xyq-canvas-command-runtime.cjs.sha256

@@ -1,2 +1,2 @@
-f258da52a41a6e5631c169037db8f6bfd34b06c96926e094d85cd6418e6fca31  xyq-canvas-command-runtime.cjs
+8e14b9a2c496491c2ee44da3ed950ac8301b67981dfaba3ab1e042cf8b937298  xyq-canvas-command-runtime.cjs
 3b97217c41dfb3c298185c80b1e70c2b469f552450e53d00fc1dcf7098740ffb  xyq-canvas-command-runtime.cjs.LEGAL.txt

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, 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 i, path := range paths {
-		expanded, err := common.ExpandPath(path)
-		if err != nil {
-			return nil, fmt.Errorf("第%d张参考图片 %q 路径解析失败: %w", i+1, filepath.Base(path), err)
-		}
-		result, err := common.UploadFile(ctx, common.UploadFileOptions{Path: expanded}, runner)
-		if err != nil {
-			return nil, fmt.Errorf("第%d张参考图片 %q 上传失败: %w", i+1, filepath.Base(path), 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)
-	if err != nil {
-		return nil, err
-	}
-	videoAssetIDs, err := uploadMediaList(ctx, "个参考视频", opts.VideoPaths, runner)
-	if err != nil {
-		return nil, err
-	}
-	audioAssetIDs, err := uploadMediaList(ctx, "段参考音频", opts.AudioPaths, 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, 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, mediaLabel string, paths []string, runner *common.Runner) ([]string, error) {
-	assetIDs := make([]string, 0, len(paths))
-	for i, path := range paths {
-		expanded, err := common.ExpandPath(path)
-		if err != nil {
-			return nil, fmt.Errorf("第%d%s %q 路径解析失败: %w", i+1, mediaLabel, filepath.Base(path), err)
-		}
-		result, err := common.UploadFile(ctx, common.UploadFileOptions{Path: expanded}, runner)
-		if err != nil {
-			return nil, fmt.Errorf("第%d%s %q 上传失败: %w", i+1, mediaLabel, filepath.Base(path), 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.45",
+  "version": "1.0.47",
   "description": "Pippit CLI",
   "bin": {
     "pippit-tool-cli": "scripts/run.js"
@@ -10,7 +10,7 @@
     "test:marketing-skill": "node scripts/marketing-skill.test.js",
     "prepack": "node scripts/prepare-canvas-runtime.js",
     "prepare:canvas-runtime": "node scripts/prepare-canvas-runtime.js",
-    "test": "node scripts/version-check.test.js && node scripts/skills.test.js && node scripts/marketing-skill.test.js && node scripts/install-wizard.test.js && node scripts/install-cli.test.js && node scripts/run-help.test.js && node scripts/canvas-command.test.js && node scripts/canvas-command-schema.test.js && node scripts/canvas-command-guides.test.js && node scripts/prepare-canvas-runtime.test.js && node scripts/canvas-command-runtime.test.js && node scripts/canvas-media-identity.test.js && npm run test:canvas-operations && go test ./... && go vet ./...",
+    "test": "node scripts/version-check.test.js && node scripts/skills.test.js && node scripts/marketing-skill.test.js && node scripts/install-wizard.test.js && node scripts/install-cli.test.js && node scripts/run-help.test.js && node scripts/canvas-command.test.js && node scripts/canvas-command-schema.test.js && node scripts/canvas-command-guides.test.js && node scripts/prepare-canvas-runtime.test.js && node scripts/canvas-command-runtime.test.js && node scripts/canvas-media-identity.test.js && node scripts/canvas-video-ratio.test.js && npm run test:canvas-operations && go test ./... && go vet ./...",
     "verify:canvas-runtime": "node scripts/prepare-canvas-runtime.js --check-only",
     "test:canvas-runtime": "node scripts/canvas-command-runtime.test.js",
     "test:canvas-operations": "node scripts/canvas-command-canvas-operations.test.js && node scripts/canvas-command-scene3d-operations.test.js && node scripts/canvas-command-timeline-operations.test.js"

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

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