@pippit-dev/cli 1.0.18 → 1.0.20

package/internal/canvas/apply.go

@@ -13,8 +13,9 @@ import (
 var decimalIDPattern = regexp.MustCompile(`^[1-9][0-9]*$`)
 
 type ApplyOptions struct {
-	ProjectID string
-	Request   ApplyRequest
+	ProjectID                   string
+	Request                     ApplyRequest
+	AllowNonAcknowledgedResults bool
 }
 
 type ApplyRequest struct {
@@ -47,6 +48,8 @@ type ApplyResult struct {
 	BatchID string                   `json:"batch_id"`
 	Results []PatchTransactionResult `json:"results"`
 	LogID   string                   `json:"log_id,omitempty"`
+
+	rawResults []json.RawMessage
 }
 
 type PatchTransactionResult struct {
@@ -58,7 +61,29 @@ type PatchTransactionResult struct {
 }
 
 type applyData struct {
-	Results []PatchTransactionResult `json:"results"`
+	Results []json.RawMessage `json:"results"`
+}
+
+type decodedPatchTransactionResult struct {
+	result PatchTransactionResult
+	raw    json.RawMessage
+}
+
+func (result ApplyResult) MarshalJSON() ([]byte, error) {
+	type applyResultJSON struct {
+		BatchID string `json:"batch_id"`
+		Results any    `json:"results"`
+		LogID   string `json:"log_id,omitempty"`
+	}
+	results := any(result.Results)
+	if len(result.rawResults) > 0 {
+		results = result.rawResults
+	}
+	return json.Marshal(applyResultJSON{
+		BatchID: result.BatchID,
+		Results: results,
+		LogID:   result.LogID,
+	})
 }
 
 func Apply(ctx context.Context, opts ApplyOptions, runner *common.Runner) (*ApplyResult, error) {
@@ -90,18 +115,33 @@ func Apply(ctx context.Context, opts ApplyOptions, runner *common.Runner) (*Appl
 			envelope.LogID,
 		)
 	}
-	ordered, err := validateApplyResults(request.Transactions, data.Results)
+	decodedResults, err := decodeApplyResults(data.Results)
+	if err != nil {
+		return nil, common.NewLogIDError(
+			fmt.Sprintf("canvas apply returned invalid data: %v; query affected assets before retrying because outcome cannot be confirmed", err),
+			envelope.LogID,
+		)
+	}
+	ordered, rawResults, _, err := validateApplyResults(
+		request.Transactions,
+		decodedResults,
+		opts.AllowNonAcknowledgedResults,
+	)
 	if err != nil {
 		return nil, common.NewLogIDError(
 			fmt.Sprintf("%s; query affected assets before retrying because outcome cannot be confirmed", err),
 			envelope.LogID,
 		)
 	}
-	return &ApplyResult{
+	result := &ApplyResult{
 		BatchID: request.BatchID,
 		Results: ordered,
 		LogID:   strings.TrimSpace(envelope.LogID),
-	}, nil
+	}
+	if opts.AllowNonAcknowledgedResults {
+		result.rawResults = rawResults
+	}
+	return result, nil
 }
 
 func validateApplyRequest(request *ApplyRequest) error {
@@ -161,43 +201,79 @@ func validateApplyRequest(request *ApplyRequest) error {
 	return nil
 }
 
-func validateApplyResults(expected []PatchTransaction, actual []PatchTransactionResult) ([]PatchTransactionResult, error) {
-	byID := make(map[string]PatchTransactionResult, len(actual))
-	for _, result := range actual {
+func decodeApplyResults(rawResults []json.RawMessage) ([]decodedPatchTransactionResult, error) {
+	results := make([]decodedPatchTransactionResult, 0, len(rawResults))
+	for index, rawResult := range rawResults {
+		var result PatchTransactionResult
+		if err := json.Unmarshal(rawResult, &result); err != nil {
+			return nil, fmt.Errorf("decode transaction result[%d]: %w", index, err)
+		}
+		results = append(results, decodedPatchTransactionResult{result: result, raw: rawResult})
+	}
+	return results, nil
+}
+
+func validateApplyResults(
+	expected []PatchTransaction,
+	actual []decodedPatchTransactionResult,
+	allowNonAcknowledgedResults bool,
+) ([]PatchTransactionResult, []json.RawMessage, bool, error) {
+	byID := make(map[string]decodedPatchTransactionResult, len(actual))
+	for _, decoded := range actual {
+		result := decoded.result
 		result.TransactionID = strings.TrimSpace(result.TransactionID)
 		if result.TransactionID == "" {
-			return nil, fmt.Errorf("canvas apply returned a result without transaction_id")
+			return nil, nil, false, fmt.Errorf("canvas apply returned a result without transaction_id")
 		}
 		if _, duplicate := byID[result.TransactionID]; duplicate {
-			return nil, fmt.Errorf("canvas apply returned duplicate result for transaction %q", result.TransactionID)
+			return nil, nil, false, fmt.Errorf("canvas apply returned duplicate result for transaction %q", result.TransactionID)
 		}
-		byID[result.TransactionID] = result
+		decoded.result = result
+		byID[result.TransactionID] = decoded
 	}
 	if len(byID) != len(expected) {
-		return nil, fmt.Errorf("canvas apply returned %d transaction results, want %d", len(byID), len(expected))
+		return nil, nil, false, fmt.Errorf("canvas apply returned %d transaction results, want %d", len(byID), len(expected))
 	}
 	ordered := make([]PatchTransactionResult, 0, len(expected))
+	orderedRaw := make([]json.RawMessage, 0, len(expected))
+	hasNonAcknowledgedResult := false
 	for _, transaction := range expected {
-		result, ok := byID[transaction.TransactionID]
+		decoded, ok := byID[transaction.TransactionID]
 		if !ok {
-			return nil, fmt.Errorf("canvas apply omitted transaction result %q", transaction.TransactionID)
-		}
-		if strings.ToLower(strings.TrimSpace(result.Status)) != "ack" {
-			return nil, fmt.Errorf(
-				"canvas apply transaction %q was not acknowledged: status=%q blocked_by=%q error=%q",
-				transaction.TransactionID, result.Status, result.BlockedByTransaction, result.Error,
-			)
+			return nil, nil, false, fmt.Errorf("canvas apply omitted transaction result %q", transaction.TransactionID)
 		}
-		for _, patch := range transaction.Patches {
-			version, ok := result.AssetVersions[patch.AssetID]
-			if !ok {
-				return nil, fmt.Errorf("canvas apply transaction %q omitted version for asset %q", transaction.TransactionID, patch.AssetID)
+		result := decoded.result
+		status := strings.ToLower(strings.TrimSpace(result.Status))
+		switch status {
+		case "ack":
+			for _, patch := range transaction.Patches {
+				version, ok := result.AssetVersions[patch.AssetID]
+				if !ok {
+					if allowNonAcknowledgedResults && patch.Op == "add" && patch.Path == "" {
+						continue
+					}
+					return nil, nil, false, fmt.Errorf("canvas apply transaction %q omitted version for asset %q", transaction.TransactionID, patch.AssetID)
+				}
+				if version < 0 {
+					return nil, nil, false, fmt.Errorf("canvas apply transaction %q returned negative version for asset %q", transaction.TransactionID, patch.AssetID)
+				}
 			}
-			if version < 0 {
-				return nil, fmt.Errorf("canvas apply transaction %q returned negative version for asset %q", transaction.TransactionID, patch.AssetID)
+		case "reject", "blocked", "skipped":
+			if !allowNonAcknowledgedResults {
+				return nil, nil, false, fmt.Errorf(
+					"canvas apply transaction %q was not acknowledged: status=%q blocked_by=%q error=%q",
+					transaction.TransactionID, result.Status, result.BlockedByTransaction, result.Error,
+				)
 			}
+			hasNonAcknowledgedResult = true
+		default:
+			return nil, nil, false, fmt.Errorf(
+				"canvas apply transaction %q returned invalid status %q",
+				transaction.TransactionID, result.Status,
+			)
 		}
 		ordered = append(ordered, result)
+		orderedRaw = append(orderedRaw, decoded.raw)
 	}
-	return ordered, nil
+	return ordered, orderedRaw, hasNonAcknowledgedResult, nil
 }

package/internal/canvas/canvas_test.go

@@ -336,6 +336,119 @@ func TestApplyRequiresAcknowledgementAndEveryAssetVersion(t *testing.T) {
 	}
 }
 
+func TestApplyAllowsExplicitTransportOutcomesWithoutHidingServerResultFields(t *testing.T) {
+	request := ApplyRequest{
+		BatchID: "batch-1", ClientID: "client-1",
+		Transactions: []PatchTransaction{{TransactionID: "tx-1", Patches: []PatchEntry{{
+			AssetID: "asset-1", Op: "replace", Path: "", Value: json.RawMessage(`{}`),
+		}}}},
+	}
+	for _, status := range []string{"reject", "blocked", "skipped"} {
+		t.Run(status, func(t *testing.T) {
+			client := &fakeClient{send: func(_ context.Context, _ string, _ any, out any) error {
+				response := fmt.Sprintf(
+					`{"ret":"0","log_id":"transport-log","data":{"results":[{"transaction_id":"tx-1","status":%q,"blocked_by":"tx-0","message":"server detail","current_asset_versions":{"asset-1":7},"server_detail":{"reason":"conflict"}}]}}`,
+					status,
+				)
+				return decodeInto(out, response)
+			}}
+			result, err := Apply(context.Background(), ApplyOptions{
+				Request:                     request,
+				AllowNonAcknowledgedResults: true,
+			}, runnerWithClient(client))
+			if err != nil || result.Results[0].Status != status {
+				t.Fatalf("Apply() = (%#v, %v), want structured %s result", result, err, status)
+			}
+			payload, err := json.Marshal(result)
+			if err != nil {
+				t.Fatalf("Marshal() error = %v", err)
+			}
+			var output map[string]any
+			if err := json.Unmarshal(payload, &output); err != nil {
+				t.Fatalf("Unmarshal() error = %v", err)
+			}
+			entry := output["results"].([]any)[0].(map[string]any)
+			if entry["message"] != "server detail" || entry["server_detail"] == nil || entry["current_asset_versions"] == nil {
+				t.Fatalf("result = %#v, want complete server transaction result", entry)
+			}
+		})
+	}
+}
+
+func TestApplyTransportResultAllowsRootAssetCreateAckWithoutVersion(t *testing.T) {
+	request := ApplyRequest{
+		BatchID: "batch-1", ClientID: "client-1",
+		Transactions: []PatchTransaction{{TransactionID: "tx-1", Patches: []PatchEntry{{
+			AssetID: "asset-new", Op: "add", Path: "", Value: json.RawMessage(`{"nodes":[]}`),
+		}}}},
+	}
+	client := &fakeClient{send: func(_ context.Context, _ string, _ any, out any) error {
+		return decodeInto(out, `{"ret":"0","data":{"results":[{"transaction_id":"tx-1","status":"ack","server_detail":{"created":true}}]}}`)
+	}}
+	result, err := Apply(context.Background(), ApplyOptions{
+		Request:                     request,
+		AllowNonAcknowledgedResults: true,
+	}, runnerWithClient(client))
+	if err != nil || result.Results[0].Status != "ack" {
+		t.Fatalf("Apply() = (%#v, %v), want transport ACK", result, err)
+	}
+	payload, err := json.Marshal(result)
+	if err != nil {
+		t.Fatalf("Marshal() error = %v", err)
+	}
+	var output map[string]any
+	if err := json.Unmarshal(payload, &output); err != nil {
+		t.Fatalf("Unmarshal() error = %v", err)
+	}
+	entry := output["results"].([]any)[0].(map[string]any)
+	if entry["asset_versions"] != nil || entry["server_detail"] == nil {
+		t.Fatalf("result = %#v, want unchanged ACK for SDK decoder", entry)
+	}
+}
+
+func TestApplyTransportResultStillRequiresVersionsForNonCreatePatches(t *testing.T) {
+	for _, patch := range []PatchEntry{
+		{AssetID: "asset-1", Op: "replace", Path: "", Value: json.RawMessage(`{}`)},
+		{AssetID: "asset-1", Op: "add", Path: "/nodes/0", Value: json.RawMessage(`{}`)},
+	} {
+		t.Run(patch.Op+patch.Path, func(t *testing.T) {
+			request := ApplyRequest{
+				BatchID: "batch-1", ClientID: "client-1",
+				Transactions: []PatchTransaction{{TransactionID: "tx-1", Patches: []PatchEntry{patch}}},
+			}
+			client := &fakeClient{send: func(_ context.Context, _ string, _ any, out any) error {
+				return decodeInto(out, `{"ret":"0","data":{"results":[{"transaction_id":"tx-1","status":"ack"}]}}`)
+			}}
+			_, err := Apply(context.Background(), ApplyOptions{
+				Request:                     request,
+				AllowNonAcknowledgedResults: true,
+			}, runnerWithClient(client))
+			if err == nil || !strings.Contains(err.Error(), "omitted version") {
+				t.Fatalf("Apply() error = %v, want missing version rejection", err)
+			}
+		})
+	}
+}
+
+func TestApplyTransportResultModeStillRejectsInvalidStatus(t *testing.T) {
+	request := ApplyRequest{
+		BatchID: "batch-1", ClientID: "client-1",
+		Transactions: []PatchTransaction{{TransactionID: "tx-1", Patches: []PatchEntry{{
+			AssetID: "asset-1", Op: "replace", Path: "", Value: json.RawMessage(`{}`),
+		}}}},
+	}
+	client := &fakeClient{send: func(_ context.Context, _ string, _ any, out any) error {
+		return decodeInto(out, `{"ret":"0","data":{"results":[{"transaction_id":"tx-1","status":"pending"}]}}`)
+	}}
+	_, err := Apply(context.Background(), ApplyOptions{
+		Request:                     request,
+		AllowNonAcknowledgedResults: true,
+	}, runnerWithClient(client))
+	if err == nil || !strings.Contains(err.Error(), "invalid status") {
+		t.Fatalf("Apply() error = %v, want invalid response rejection", err)
+	}
+}
+
 func TestApplyBetaRejectsMultipleTransactionsBeforeRequest(t *testing.T) {
 	requestCalls := 0
 	client := &fakeClient{send: func(context.Context, string, any, any) error {

package/internal/common/get_credit_balance.go

@@ -0,0 +1,61 @@
+package common
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+// GetCreditBalanceResult is the JSON output printed by `pippit-tool-cli get-credit-balance`.
+type GetCreditBalanceResult struct {
+	TotalRemainAmount int64  `json:"total_remain_amount,string"`
+	LogID             string `json:"-"`
+}
+
+type getCreditBalanceResponse struct {
+	Ret    string                        `json:"ret"`
+	Errmsg string                        `json:"errmsg"`
+	LogID  string                        `json:"log_id"`
+	Data   *getCreditBalanceResponseData `json:"data"`
+}
+
+type getCreditBalanceResponseData struct {
+	TotalRemainAmount *int64 `json:"total_remain_amount,string"`
+}
+
+// GetCreditBalance queries the effective credit balance of the access-key owner.
+func GetCreditBalance(ctx context.Context, runner *Runner) (*GetCreditBalanceResult, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("get_credit_balance 运行器客户端缺失")
+	}
+
+	var resp getCreditBalanceResponse
+	if err := runner.Client.SendRequest(ctx, getCreditBalancePath(runner), struct{}{}, &resp); err != nil {
+		return nil, fmt.Errorf("获取积分余额请求失败: %w", err)
+	}
+	if resp.Ret != "0" {
+		if resp.Errmsg == "" {
+			resp.Errmsg = "未知错误"
+		}
+		return nil, NewLogIDError(fmt.Sprintf("获取积分余额请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
+	}
+	if resp.Data == nil {
+		return nil, NewLogIDError("get_credit_balance 响应缺少 data", resp.LogID)
+	}
+	if resp.Data.TotalRemainAmount == nil {
+		return nil, NewLogIDError("get_credit_balance 响应缺少 data.total_remain_amount", resp.LogID)
+	}
+
+	return &GetCreditBalanceResult{
+		TotalRemainAmount: *resp.Data.TotalRemainAmount,
+		LogID:             resp.LogID,
+	}, nil
+}
+
+func getCreditBalancePath(runner *Runner) string {
+	if runner != nil && runner.Config != nil && runner.Config.Paths != nil && runner.Config.Paths.GetCreditBalance != "" {
+		return runner.Config.Paths.GetCreditBalance
+	}
+	return config.GetCreditBalancePath
+}

package/internal/common/get_credit_balance_test.go

@@ -0,0 +1,75 @@
+package common
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/bytedance/sonic"
+)
+
+type creditBalanceFakeClient struct {
+	response string
+	path     string
+	body     any
+}
+
+func (c *creditBalanceFakeClient) SendRequest(_ context.Context, path string, body any, out any) error {
+	c.path = path
+	c.body = body
+	return sonic.Unmarshal([]byte(c.response), out)
+}
+
+func (c *creditBalanceFakeClient) SendRequestWithHeaders(ctx context.Context, path string, body any, _ map[string]string, out any) error {
+	return c.SendRequest(ctx, path, body, out)
+}
+
+func (c *creditBalanceFakeClient) SendMultipartRequest(context.Context, string, map[string]string, MultipartFile, any) error {
+	return fmt.Errorf("unexpected multipart request")
+}
+
+func TestGetCreditBalanceReturnsAmount(t *testing.T) {
+	client := &creditBalanceFakeClient{
+		response: `{"ret":"0","log_id":"log_balance","data":{"total_remain_amount":"4321"}}`,
+	}
+
+	result, err := GetCreditBalance(context.Background(), &Runner{Client: client})
+	if err != nil {
+		t.Fatalf("GetCreditBalance() error = %v", err)
+	}
+	if result.TotalRemainAmount != 4321 {
+		t.Fatalf("TotalRemainAmount = %d, want 4321", result.TotalRemainAmount)
+	}
+	if result.LogID != "log_balance" {
+		t.Fatalf("LogID = %q, want log_balance", result.LogID)
+	}
+	if client.path != "/api/biz/v1/skill/get_credit_balance" {
+		t.Fatalf("path = %q, want get_credit_balance path", client.path)
+	}
+	if _, ok := client.body.(struct{}); !ok {
+		t.Fatalf("body = %#v, want an empty POST body", client.body)
+	}
+}
+
+func TestGetCreditBalanceRequiresOptionalAmount(t *testing.T) {
+	client := &creditBalanceFakeClient{
+		response: `{"ret":"0","log_id":"log_missing","data":{}}`,
+	}
+
+	_, err := GetCreditBalance(context.Background(), &Runner{Client: client})
+	if err == nil || !strings.Contains(err.Error(), "data.total_remain_amount") || !strings.Contains(err.Error(), "log_id=log_missing") {
+		t.Fatalf("GetCreditBalance() error = %v, want missing amount and log_id", err)
+	}
+}
+
+func TestGetCreditBalanceBusinessErrorIncludesLogID(t *testing.T) {
+	client := &creditBalanceFakeClient{
+		response: `{"ret":"16008","errmsg":"查询失败","log_id":"log_123"}`,
+	}
+
+	_, err := GetCreditBalance(context.Background(), &Runner{Client: client})
+	if err == nil || !strings.Contains(err.Error(), "ret=16008 errmsg=查询失败") || !strings.Contains(err.Error(), "log_id=log_123") {
+		t.Fatalf("GetCreditBalance() error = %v, want business error and log_id", err)
+	}
+}

package/internal/config/config.go

@@ -12,6 +12,7 @@ const (
 	DefaultAuthTTL              = 30 * time.Second
 	DefaultAuthStoreServiceName = "pippit-cli"
 	SubmitRunPath               = "/api/biz/v1/skill/submit_run"
+	GetCreditBalancePath        = "/api/biz/v1/skill/get_credit_balance"
 	GetThreadPath               = "/api/biz/v1/skill/get_thread"
 	UploadFilePath              = "/api/biz/v1/skill/upload_file"
 	ListThreadFilePath          = "/api/biz/v1/skill/list_thread_file"
@@ -29,10 +30,11 @@ type Config struct {
 }
 
 type Paths struct {
-	SubmitRun      string
-	GetThread      string
-	UploadFile     string
-	ListThreadFile string
+	SubmitRun        string
+	GetCreditBalance string
+	GetThread        string
+	UploadFile       string
+	ListThreadFile   string
 }
 
 // Load resolves the built-in runtime config.
@@ -43,10 +45,11 @@ func Load() *Config {
 		AuthTTL:     DefaultAuthTTL,
 		AccessKey:   strings.TrimSpace(os.Getenv(EnvXYQAccessKey)),
 		Paths: &Paths{
-			SubmitRun:      SubmitRunPath,
-			GetThread:      GetThreadPath,
-			UploadFile:     UploadFilePath,
-			ListThreadFile: ListThreadFilePath,
+			SubmitRun:        SubmitRunPath,
+			GetCreditBalance: GetCreditBalancePath,
+			GetThread:        GetThreadPath,
+			UploadFile:       UploadFilePath,
+			ListThreadFile:   ListThreadFilePath,
 		},
 	}
 }

package/internal/config/config_test.go

@@ -20,6 +20,9 @@ func TestLoadUsesDefaultConfig(t *testing.T) {
 	if cfg.Paths.SubmitRun != SubmitRunPath {
 		t.Fatalf("SubmitRun path = %q, want %q", cfg.Paths.SubmitRun, SubmitRunPath)
 	}
+	if cfg.Paths.GetCreditBalance != GetCreditBalancePath {
+		t.Fatalf("GetCreditBalance path = %q, want %q", cfg.Paths.GetCreditBalance, GetCreditBalancePath)
+	}
 }
 
 func TestLoadReadsAccessKey(t *testing.T) {

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@pippit-dev/cli",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "Pippit CLI",
   "bin": {
     "pippit-tool-cli": "scripts/run.js"
   },
   "scripts": {
     "postinstall": "node scripts/install.js",
-    "test": "node scripts/version-check.test.js && node scripts/skills.test.js && node scripts/install-wizard.test.js && go test ./... && go vet ./..."
+    "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/install-wizard.test.js && node scripts/canvas-command.test.js && node scripts/prepare-canvas-runtime.test.js && go test ./... && go vet ./...",
+    "verify:canvas-runtime": "node scripts/prepare-canvas-runtime.js --check-only"
   },
   "os": [
     "darwin",
@@ -32,11 +35,15 @@
     "skills",
     "scripts/install.js",
     "scripts/install-wizard.js",
+    "scripts/canvas-command.js",
     "scripts/platform.js",
     "scripts/run.js",
     "scripts/skills.js",
     "scripts/telemetry.js",
     "scripts/version-check.js",
+    "dist/xyq-canvas-command-runtime.cjs",
+    "dist/xyq-canvas-command-runtime.cjs.LEGAL.txt",
+    "dist/xyq-canvas-command-runtime.cjs.sha256",
     "checksums.txt",
     "README.md",
     "LICENSE"