@pippit-dev/cli 1.0.42 → 1.0.43

package/internal/generate_image/generate_image.go

@@ -42,14 +42,7 @@ type generalAgentSettings struct {
 	GenerateImageCount *int   `json:"generate_image_count,omitempty"`
 }
 
-// Result is the JSON envelope printed by `pippit-tool-cli generate-image`.
-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) {
+func Run(ctx context.Context, opts *Options, runner *common.Runner) (*common.SubmitRunResult, error) {
 	if runner == nil || runner.Client == nil {
 		return nil, fmt.Errorf("generate-image 运行器客户端缺失")
 	}
@@ -89,7 +82,8 @@ func Run(ctx context.Context, opts *Options, runner *common.Runner) (*Result, er
 		return nil, fmt.Errorf("generate-image 响应缺少 data.run.run_id")
 	}
 
-	return &Result{
+	return &common.SubmitRunResult{
+		TeamID:        common.SpaceTeamID(ctx),
 		ThreadID:      resp.Data.Run.ThreadID,
 		RunID:         resp.Data.Run.RunID,
 		WebThreadLink: resp.Data.WebThreadLink,

package/internal/short_drama/submit_run.go

@@ -15,14 +15,7 @@ type SubmitRunOptions struct {
 	AssetIDs []string `json:"asset_ids,omitempty"`
 }
 
-// SubmitRunResult is the JSON envelope printed by `pippit-tool-cli short-drama +submit-run`.
-type SubmitRunResult struct {
-	ThreadID      string `json:"thread_id"`
-	RunID         string `json:"run_id"`
-	WebThreadLink string `json:"web_thread_link"`
-}
-
-func SubmitRun(ctx context.Context, opts *SubmitRunOptions, runner *common.Runner) (*SubmitRunResult, error) {
+func SubmitRun(ctx context.Context, opts *SubmitRunOptions, runner *common.Runner) (*common.SubmitRunResult, error) {
 	if runner == nil || runner.Client == nil {
 		return nil, fmt.Errorf("submit_run 运行器客户端缺失")
 	}
@@ -55,7 +48,8 @@ func SubmitRun(ctx context.Context, opts *SubmitRunOptions, runner *common.Runne
 	if resp.Data.Run.RunID == "" {
 		return nil, fmt.Errorf("short_drama 响应缺少 data.run.run_id")
 	}
-	return &SubmitRunResult{
+	return &common.SubmitRunResult{
+		TeamID:        common.SpaceTeamID(ctx),
 		ThreadID:      resp.Data.Run.ThreadID,
 		RunID:         resp.Data.Run.RunID,
 		WebThreadLink: resp.Data.WebThreadLink,

package/internal/space/session.go

@@ -0,0 +1,153 @@
+package space
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+)
+
+// 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.
+type Session struct {
+	Store    *Store
+	Explicit *string
+	Expected *Binding
+	Identity func(context.Context) (string, error)
+	Stderr   io.Writer
+	selected *Selection
+}
+
+func DecodeBinding(raw string) (*Binding, error) {
+	data, err := base64.RawURLEncoding.DecodeString(raw)
+	var binding Binding
+	if err != nil || json.Unmarshal(data, &binding) != nil {
+		return nil, fmt.Errorf("space-context 无效")
+	}
+	if _, err := ParseTeamID(binding.TeamID); err != nil {
+		return nil, err
+	}
+	return &binding, nil
+}
+
+func (s *Session) CheckIdentity(ctx context.Context) error {
+	if s.Store == nil || s.Identity == nil {
+		return nil
+	}
+	account, err := s.Identity(ctx)
+	if err != nil {
+		return err
+	}
+	if account != s.Store.Account {
+		return fmt.Errorf("当前账号已改变，已停止原空间的操作；请切回原账号后查询原任务")
+	}
+	return nil
+}
+
+// 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) {
+	explicit := s.Explicit
+	fixed := s.selected
+	if s.Expected != nil {
+		if s.Store == nil {
+			return Selection{}, fmt.Errorf("无法获取当前账号的空间记录，不能校验 --space-context")
+		}
+		if s.Expected.Account != s.Store.Account || s.Expected.Origin != s.Store.Origin {
+			return Selection{}, fmt.Errorf("账号或 API origin 与原任务不一致，已停止操作")
+		}
+		if explicit != nil && *explicit != s.Expected.TeamID {
+			return Selection{}, fmt.Errorf("--team-id 与固定任务空间冲突")
+		}
+		if fixed == nil {
+			fixed = &s.Expected.Selection
+		}
+	}
+	var records []record
+	var unreadable error
+	if s.Store != nil {
+		records, unreadable = s.Store.loadReferences(ref)
+	}
+	var task *Selection
+	for i := range records {
+		r := &records[i]
+		if r.Kind == "asset" {
+			continue
+		}
+		if task != nil && task.TeamID != r.TeamID {
+			return Selection{}, fmt.Errorf("thread/run 空间记录冲突；请先核实并修复本地记录")
+		}
+		task = &r.Selection
+	}
+	// Only explicit input permits recovery; a frozen choice does not.
+	if unreadable != nil && explicit == nil {
+		return Selection{}, fmt.Errorf("%w；核实原空间后用 --team-id <ID> 查询恢复，不要重新提交生成", unreadable)
+	}
+
+	// Keep selection priority in one place, whether or not a Store is available.
+	selected := Personal()
+	if fixed != nil {
+		selected = *fixed
+	} else if explicit != nil {
+		teamID, err := ParseTeamID(*explicit)
+		if err != nil {
+			return Selection{}, err
+		}
+		if teamID != "0" {
+			selected = Selection{TeamID: teamID, Name: "团队空间"}
+		}
+	} else if task != nil {
+		selected = *task
+	} else if s.Store != nil {
+		var err error
+		selected, err = s.Store.Current()
+		if err != nil {
+			return Selection{}, err
+		}
+	}
+	if task != nil && task.TeamID != selected.TeamID {
+		return Selection{}, fmt.Errorf("任务属于空间 %s，与本次空间 %s 冲突；请使用 --team-id %s 查询", task.TeamID, selected.TeamID, task.TeamID)
+	}
+	for _, r := range records {
+		if r.Kind == "asset" && r.TeamID != selected.TeamID {
+			return Selection{}, fmt.Errorf("素材属于空间 %s，与本次空间 %s 冲突；请使用相同空间的素材", r.TeamID, selected.TeamID)
+		}
+	}
+	if s.selected == nil {
+		s.selected = &selected
+		if s.Stderr != nil {
+			account := "个人"
+			if selected.TeamID != "0" {
+				account = "团队"
+			}
+			fmt.Fprintf(s.Stderr, "本次空间：%s（team_id=%s）；积分账户：%s\n", selected.Name, selected.TeamID, account)
+		}
+	}
+	return *s.selected, nil
+}
+
+func (s *Session) TeamID() string {
+	if s == nil || s.selected == nil {
+		return "0"
+	}
+	return s.selected.TeamID
+}
+
+func (s *Session) Token() string {
+	if s == nil || s.selected == nil || s.Store == nil {
+		return ""
+	}
+	data, _ := json.Marshal(Binding{Selection: Selection{TeamID: s.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 == "" {
+		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())
+	}
+}

package/internal/space/store.go

@@ -0,0 +1,211 @@
+package space
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+const Version = 1
+
+type Selection struct {
+	TeamID string `json:"team_id"`
+	Name   string `json:"name"`
+}
+
+type Binding struct {
+	Selection
+	Account string `json:"account_scope"`
+	Origin  string `json:"api_origin"`
+}
+
+type References struct {
+	ThreadID string   `json:"thread_id"`
+	RunID    string   `json:"run_id"`
+	AssetIDs []string `json:"asset_ids"`
+}
+
+type record struct {
+	Version int `json:"version"`
+	Binding
+	Kind     string `json:"kind"`
+	ID       string `json:"id"`
+	ThreadID string `json:"thread_id,omitempty"`
+}
+
+type Store struct {
+	Dir     string
+	Account string
+	Origin  string
+}
+
+func Digest(value string) string {
+	sum := sha256.Sum256([]byte(value))
+	return hex.EncodeToString(sum[:])
+}
+
+func ParseTeamID(raw string) (string, error) {
+	if raw == "" || strings.IndexFunc(raw, func(r rune) bool { return r < '0' || r > '9' }) >= 0 {
+		return "", fmt.Errorf("team-id 必须为 0 或正整数团队 ID")
+	}
+	n, err := strconv.ParseInt(raw, 10, 64)
+	if err != nil {
+		return "", fmt.Errorf("team-id 超出 int64 范围")
+	}
+	return strconv.FormatInt(n, 10), nil
+}
+
+func NormalizeOrigin(raw string) (string, error) {
+	u, err := url.Parse(raw)
+	if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") || u.User != nil {
+		return "", fmt.Errorf("API origin 无效")
+	}
+	u.Scheme, u.Host = strings.ToLower(u.Scheme), strings.ToLower(u.Host)
+	if (u.Scheme == "https" && u.Port() == "443") || (u.Scheme == "http" && u.Port() == "80") {
+		u.Host = u.Hostname()
+		if strings.Contains(u.Host, ":") {
+			u.Host = "[" + u.Host + "]"
+		}
+	}
+	return u.Scheme + "://" + u.Host, nil
+}
+
+func NewStore(baseURL, account string) (*Store, error) {
+	origin, err := NormalizeOrigin(baseURL)
+	if err != nil {
+		return nil, err
+	}
+	dir, err := os.UserConfigDir()
+	if err != nil {
+		return nil, err
+	}
+	return &Store{Dir: filepath.Join(dir, "pippit-cli", "spaces", Digest(origin+"\n"+account)), Account: account, Origin: origin}, nil
+}
+
+func Personal() Selection { return Selection{TeamID: "0", Name: "个人空间"} }
+
+func (s *Store) file(kind, id string) string {
+	return filepath.Join(s.Dir, kind+"-"+Digest(id)+".json")
+}
+
+func (s *Store) load(kind, id, thread string) (*record, error) {
+	data, err := os.ReadFile(s.file(kind, id))
+	if os.IsNotExist(err) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("无法读取%s空间记录: %w", kind, err)
+	}
+	var r record
+	if json.Unmarshal(data, &r) != nil || r.Version != Version || r.Account != s.Account || r.Origin != s.Origin || r.Kind != kind || r.ID != id || r.ThreadID != thread {
+		return nil, fmt.Errorf("%s空间记录损坏、身份不符或版本不支持", kind)
+	}
+	teamID, err := ParseTeamID(r.TeamID)
+	if err != nil || teamID != r.TeamID {
+		return nil, fmt.Errorf("%s空间记录的 team_id 无效", kind)
+	}
+	return &r, nil
+}
+
+func (s *Store) Current() (Selection, error) {
+	r, err := s.load("default", "", "")
+	if err != nil {
+		return Selection{}, fmt.Errorf("%w；可用 --team-id 指定本次空间", err)
+	}
+	if r == nil {
+		return Personal(), nil
+	}
+	return r.Selection, nil
+}
+
+func (s *Store) SaveDefault(selection Selection) error {
+	if s.Account == "" {
+		return fmt.Errorf("请先登录，再保存默认空间")
+	}
+	return s.save("default", "", "", selection)
+}
+
+func (s *Store) save(kind, id, thread string, selection Selection) error {
+	teamID, err := ParseTeamID(selection.TeamID)
+	if err != nil {
+		return err
+	}
+	selection.TeamID = teamID
+	data, err := json.Marshal(record{Version: Version, Binding: Binding{Selection: selection, Account: s.Account, Origin: s.Origin}, Kind: kind, ID: id, ThreadID: thread})
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(s.Dir, 0700); err != nil {
+		return err
+	}
+	f, err := os.CreateTemp(s.Dir, ".space-*.tmp")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(f.Name())
+	if _, err = f.Write(data); err != nil {
+		f.Close()
+		return err
+	}
+	if err = f.Sync(); err != nil {
+		f.Close()
+		return err
+	}
+	if err = f.Close(); err != nil {
+		return err
+	}
+	return os.Rename(f.Name(), s.file(kind, id))
+}
+
+// loadReferences returns readable records together with any read error, so a
+// caller recovering an unreadable record can still check the remaining records.
+func (s *Store) loadReferences(ref References) ([]record, error) {
+	var records []record
+	var unreadable error
+	for _, key := range referenceKeys(ref) {
+		r, err := s.load(key.kind, key.id, key.thread)
+		if err != nil {
+			unreadable = err
+		} else if r != nil {
+			records = append(records, *r)
+		}
+	}
+	return records, unreadable
+}
+
+type referenceKey struct{ kind, id, thread string }
+
+func referenceKeys(ref References) []referenceKey {
+	var keys []referenceKey
+	if ref.ThreadID != "" {
+		keys = append(keys, referenceKey{"thread", ref.ThreadID, ""})
+	}
+	if ref.RunID != "" {
+		keys = append(keys, referenceKey{"run", ref.RunID, ref.ThreadID})
+	}
+	for _, id := range ref.AssetIDs {
+		if id != "" {
+			keys = append(keys, referenceKey{"asset", id, ""})
+		}
+	}
+	return keys
+}
+
+func (s *Store) Remember(ref References, selected Selection) error {
+	for _, key := range referenceKeys(ref) {
+		old, err := s.load(key.kind, key.id, key.thread)
+		if err == nil && old != nil && old.TeamID != selected.TeamID {
+			return fmt.Errorf("拒绝覆盖归属不同的%s记录", key.kind)
+		}
+		if err := s.save(key.kind, key.id, key.thread, selected); err != nil {
+			return err
+		}
+	}
+	return nil
+}

package/internal/space/store_test.go

@@ -0,0 +1,246 @@
+package space
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func testStore(t *testing.T) *Store {
+	t.Helper()
+	return &Store{Dir: t.TempDir(), Account: "account-a", Origin: "https://example.test"}
+}
+
+func TestTaskScopeSurvivesDefaultSwitchAndRejectsConflicts(t *testing.T) {
+	s := testStore(t)
+	a := Selection{TeamID: "12", Name: "A"}
+	b := Selection{TeamID: "34", Name: "B"}
+	ref := References{ThreadID: "thread", RunID: "run", AssetIDs: []string{"asset"}}
+	if err := s.Remember(ref, a); err != nil {
+		t.Fatal(err)
+	}
+	if err := s.SaveDefault(b); err != nil {
+		t.Fatal(err)
+	}
+	got, err := (&Session{Store: s}).Resolve(ref)
+	if err != nil || got.TeamID != "12" {
+		t.Fatalf("old task = %+v, %v", got, err)
+	}
+	got, err = (&Session{Store: s}).Resolve(References{})
+	if err != nil || got.TeamID != "34" {
+		t.Fatalf("new task = %+v, %v", got, err)
+	}
+	if _, err := (&Session{Store: s, Explicit: &b.TeamID}).Resolve(ref); err == nil {
+		t.Fatal("explicit conflicting team accepted")
+	}
+	if _, err := (&Session{Store: s}).Resolve(References{AssetIDs: []string{"asset"}}); err == nil {
+		t.Fatal("cross-team asset accepted")
+	}
+	zero := "0"
+	got, err = (&Session{Store: s, Explicit: &zero}).Resolve(References{})
+	if err != nil || got.TeamID != "0" {
+		t.Fatalf("personal override = %+v, %v", got, err)
+	}
+	current, _ := s.Current()
+	if current.TeamID != "34" {
+		t.Fatal("one-shot override changed saved default")
+	}
+	if err := os.Remove(s.file("thread", "thread")); err != nil {
+		t.Fatal(err)
+	}
+	got, err = (&Session{Store: s}).Resolve(ref)
+	if err != nil || got.TeamID != "12" {
+		t.Fatalf("partial task record = %+v, %v", got, err)
+	}
+}
+
+func TestCorruptRecordRequiresExplicitRecovery(t *testing.T) {
+	s := testStore(t)
+	ref := References{ThreadID: "thread", RunID: "run"}
+	a := Selection{TeamID: "12", Name: "A"}
+	if err := s.Remember(ref, a); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(s.file("run", "run"), []byte("broken"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := (&Session{Store: s}).Resolve(ref); err == nil {
+		t.Fatal("corrupt record treated as missing")
+	}
+	other := "34"
+	if _, err := (&Session{Store: s, Explicit: &other}).Resolve(ref); err == nil {
+		t.Fatal("corrupt run overrode valid thread")
+	}
+	if _, err := (&Session{Store: s, Explicit: &a.TeamID}).Resolve(ref); err != nil {
+		t.Fatal(err)
+	}
+	if err := s.Remember(ref, a); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := (&Session{Store: s}).Resolve(ref); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(s.file("default", ""), []byte("broken"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := (&Session{Store: s}).Resolve(References{}); err == nil {
+		t.Fatal("corrupt default fell back to personal")
+	}
+	zero := "0"
+	if _, err := (&Session{Store: s, Explicit: &zero}).Resolve(References{}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestSpaceIdentityAndInt64Boundary(t *testing.T) {
+	for _, raw := range []string{"", "-1", "1.5", " 12", "+12", "9223372036854775808"} {
+		if _, err := ParseTeamID(raw); err == nil {
+			t.Errorf("accepted %q", raw)
+		}
+	}
+	s := testStore(t)
+	for raw, want := range map[string]string{"0": "0", "000": "0", "00012": "12", "9223372036854775807": "9223372036854775807"} {
+		if got, err := ParseTeamID(raw); err != nil || got != want {
+			t.Errorf("%q = %q, %v", raw, got, err)
+		}
+		if err := s.SaveDefault(Selection{TeamID: raw}); err != nil {
+			t.Fatalf("save %q: %v", raw, err)
+		}
+		if got, err := s.Current(); err != nil || got.TeamID != want {
+			t.Errorf("read saved %q = %+v, %v; want team_id %q", raw, got, err, want)
+		}
+	}
+	a, err := NewStore("https://EXAMPLE.test:443/path", "account-a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, _ := NewStore("https://example.test", "account-a")
+	c, _ := NewStore("https://example.test", "account-b")
+	d, _ := NewStore("https://other.test", "account-a")
+	if a.Dir != b.Dir || a.Dir == c.Dir || a.Dir == d.Dir {
+		t.Fatal("account/origin isolation failed")
+	}
+}
+
+func TestFixedSessionRequiresExplicitRecordRecovery(t *testing.T) {
+	for _, teamID := range []string{"0", "12"} {
+		for _, bindingOnly := range []bool{false, true} {
+			s := testStore(t)
+			selected := Selection{TeamID: teamID}
+			if err := s.SaveDefault(selected); err != nil {
+				t.Fatal(err)
+			}
+			session := &Session{Store: s}
+			if _, err := session.Resolve(References{}); err != nil {
+				t.Fatal(err)
+			}
+			if bindingOnly {
+				binding, err := DecodeBinding(session.Token())
+				if err != nil {
+					t.Fatal(err)
+				}
+				session = &Session{Store: s, Expected: binding}
+			}
+			if err := s.SaveDefault(Selection{TeamID: "34"}); err != nil {
+				t.Fatal(err)
+			}
+			ref := References{ThreadID: "thread", RunID: "run"}
+			if err := s.Remember(ref, selected); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(s.file("run", "run"), []byte("broken"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := session.Resolve(ref); err == nil {
+				t.Fatalf("team %s, binding=%v: fixed space bypassed corrupt record", teamID, bindingOnly)
+			}
+			session.Explicit = &teamID
+			got, err := session.Resolve(ref)
+			if err != nil || got.TeamID != teamID {
+				t.Fatalf("explicit recovery = %+v, %v", got, err)
+			}
+			if err := s.Remember(References{ThreadID: "other"}, Selection{TeamID: "34"}); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := session.Resolve(References{ThreadID: "other"}); err == nil {
+				t.Fatal("fixed space accepted a conflicting task")
+			}
+		}
+	}
+}
+
+func TestSessionWithoutStoreKeepsExplicitSpace(t *testing.T) {
+	for _, teamID := range []string{"0", "12", "34"} {
+		explicit := teamID
+		session := &Session{Explicit: &explicit}
+		selected, err := session.Resolve(References{})
+		if err != nil || selected.TeamID != teamID {
+			t.Fatalf("space = %+v, %v", selected, err)
+		}
+		explicit = "56"
+		selected, err = session.Resolve(References{ThreadID: "thread", RunID: "run"})
+		if err != nil || selected.TeamID != teamID {
+			t.Fatalf("command changed its frozen space: %+v, %v", selected, err)
+		}
+		session.Remember(References{ThreadID: "thread", RunID: "run"})
+		if session.Token() != "" {
+			t.Fatal("unknown account must not produce an identity binding")
+		}
+	}
+	session := &Session{Expected: &Binding{Selection: Personal(), Account: "account", Origin: "https://example.test"}}
+	if _, err := session.Resolve(References{}); err == nil {
+		t.Fatal("identity binding accepted without an identifiable account")
+	}
+}
+
+func TestCommandSessionFreezesScopeAndChecksIdentity(t *testing.T) {
+	s := testStore(t)
+	if err := s.SaveDefault(Selection{TeamID: "12", Name: "A"}); err != nil {
+		t.Fatal(err)
+	}
+	account := s.Account
+	var warning bytes.Buffer
+	session := &Session{Store: s, Stderr: &warning, Identity: func(context.Context) (string, error) { return account, nil }}
+	ctx := context.Background()
+	if _, err := session.Resolve(References{}); err != nil {
+		t.Fatal(err)
+	}
+	token := session.Token()
+	if err := s.SaveDefault(Selection{TeamID: "34", Name: "B"}); err != nil {
+		t.Fatal(err)
+	}
+	got, err := session.Resolve(References{})
+	if err != nil || got.TeamID != "12" {
+		t.Fatalf("session changed = %+v, %v", got, err)
+	}
+	binding, err := DecodeBinding(token)
+	if err != nil {
+		t.Fatal(err)
+	}
+	next := &Session{Store: s, Expected: binding}
+	got, err = next.Resolve(References{})
+	if err != nil || got.TeamID != "12" || next.Token() != token {
+		t.Fatalf("cross-process binding = %+v, %v", got, err)
+	}
+	account = "account-b"
+	if err := session.CheckIdentity(ctx); err == nil {
+		t.Fatal("account switch accepted")
+	}
+	next.Store = &Store{Dir: s.Dir, Account: account, Origin: s.Origin}
+	if _, err := next.Resolve(References{}); err == nil {
+		t.Fatal("binding allowed different account")
+	}
+	// A successful request stays successful even if the record directory fails.
+	blocked := filepath.Join(t.TempDir(), "file")
+	if err := os.WriteFile(blocked, []byte("file"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	s.Dir = blocked
+	session.Remember(References{ThreadID: "created-thread", RunID: "created-run"})
+	if !strings.Contains(warning.String(), "created-run") || !strings.Contains(warning.String(), "不要重复提交") {
+		t.Fatal(warning.String())
+	}
+}

package/package.json

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