@pippit-dev/cli 1.0.41 → 1.0.43

package/cmd/root_update_check_test.go

@@ -0,0 +1,139 @@
+package cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/Pippit-dev/pippit-cli/internal/adapter"
+	"github.com/Pippit-dev/pippit-cli/internal/version"
+	"github.com/spf13/cobra"
+)
+
+type noSelfUpdateAdapter struct{ adapter.Default }
+
+func (noSelfUpdateAdapter) CLIOptions() adapter.CLIOptions {
+	options := adapter.Default{}.CLIOptions()
+	options.SelfUpdateEnabled = false
+	return options
+}
+
+func setupRootUpdateCache(t *testing.T) string {
+	t.Helper()
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+	for _, key := range []string{"CI", "PIPPIT_CLI_DISABLE_UPDATE_CHECK", "PIPPIT_CLI_UPDATE_CHECKED"} {
+		t.Setenv(key, "")
+	}
+	previous := version.Version
+	version.Version = "1.0.41"
+	t.Cleanup(func() { version.Version = previous })
+	cacheFile := filepath.Join(home, ".pippit_tool_cli", "version-check.json")
+	if err := os.MkdirAll(filepath.Dir(cacheFile), 0700); err != nil {
+		t.Fatal(err)
+	}
+	data := fmt.Sprintf(`{"latest":"1.0.42","checkedAt":%d}`, time.Now().UnixMilli())
+	if err := os.WriteFile(cacheFile, []byte(data), 0600); err != nil {
+		t.Fatal(err)
+	}
+	return cacheFile
+}
+
+func TestNativeBusinessInvocationReportsUpdateBeforeUnchangedJSON(t *testing.T) {
+	setupRootUpdateCache(t)
+	for _, commandName := range []string{"probe", "login"} {
+		for range 2 {
+			var stdout, stderr bytes.Buffer
+			root := NewRootCommand(&stdout, &stderr)
+			probe := &cobra.Command{Use: "probe"}
+			if commandName == "login" {
+				probe, _, _ = root.Find([]string{"login"})
+			} else {
+				root.AddCommand(probe)
+			}
+			probe.RunE = func(*cobra.Command, []string) error {
+				if !strings.Contains(stderr.String(), "1.0.41 -> 1.0.42") {
+					t.Fatal("business operation started before the synchronous notice")
+				}
+				_, err := fmt.Fprintln(&stdout, `{"ok":true}`)
+				return err
+			}
+			root.SetArgs([]string{commandName})
+			if err := root.Execute(); err != nil {
+				t.Fatal(err)
+			}
+			if !json.Valid(stdout.Bytes()) || stdout.String() != "{\"ok\":true}\n" ||
+				strings.Count(stderr.String(), "New version available") != 1 {
+				t.Fatalf("stdout/stderr contract changed: %q / %q", stdout.String(), stderr.String())
+			}
+			if (commandName == "login") != strings.Contains(stderr.String(), "authorization fails") {
+				t.Fatal("login-specific notice was omitted or leaked into another command")
+			}
+		}
+	}
+}
+
+func TestNativeUpdateCheckRespectsAdapterAndInvocationBoundaries(t *testing.T) {
+	setupRootUpdateCache(t)
+	for _, scenario := range []string{"help", "version", "empty", "invalid", "invalid flag", "update", "adapter", "dev", "CI", "PIPPIT_CLI_DISABLE_UPDATE_CHECK", "PIPPIT_CLI_UPDATE_CHECKED"} {
+		t.Run(scenario, func(t *testing.T) {
+			policy := adapter.Adapter(adapter.Default{})
+			args := []string{"probe"}
+			switch scenario {
+			case "help":
+				args = []string{"probe", "--help"}
+			case "version":
+				args = []string{"--version"}
+			case "empty":
+				args = []string{}
+			case "invalid":
+				args = []string{"unknown-command"}
+			case "invalid flag":
+				args = []string{"probe", "--unknown"}
+			case "update":
+				args = []string{"update"}
+			case "adapter":
+				policy = noSelfUpdateAdapter{}
+			case "dev":
+				previous := version.Version
+				version.Version = "dev"
+				t.Cleanup(func() { version.Version = previous })
+			default:
+				t.Setenv(scenario, "1")
+			}
+			var stdout, stderr bytes.Buffer
+			root := NewRootCommandWithAdapter(&stdout, &stderr, policy)
+			root.AddCommand(&cobra.Command{Use: "probe", Run: func(*cobra.Command, []string) {}})
+			if scenario == "update" {
+				update, _, _ := root.Find([]string{"update"})
+				update.RunE = func(*cobra.Command, []string) error { return nil }
+			}
+			root.SetArgs(args)
+			err := root.Execute()
+			if (scenario == "invalid" || scenario == "invalid flag") != (err != nil) {
+				t.Fatalf("unexpected command result: %v", err)
+			}
+			if strings.Contains(stderr.String(), "New version available") {
+				t.Fatalf("skipped invocation emitted an update notice: %s", stderr.String())
+			}
+		})
+	}
+}
+
+func TestConstructingRootHasNoVersionCheckSideEffects(t *testing.T) {
+	cacheFile := setupRootUpdateCache(t)
+	if err := os.Remove(cacheFile); err != nil {
+		t.Fatal(err)
+	}
+	var stdout, stderr bytes.Buffer
+	_ = NewRootCommand(&stdout, &stderr)
+	if _, err := os.Stat(cacheFile); !os.IsNotExist(err) || stdout.Len() != 0 || stderr.Len() != 0 {
+		t.Fatal("constructing the root queried versions, wrote cache or produced output")
+	}
+}

package/cmd/short_drama_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/Pippit-dev/pippit-cli/internal/auth"
 	"github.com/Pippit-dev/pippit-cli/internal/common"
 	"github.com/Pippit-dev/pippit-cli/internal/config"
+	"github.com/Pippit-dev/pippit-cli/internal/space"
 	"github.com/Pippit-dev/pippit-cli/internal/version"
 	"github.com/bytedance/sonic"
 	"github.com/spf13/cobra"
@@ -965,6 +966,7 @@ func newTestRootCommandWithAccessKey(t *testing.T, stdout, stderr io.Writer, bas
 	client := common.NewHTTPClient(cfg.BaseURL, cfg.HTTPTimeout, common.NewAccessKeyAuthorizer(cfg.AccessKey))
 	runner := common.NewRunner(cfg, client)
 	runner.Auth = auth.NewManager(cfg)
+	runner.SpaceStore = &space.Store{Dir: t.TempDir()}
 	return newRootCommand(stdout, stderr, runner)
 }
 

package/cmd/source_test.go

@@ -16,7 +16,7 @@ import (
 )
 
 func TestSkillSubmitSourcePreservesCreativeRequest(t *testing.T) {
-	for _, key := range []string{"PIPPIT_CLI_SOURCE", "CODEX_THREAD_ID", "CODEX_SESSION_ID", "CLAUDECODE", "CURSOR_AGENT", "GEMINI_CLI"} {
+	for _, key := range []string{"PIPPIT_CLI_SOURCE", "CODEX_THREAD_ID", "CODEX_SESSION_ID", "CLAUDECODE", "CURSOR_AGENT", "GEMINI_CLI", "OPENCODE", "QWEN_CODE", "CLINE_ACTIVE", "COPILOT_CLI", "COPILOT_AGENT_SESSION_ID"} {
 		t.Setenv(key, "")
 	}
 
@@ -130,6 +130,10 @@ func TestSkillSubmitSourcePreservesCreativeRequest(t *testing.T) {
 				if received["platform"] != "codex" {
 					t.Errorf("runtime host not detected: %#v", received["platform"])
 				}
+				execute("--source", "")
+				if received["platform"] != "codex" {
+					t.Error("explicit empty must allow runtime fallback")
+				}
 				t.Setenv("PIPPIT_CLI_SOURCE", " workbuddy ")
 				execute()
 				if received["platform"] != "workbuddy" {
@@ -139,11 +143,30 @@ func TestSkillSubmitSourcePreservesCreativeRequest(t *testing.T) {
 				if received["platform"] != "doubao_office" {
 					t.Error("explicit flag must win")
 				}
-				execute("--source", "")
-				if _, exists := received["platform"]; exists {
-					t.Error("explicit empty must suppress attribution")
+				for _, flags := range [][]string{{"--source", ""}, {"--source", " \t "}, {"--source="}, {"--source=codex", "--source="}} {
+					execute(flags...)
+					if received["platform"] != "workbuddy" {
+						t.Errorf("blank source must allow environment fallback: %v, got %#v", flags, received["platform"])
+					}
 				}
 			})
+			for _, host := range []struct{ key, want string }{
+				{"OPENCODE", "opencode"}, {"QWEN_CODE", "qwen_code"},
+				{"CLINE_ACTIVE", "cline"}, {"COPILOT_CLI", "github_copilot_cli"},
+				{"COPILOT_AGENT_SESSION_ID", "github_copilot_cli"},
+			} {
+				t.Run(host.key, func(t *testing.T) {
+					t.Setenv(host.key, "session-must-not-be-reported")
+					execute("--source", "")
+					if received["platform"] != host.want {
+						t.Errorf("platform = %#v, want %q", received["platform"], host.want)
+					}
+					delete(received, "platform")
+					if !reflect.DeepEqual(received, wantBody) || query != wantQuery {
+						t.Error("runtime source changed creative request or ROI query")
+					}
+				})
+			}
 			// A fresh invocation without source must not reuse previous attribution.
 			execute()
 			if _, exists := received["platform"]; exists {

package/cmd/space.go

@@ -0,0 +1,199 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"github.com/Pippit-dev/pippit-cli/internal/commandnames"
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+	"github.com/Pippit-dev/pippit-cli/internal/space"
+	"github.com/spf13/cobra"
+)
+
+func prepareCommandSpace(cmd *cobra.Command, runner *common.Runner, stderr io.Writer) error {
+	if runner == nil {
+		return nil
+	}
+	teamFlag := cmd.Flags().Lookup("team-id")
+	var explicit *string
+	if teamFlag != nil && teamFlag.Changed {
+		id, err := space.ParseTeamID(teamFlag.Value.String())
+		if err != nil {
+			return err
+		}
+		explicit = &id
+	}
+	top := cmd
+	for top.Parent() != nil && top.Parent().Parent() != nil {
+		top = top.Parent()
+	}
+	switch top.Name() {
+	case commandnames.Space, commandnames.Login, commandnames.Logout, commandnames.Status, commandnames.Update, commandnames.Completion, commandnames.Help, commandnames.DownloadResult:
+		return nil
+	}
+	raw, _ := cmd.Flags().GetString("space-context")
+	store, err := common.SpaceStoreForRunner(cmd.Context(), runner)
+	if err != nil {
+		if explicit == nil || raw != "" {
+			return err
+		}
+		if stderr != nil {
+			fmt.Fprintln(stderr, "本地空间记录不可用，将使用显式 --team-id；本次不保存空间记录。")
+		}
+	}
+	if store == nil && explicit == nil && raw == "" {
+		return nil
+	}
+	session := &space.Session{Store: store, Explicit: explicit, Stderr: stderr, Identity: func(ctx context.Context) (string, error) { return common.SpaceAccount(ctx, runner) }}
+	if raw != "" {
+		session.Expected, err = space.DecodeBinding(raw)
+		if err != nil {
+			return err
+		}
+	}
+	ctx := common.WithSpace(cmd.Context(), session)
+	cmd.SetContext(ctx)
+	// Business requests resolve their space from the final request body.
+	return nil
+}
+
+type listedSpace struct {
+	space.Selection
+	CurrentRole *int32 `json:"current_role,omitempty"`
+	Current     bool   `json:"current"`
+}
+
+func loadSpaces(ctx context.Context, runner *common.Runner, store *space.Store) ([]listedSpace, error) {
+	if store != nil {
+		ctx = common.WithSpace(ctx, &space.Session{Store: store, Identity: func(ctx context.Context) (string, error) { return common.SpaceAccount(ctx, runner) }})
+	}
+	result := []listedSpace{{Selection: space.Personal()}}
+	seenTeams := map[string]bool{"0": true}
+	seenCursors := map[string]bool{}
+	cursor := "0"
+	for {
+		if seenCursors[cursor] {
+			return nil, fmt.Errorf("团队列表分页游标重复，未保存空间选择")
+		}
+		seenCursors[cursor] = true
+		var response struct {
+			Ret    string `json:"ret"`
+			Errmsg string `json:"errmsg"`
+			LogID  string `json:"log_id"`
+			Data   *struct {
+				Teams []struct {
+					TeamID string `json:"team_id"`
+					Name   string `json:"team_name"`
+					Role   *int32 `json:"current_role"`
+				} `json:"team_info_list"`
+				NextCursor string `json:"next_cursor"`
+				HasMore    bool   `json:"has_more"`
+			} `json:"data"`
+		}
+		if err := runner.Client.SendRequest(ctx, config.GetLiteTeamListPath, map[string]any{"cursor": cursor, "count": 100}, &response); err != nil {
+			return nil, fmt.Errorf("获取团队列表失败，默认空间未改变: %w", err)
+		}
+		if response.Ret != "0" {
+			return nil, common.NewLogIDError("获取团队列表失败: "+response.Errmsg, response.LogID)
+		}
+		if response.Data == nil {
+			return nil, fmt.Errorf("团队列表响应缺少 data")
+		}
+		for _, team := range response.Data.Teams {
+			id, err := space.ParseTeamID(team.TeamID)
+			if err != nil || id == "0" {
+				return nil, fmt.Errorf("团队列表返回无效 team_id")
+			}
+			if !seenTeams[id] {
+				result = append(result, listedSpace{Selection: space.Selection{TeamID: id, Name: team.Name}, CurrentRole: team.Role})
+				seenTeams[id] = true
+			}
+		}
+		if !response.Data.HasMore {
+			return result, nil
+		}
+		if response.Data.NextCursor == "" {
+			return nil, fmt.Errorf("团队列表未返回下一页游标，未保存空间选择")
+		}
+		cursor = response.Data.NextCursor
+	}
+}
+
+func newSpaceCommand(stdout io.Writer, runner *common.Runner) *cobra.Command {
+	root := &cobra.Command{
+		Use:   commandnames.Space,
+		Short: "查看和切换个人或团队默认空间",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
+		},
+	}
+	list := &cobra.Command{Use: "list", Args: cobra.NoArgs, Short: "列出个人和团队空间，标记当前选择", RunE: func(cmd *cobra.Command, _ []string) error {
+		store, err := common.SpaceStoreForRunner(cmd.Context(), runner)
+		if err != nil {
+			return err
+		}
+		var selected *space.Selection
+		if store != nil {
+			current, err := store.Current()
+			if err != nil {
+				return err
+			}
+			selected = &current
+		}
+		spaces, err := loadSpaces(cmd.Context(), runner, store)
+		if err != nil {
+			return err
+		}
+		for i := range spaces {
+			spaces[i].Current = selected != nil && spaces[i].TeamID == selected.TeamID
+		}
+		return common.WriteJSON(stdout, map[string]any{"spaces": spaces, "current": selected})
+	}}
+	use := &cobra.Command{Use: "use <TEAM_ID>", Args: cobra.ExactArgs(1), Short: "保存默认空间；0 为个人，正整数为团队", RunE: func(cmd *cobra.Command, args []string) error {
+		id, err := space.ParseTeamID(args[0])
+		if err != nil {
+			return err
+		}
+		store, err := common.SpaceStoreForRunner(cmd.Context(), runner)
+		if err != nil {
+			return err
+		}
+		if store == nil {
+			return fmt.Errorf("无法识别当前账号，不能保存默认空间")
+		}
+		selected := space.Personal()
+		if id != "0" {
+			spaces, err := loadSpaces(cmd.Context(), runner, store)
+			if err != nil {
+				return err
+			}
+			found := false
+			for _, item := range spaces {
+				if item.TeamID == id {
+					selected = item.Selection
+					found = true
+					break
+				}
+			}
+			if !found {
+				return fmt.Errorf("当前账号的团队列表中没有 %s，默认空间未改变", id)
+			}
+		}
+		account, err := common.SpaceAccount(cmd.Context(), runner)
+		if err != nil {
+			return err
+		}
+		if account != store.Account {
+			return fmt.Errorf("账号已改变，默认空间未保存；请重新选择")
+		}
+		if err := store.SaveDefault(selected); err != nil {
+			return err
+		}
+		return common.WriteJSON(stdout, selected)
+	}}
+	root.AddCommand(list, use)
+	return root
+}