@pippit-dev/cli 1.0.25 → 1.0.27

package/internal/models/describe_test.go

@@ -0,0 +1,199 @@
+package models
+
+import (
+	"bytes"
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+func description(t *testing.T, raw string) map[string]json.RawMessage {
+	t.Helper()
+	out, err := describeModel(json.RawMessage(raw))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var fields map[string]json.RawMessage
+	if err := json.Unmarshal(out, &fields); err != nil {
+		t.Fatal(err)
+	}
+	return fields
+}
+
+func TestDescriptionCLIParametersAndRawPreservation(t *testing.T) {
+	raw := `{"key":"MiniMax-H3","supported_ratio_list":[0,2,13,3,4,5,6],"default_ratio":3,"config_key":"internal",
+	"future_field":9007199254740993,"audio_total_limit":0,"max_image_size":31457280,"min_video_duration":2000,
+	"supported_duration_list":[{"value":999}],"default_duration_value":999,
+	"parameter_config":{"dimensions":[
+	{"key":"duration","default_value":"10","range_config":{"min_value":4,"max_value":15,"step":1}},
+	{"key":"resolution","default_value":" 768P ","option_list":[{"value":"768p"},{"value":"2k"},{"value":"4k","disabled":true}]},
+	{"key":"seed","default_value":"random"}],"need_available_combinations":true}}
+	`
+	out := description(t, raw)
+	for _, key := range []string{"config_key", "supported_ratio_list", "default_ratio", "supported_duration_list", "default_duration_value", "audio_total_limit", "max_image_size"} {
+		if _, ok := out[key]; ok {
+			t.Fatalf("unconverted field %s", key)
+		}
+	}
+	var ratio struct {
+		Options []string
+		Default string
+	}
+	if err := json.Unmarshal(out["ratio"], &ratio); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(ratio.Options, []string{"adaptive", "16:9", "21:9", "9:16", "4:3", "3:4", "1:1"}) || ratio.Default != "9:16" {
+		t.Fatalf("ratio=%+v", ratio)
+	}
+	var resolution struct {
+		Options []string
+		Default string
+	}
+	if err := json.Unmarshal(out["resolution"], &resolution); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(resolution.Options, []string{"768p", "2k"}) || resolution.Default != "768p" {
+		t.Fatalf("resolution=%+v", resolution)
+	}
+	var duration struct {
+		Min, Max, Step, Default int
+		Unit                    string
+	}
+	if err := json.Unmarshal(out["duration"], &duration); err != nil {
+		t.Fatal(err)
+	}
+	if duration.Min != 4 || duration.Max != 15 || duration.Step != 1 || duration.Default != 10 || duration.Unit != "seconds" {
+		t.Fatalf("duration=%+v", duration)
+	}
+	if string(out["future_field"]) != "9007199254740993" {
+		t.Fatal("integer precision lost")
+	}
+	var limits map[string]json.RawMessage
+	if err := json.Unmarshal(out["material_limits"], &limits); err != nil {
+		t.Fatal(err)
+	}
+	if string(limits["audio_total_limit"]) != "0" || string(limits["max_image_size_bytes"]) != "31457280" || string(limits["min_video_duration_ms"]) != "2000" {
+		t.Fatalf("limits=%s", out["material_limits"])
+	}
+	if _, ok := limits["video_total_limit"]; ok {
+		t.Fatal("absent limit must stay absent")
+	}
+	if !bytes.Contains(out["parameter_config"], []byte("seed")) || !bytes.Contains(out["parameter_config"], []byte("need_available_combinations")) {
+		t.Fatal("unrelated configuration lost")
+	}
+	if _, ok := out["warnings"]; ok {
+		t.Fatalf("valid dimensions must override legacy durations: %s", out["warnings"])
+	}
+	if !bytes.Contains(out["notes"], []byte("纯文生视频")) {
+		t.Fatal("missing MiniMax adaptive restriction")
+	}
+}
+
+func TestDescriptionUnknownRatioAndDefault(t *testing.T) {
+	for _, value := range []int{1, 999} {
+		raw, _ := json.Marshal(map[string]any{"supported_ratio_list": []int{value, 2, 2}, "default_ratio": value})
+		out := description(t, string(raw))
+		var ratio struct {
+			Options []string
+			Default *string
+		}
+		if err := json.Unmarshal(out["ratio"], &ratio); err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(ratio.Options, []string{"16:9"}) || ratio.Default != nil {
+			t.Fatalf("invented usable value: %+v", ratio)
+		}
+		if _, exists := out["warnings"]; exists {
+			t.Fatal("unknown and custom enums should be silently skipped")
+		}
+	}
+	out := description(t, `{"supported_ratio_list":[0,7,8,9,10,11,12],"default_ratio":0}`)
+	var ratio struct {
+		Options []string
+		Default string
+	}
+	if err := json.Unmarshal(out["ratio"], &ratio); err != nil {
+		t.Fatal(err)
+	}
+	if ratio.Default != "adaptive" || !reflect.DeepEqual(ratio.Options, []string{"adaptive", "2:1", "2.35:1", "1.85:1", "1.125:2.436", "3:2", "2:3"}) {
+		t.Fatalf("ratio=%+v", ratio)
+	}
+}
+
+func TestDescriptionDimensionFailuresAndOptions(t *testing.T) {
+	for _, dimension := range []string{
+		`{"key":"resolution","default_value":"2k","option_list":[{"value":"768p"},{"value":"2k","disabled":true}]}`,
+		`{"key":"resolution","default_value":"","option_list":[]}`,
+		`{"key":"duration","default_value":"7","range_config":{"min_value":4,"max_value":10,"step":2}}`,
+		`{"key":"duration","range_config":{"min_value":10,"max_value":4}}`,
+		`{"key":"duration","option_list":[{"value":"auto"}]}`,
+	} {
+		out := description(t, `{"parameter_config":{"dimensions":[`+dimension+`]}}`)
+		if _, ok := out["warnings"]; !ok {
+			t.Fatalf("missing warning: %s", dimension)
+		}
+		for _, key := range []string{"resolution", "duration"} {
+			var value map[string]json.RawMessage
+			if len(out[key]) == 0 {
+				continue
+			}
+			if err := json.Unmarshal(out[key], &value); err != nil {
+				t.Fatal(err)
+			}
+			if _, ok := value["default"]; ok {
+				t.Fatalf("invalid default exposed: %s", out[key])
+			}
+		}
+	}
+	out := description(t, `{"parameter_config":{"dimensions":[{"key":"duration","default_value":"10","option_list":[{"value":"5"},{"value":"10"},{"value":"15","disabled":true}]}]}}`)
+	var duration struct {
+		Options []int
+		Default int
+		Min     *int
+	}
+	if err := json.Unmarshal(out["duration"], &duration); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(duration.Options, []int{5, 10}) || duration.Default != 10 || duration.Min != nil {
+		t.Fatalf("duration=%+v", duration)
+	}
+}
+
+func TestDescriptionCreationModesAndCacheNotMutated(t *testing.T) {
+	raw := json.RawMessage(`{"key":"MiniMax-H3-Max","kind":"video","supported_ratio_list":[0,2],"default_ratio":2,"creation_mode_config":{"schema_version":1,"default_mode":"text_to_video","modes":[{"key":"text_to_video","enabled":true,"ratio_policy":{"value_mode":"inherit"}},{"key":"first_last_frame","enabled":true,"ratio_policy":{"value_mode":"smart"},"validation_policy":{"required_video_count":0,"forbidden_input_types":["video","audio"]}}]}}`)
+	before := append([]byte(nil), raw...)
+	var catalog Catalog
+	if err := json.Unmarshal([]byte(`{"config":{"models":[]}}`), &catalog); err != nil {
+		t.Fatal(err)
+	}
+	catalog.Config.Models = append(catalog.Config.Models, raw)
+	result, err := catalog.Describe("MiniMax-H3-Max")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var out struct {
+		Modes []struct {
+			GenerateType int `json:"generate_type"`
+			Ratio        struct {
+				Options []string
+				Default string
+			}
+			Validation struct {
+				Required  *int     `json:"required_video_count"`
+				Forbidden []string `json:"forbidden_input_types"`
+			} `json:"validation_policy"`
+		} `json:"creation_modes"`
+	}
+	if err := json.Unmarshal(result, &out); err != nil {
+		t.Fatal(err)
+	}
+	if len(out.Modes) != 2 || out.Modes[0].Ratio.Default != "16:9" || !reflect.DeepEqual(out.Modes[0].Ratio.Options, []string{"16:9"}) || out.Modes[1].GenerateType != 1 || out.Modes[1].Ratio.Default != "adaptive" || !reflect.DeepEqual(out.Modes[1].Ratio.Options, []string{"adaptive"}) {
+		t.Fatalf("modes=%+v", out.Modes)
+	}
+	if out.Modes[1].Validation.Required == nil || *out.Modes[1].Validation.Required != 0 || !reflect.DeepEqual(out.Modes[1].Validation.Forbidden, []string{"video", "audio"}) {
+		t.Fatal("mode requirements lost")
+	}
+	if !bytes.Equal(before, catalog.Config.Models[0]) {
+		t.Fatal("description mutated cached raw config")
+	}
+}

package/internal/models/models.go

@@ -0,0 +1,220 @@
+package models
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+	"github.com/Pippit-dev/pippit-cli/internal/version"
+)
+
+const (
+	Scene    = "web_turbo_video_generator"
+	CacheTTL = 5 * time.Minute
+)
+
+// Catalog preserves the server's model configuration, including unknown fields
+// and integer enums. It is never used as a local generation allowlist.
+type Catalog struct {
+	Scene     string `json:"scene"`
+	ConfigKey string `json:"config_key"`
+	Config    *struct {
+		Models []json.RawMessage `json:"models"`
+	} `json:"config"`
+}
+
+type Summary struct {
+	Key       string `json:"key"`
+	Name      string `json:"name"`
+	Kind      string `json:"kind"`
+	IsDefault bool   `json:"is_default"`
+}
+
+type Result struct {
+	Catalog   *Catalog
+	Cached    bool
+	FetchedAt time.Time
+	Warning   string
+}
+
+type cacheEntry struct {
+	FetchedAt time.Time `json:"fetched_at"`
+	Catalog   *Catalog  `json:"catalog"`
+}
+
+type Service struct {
+	runner   *common.Runner
+	cacheDir string
+	now      func() time.Time
+}
+
+func NewService(runner *common.Runner) *Service {
+	dir, err := os.UserCacheDir()
+	if err == nil {
+		dir = filepath.Join(dir, "pippit-cli", "models")
+	}
+	return &Service{runner: runner, cacheDir: dir, now: time.Now}
+}
+
+func (s *Service) Get(ctx context.Context, refresh bool) (*Result, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	if s.runner == nil || s.runner.Config == nil || s.runner.Client == nil || s.runner.Auth == nil {
+		return nil, fmt.Errorf("模型查询运行器未初始化")
+	}
+	// Resolve credentials before reading cache: logout/expiry must not expose a
+	// previous account's model list. Only a hash is used in the cache filename.
+	accessKey, err := s.runner.Auth.ResolveAccessKey(ctx)
+	if err != nil || strings.TrimSpace(accessKey) == "" {
+		return nil, fmt.Errorf("模型查询需要有效登录，请执行 pippit-tool-cli login 或检查 XYQ_ACCESS_KEY 后重试")
+	}
+	path := config.GetAvailableModelListPath
+	if s.runner.Config.Paths != nil && s.runner.Config.Paths.GetAvailableModelList != "" {
+		path = s.runner.Config.Paths.GetAvailableModelList
+	}
+	cachePath := s.cachePath(accessKey, path)
+	if !refresh && cachePath != "" {
+		if entry := s.readCache(cachePath); entry != nil {
+			return &Result{Catalog: entry.Catalog, Cached: true, FetchedAt: entry.FetchedAt}, nil
+		}
+	}
+	// A failed refresh must not make the next retry reuse an older fresh entry.
+	if cachePath != "" {
+		_ = os.Remove(cachePath)
+	}
+	queryCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+	var resp struct {
+		Ret    string   `json:"ret"`
+		Errmsg string   `json:"errmsg"`
+		LogID  string   `json:"log_id"`
+		Data   *Catalog `json:"data"`
+	}
+	err = s.runner.Client.SendRequest(queryCtx, path, struct {
+		Scene          string `json:"scene"`
+		SourceModelKey string `json:"source_model_key"`
+	}{Scene: Scene}, &resp)
+	if err != nil {
+		return nil, fmt.Errorf("模型查询失败，请稍后重试（可加 --refresh）: %w", err)
+	}
+	if resp.Ret != "0" {
+		return nil, common.NewLogIDError(fmt.Sprintf("模型查询失败，请稍后重试（可加 --refresh）: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
+	}
+	if err := validateCatalog(resp.Data); err != nil {
+		return nil, common.NewLogIDError("模型配置无效，请稍后重试（可加 --refresh）: "+err.Error(), resp.LogID)
+	}
+	currentKey, err := s.runner.Auth.ResolveAccessKey(ctx)
+	if err != nil || currentKey != accessKey {
+		return nil, fmt.Errorf("查询期间登录凭证已变化，请重试模型查询")
+	}
+	result := &Result{Catalog: resp.Data, FetchedAt: s.now().UTC()}
+	if cachePath == "" || s.writeCache(cachePath, result) != nil {
+		result.Warning = "模型查询成功，但本地缓存写入失败；下次查询将重新请求服务端"
+	}
+	return result, nil
+}
+
+func (s *Service) cachePath(accessKey, path string) string {
+	if s.cacheDir == "" {
+		return ""
+	}
+	scope, _ := json.Marshal([]string{
+		"v1", strings.TrimRight(s.runner.Config.BaseURL, "/"), path, Scene,
+		version.Current(), accessKey,
+	})
+	return filepath.Join(s.cacheDir, fmt.Sprintf("%x.json", sha256.Sum256(scope)))
+}
+
+func (s *Service) readCache(path string) *cacheEntry {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return nil
+	}
+	var entry cacheEntry
+	if json.Unmarshal(raw, &entry) != nil || validateCatalog(entry.Catalog) != nil {
+		return nil
+	}
+	age := s.now().Sub(entry.FetchedAt)
+	if age < 0 || age >= CacheTTL {
+		return nil
+	}
+	return &entry
+}
+
+func (s *Service) writeCache(path string, result *Result) error {
+	raw, err := json.Marshal(cacheEntry{FetchedAt: result.FetchedAt, Catalog: result.Catalog})
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(s.cacheDir, 0700); err != nil {
+		return err
+	}
+	f, err := os.CreateTemp(s.cacheDir, ".models-*.tmp")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(f.Name())
+	_, writeErr := f.Write(raw)
+	closeErr := f.Close()
+	if writeErr != nil {
+		return writeErr
+	}
+	if closeErr != nil {
+		return closeErr
+	}
+	return os.Rename(f.Name(), path)
+}
+
+func validateCatalog(catalog *Catalog) error {
+	if catalog == nil || catalog.Config == nil || catalog.Scene != Scene || catalog.ConfigKey == "" {
+		return fmt.Errorf("缺少配置或场景不匹配")
+	}
+	seen := make(map[string]bool)
+	for _, raw := range catalog.Config.Models {
+		var model Summary
+		if json.Unmarshal(raw, &model) != nil || strings.TrimSpace(model.Key) == "" || model.Kind != "video" {
+			return fmt.Errorf("模型条目缺少有效 key 或 kind")
+		}
+		if seen[model.Key] {
+			return fmt.Errorf("模型 key 重复: %s", model.Key)
+		}
+		seen[model.Key] = true
+	}
+	return nil
+}
+
+func (c *Catalog) Search(query string) []Summary {
+	query = strings.TrimSpace(query)
+	matches := make([]Summary, 0)
+	for _, raw := range c.Config.Models {
+		var model Summary
+		_ = json.Unmarshal(raw, &model) // validated at the network/cache boundary
+		if model.Key == query {
+			return []Summary{model}
+		}
+		if query == "" || strings.Contains(strings.ToLower(model.Name), strings.ToLower(query)) || strings.Contains(strings.ToLower(model.Key), strings.ToLower(query)) {
+			matches = append(matches, model)
+		}
+	}
+	return matches
+}
+
+func (c *Catalog) Describe(key string) (json.RawMessage, error) {
+	key = strings.TrimSpace(key)
+	for _, raw := range c.Config.Models {
+		var model Summary
+		_ = json.Unmarshal(raw, &model)
+		if model.Key == key {
+			return describeModel(raw)
+		}
+	}
+	return nil, fmt.Errorf("未找到可用模型 %q；请执行 model list --refresh 查看当前模型", key)
+}

package/internal/models/models_test.go

@@ -0,0 +1,200 @@
+package models
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/Pippit-dev/pippit-cli/internal/auth"
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+const validResponse = `{"ret":"0","data":{"scene":"web_turbo_video_generator","config_key":"key1","config":{"models":[{"key":"new-model","kind":"video","name":"新模型","is_default":true,"supported_ratio_list":[0,1],"audio_total_limit":0,"future_field":9007199254740993}]}}}`
+
+func newTestService(t *testing.T, handler http.HandlerFunc) *Service {
+	t.Helper()
+	server := httptest.NewServer(handler)
+	t.Cleanup(server.Close)
+	cfg := config.Load()
+	cfg.BaseURL, cfg.AccessKey = server.URL, "private-test-key"
+	runner := common.NewRunner(cfg, nil)
+	runner.Auth = auth.NewManager(cfg)
+	runner.Client = common.NewHTTPClient(server.URL, time.Second, common.NewAccessKeyContextProviderAuthorizer(runner.Auth.ResolveAccessKey))
+	s := NewService(runner)
+	s.cacheDir = t.TempDir()
+	return s
+}
+
+type unavailableAuth struct{ common.AuthManager }
+
+func (unavailableAuth) ResolveAccessKey(context.Context) (string, error) {
+	return "", errors.New("expired credential")
+}
+
+func TestMissingCredentialsCannotReadFreshCache(t *testing.T) {
+	requests := 0
+	s := newTestService(t, func(w http.ResponseWriter, _ *http.Request) {
+		requests++
+		_, _ = w.Write([]byte(validResponse))
+	})
+	if _, err := s.Get(context.Background(), false); err != nil {
+		t.Fatal(err)
+	}
+	s.runner.Auth = unavailableAuth{}
+	result, err := s.Get(context.Background(), false)
+	if err == nil || result != nil || requests != 1 || !strings.Contains(err.Error(), "login") {
+		t.Fatalf("must require login before cache: result=%+v err=%v requests=%d", result, err, requests)
+	}
+}
+
+func TestCacheTTLRefreshAndIsolation(t *testing.T) {
+	requests := 0
+	s := newTestService(t, func(w http.ResponseWriter, r *http.Request) {
+		requests++
+		if r.Method != "POST" || r.URL.Path != config.GetAvailableModelListPath || !strings.HasPrefix(r.Header.Get("Authorization"), "Bearer ") {
+			t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
+		}
+		var body map[string]string
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body["scene"] != Scene || body["source_model_key"] != "" {
+			t.Errorf("unexpected body: %v, err=%v", body, err)
+		}
+		_, _ = w.Write([]byte(validResponse))
+	})
+	now := time.Date(2026, 9, 20, 12, 0, 0, 0, time.UTC)
+	s.now = func() time.Time { return now }
+	check := func(refresh, cached bool, count int) *Result {
+		t.Helper()
+		result, err := s.Get(context.Background(), refresh)
+		if err != nil || result.Cached != cached || requests != count {
+			t.Fatalf("Get: result=%+v err=%v requests=%d, want cached=%v requests=%d", result, err, requests, cached, count)
+		}
+		return result
+	}
+	first := check(false, false, 1)
+	now = now.Add(CacheTTL - time.Second)
+	cached := check(false, true, 1)
+	if !cached.FetchedAt.Equal(first.FetchedAt) {
+		t.Fatal("cache hit must not renew TTL")
+	}
+	now = now.Add(time.Second)
+	check(false, false, 2) // expires exactly at five minutes
+	check(true, false, 3)
+	s.runner.Config.AccessKey = "second-account"
+	check(false, false, 4)
+	oldPath := s.cachePath("second-account", config.GetAvailableModelListPath)
+	s.runner.Config.BaseURL += "/other-api"
+	if s.cachePath("second-account", config.GetAvailableModelListPath) == oldPath {
+		t.Fatal("API base URLs must not share cache")
+	}
+	files, _ := os.ReadDir(s.cacheDir)
+	for _, file := range files {
+		raw, _ := os.ReadFile(filepath.Join(s.cacheDir, file.Name()))
+		if strings.Contains(string(raw)+file.Name(), "private-test-key") || strings.Contains(string(raw)+file.Name(), "second-account") {
+			t.Fatal("cache must not persist raw credentials")
+		}
+	}
+}
+
+func TestFailedQueryDoesNotUseOrCacheStaleData(t *testing.T) {
+	response := validResponse
+	requests := 0
+	s := newTestService(t, func(w http.ResponseWriter, _ *http.Request) {
+		requests++
+		_, _ = w.Write([]byte(response))
+	})
+	if _, err := s.Get(context.Background(), false); err != nil {
+		t.Fatal(err)
+	}
+	for _, invalid := range []string{
+		`{"ret":"1001","errmsg":"unavailable","log_id":"log_123"}`,
+		`{"ret":"0","data":null}`,
+		`{"ret":"0","data":{"scene":"other","config_key":"key","config":{}}}`,
+		`not-json`,
+	} {
+		response = invalid
+		if result, err := s.Get(context.Background(), true); err == nil || result != nil || !strings.Contains(err.Error(), "重试") {
+			t.Fatalf("failed query must suggest retry: result=%+v err=%v", result, err)
+		}
+		before := requests
+		if _, err := s.Get(context.Background(), false); err == nil || requests != before+1 {
+			t.Fatal("retry must query the server, not reuse cached success or failure")
+		}
+	}
+	response = validResponse
+	if _, err := s.Get(context.Background(), false); err != nil {
+		t.Fatal(err)
+	}
+	cachePath := s.cachePath(s.runner.Config.AccessKey, config.GetAvailableModelListPath)
+	if err := os.WriteFile(cachePath, []byte("broken"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	result, err := s.Get(context.Background(), false)
+	if err != nil || result.Cached {
+		t.Fatalf("corrupt cache should refresh: %+v %v", result, err)
+	}
+	// A timestamp in the future must not extend visibility indefinitely.
+	s.now = func() time.Time { return result.FetchedAt.Add(-time.Second) }
+	if s.readCache(cachePath) != nil {
+		t.Fatal("future-dated cache must be ignored")
+	}
+}
+
+func TestModelConfigurationPreservedAcrossCache(t *testing.T) {
+	s := newTestService(t, func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write([]byte(validResponse)) })
+	for i := 0; i < 2; i++ {
+		result, err := s.Get(context.Background(), false)
+		if err != nil {
+			t.Fatal(err)
+		}
+		raw, err := result.Catalog.Describe("new-model")
+		if err != nil || !strings.Contains(string(raw), "9007199254740993") || !strings.Contains(string(raw), `"audio_total_limit":0`) {
+			t.Fatalf("configuration lost values: %s %v", raw, err)
+		}
+		if len(result.Catalog.Search("新模")) != 1 || len(result.Catalog.Search("missing")) != 0 {
+			t.Fatal("unexpected search result")
+		}
+		if _, err := result.Catalog.Describe("missing"); err == nil {
+			t.Fatal("missing model must not invent a config")
+		}
+	}
+}
+
+func TestCacheWriteFailureStillReturnsServerResult(t *testing.T) {
+	s := newTestService(t, func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write([]byte(validResponse)) })
+	file := filepath.Join(t.TempDir(), "not-a-directory")
+	if err := os.WriteFile(file, []byte("x"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	s.cacheDir = file
+	result, err := s.Get(context.Background(), false)
+	if err != nil || result.Cached || result.Warning == "" {
+		t.Fatalf("result=%+v err=%v", result, err)
+	}
+}
+
+func TestEmptyAndDuplicateModels(t *testing.T) {
+	for _, tc := range []struct {
+		data  string
+		valid bool
+	}{
+		{`{"scene":"web_turbo_video_generator","config_key":"empty","config":{}}`, true},
+		{`{"scene":"web_turbo_video_generator","config_key":"dup","config":{"models":[{"key":"x","kind":"video"},{"key":"x","kind":"video"}]}}`, false},
+		{`{"scene":"web_turbo_video_generator","config_key":"null","config":{"models":[null]}}`, false},
+	} {
+		var catalog Catalog
+		if err := json.Unmarshal([]byte(tc.data), &catalog); err != nil {
+			t.Fatal(err)
+		}
+		if err := validateCatalog(&catalog); (err == nil) != tc.valid {
+			t.Fatalf("validateCatalog = %v", err)
+		}
+	}
+}

package/internal/short_drama/submit_run.go

@@ -9,6 +9,7 @@ import (
 
 // SubmitRunOptions is the stable command-facing request shape for short drama run submission.
 type SubmitRunOptions struct {
+	Source   string   `json:"platform,omitempty"`
 	Message  string   `json:"message"`
 	ThreadID string   `json:"thread_id,omitempty"`
 	AssetIDs []string `json:"asset_ids,omitempty"`
@@ -36,6 +37,7 @@ func SubmitRun(ctx context.Context, opts *SubmitRunOptions, runner *common.Runne
 		body["asset_ids"] = opts.AssetIDs
 	}
 	body["agent_name"] = "pippit_nest_novel_agent"
+	body = common.WithSubmitRunSource(body, opts.Source)
 
 	var resp common.SubmitRunResponse
 	if err := runner.Client.SendRequest(ctx, common.SubmitRunPath(runner), body, &resp); err != nil {

package/internal/video_tool/video_tool.go

@@ -17,6 +17,7 @@ const (
 
 // SuperResolutionOptions is the command-facing request shape for video-super-resolution.
 type SuperResolutionOptions struct {
+	Source           string
 	VideoPath        string
 	ToolVersion      string
 	OutputResolution string
@@ -24,6 +25,7 @@ type SuperResolutionOptions struct {
 
 // EraseSubtitleOptions is the command-facing request shape for erase-video-subtitle.
 type EraseSubtitleOptions struct {
+	Source    string
 	VideoPath string
 }
 
@@ -43,7 +45,7 @@ func RunSuperResolution(ctx context.Context, opts *SuperResolutionOptions, runne
 	if err != nil {
 		return nil, err
 	}
-	return common.SubmitRun(ctx, "video-super-resolution", buildSuperResolutionSubmitRunBody(opts, assetID), runner)
+	return common.SubmitRun(ctx, "video-super-resolution", common.WithSubmitRunSource(buildSuperResolutionSubmitRunBody(opts, assetID), opts.Source), runner)
 }
 
 // RunEraseSubtitle uploads one video and submits a subtitle-erasing run.
@@ -59,7 +61,7 @@ func RunEraseSubtitle(ctx context.Context, opts *EraseSubtitleOptions, runner *c
 	if err != nil {
 		return nil, err
 	}
-	return common.SubmitRun(ctx, "erase-video-subtitle", buildEraseSubtitleSubmitRunBody(assetID), runner)
+	return common.SubmitRun(ctx, "erase-video-subtitle", common.WithSubmitRunSource(buildEraseSubtitleSubmitRunBody(assetID), opts.Source), runner)
 }
 
 // ValidateSuperResolutionOptions validates only command shape; semantic enums remain service-owned.

package/package.json

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

package/skills/short-drama/SKILL.md

@@ -21,6 +21,10 @@ metadata:
 
 短剧场景面向剧情、人物、分集与画面化叙事创作，用户的原始需求通过 `--message` 发送给后端 Agent。后端 Agent 负责理解任务、编排流程和生成内容；用户侧 Agent 负责提交任务、并行查询进展与产物、主动下载重要资产并展示结果。
 
+## 宿主来源统计
+
+调用 `short-drama +submit-run` 时，宿主 Agent 根据可信的实际运行环境静默附加可选 `--source`：豆包办公为 `doubao_office`，WorkBuddy 为 `workbuddy`，Codex 为 `codex`；其它已知宿主使用真实、稳定的产品标识。不附带版本、会话 ID、用户信息或 prompt，不从用户创作内容猜测来源，不向用户询问或增加确认。来源不明时省略；仅用于统计，不影响实际工具效果，不改写 `--message`。上传、查询和下载命令不附加此参数。旧版 CLI 以 `--help` 为准，不支持时省略，不因统计字段阻塞任务或重复提交。
+
 ## 功能
 
 1. **提交短剧 Run 任务** - 创建新会话或向已有会话发送短剧创作需求。