@pippit-dev/cli 1.0.17 → 1.0.20

package/internal/canvas/create.go

@@ -0,0 +1,380 @@
+package canvas
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
+
+const defaultCreationPollInterval = time.Second
+
+var terminalCreationStates = map[string]struct{}{
+	"4": {}, "5": {}, "9": {}, "failed": {}, "canceled": {}, "hitl_interrupt": {},
+}
+
+type CreateOptions struct {
+	Title        string
+	RequestID    string
+	Wait         bool
+	PollInterval time.Duration
+	WaitTimeout  time.Duration
+}
+
+type CreateResult struct {
+	RequestID             string `json:"request_id"`
+	State                 string `json:"state"`
+	ProjectID             string `json:"project_id"`
+	ThreadID              string `json:"thread_id"`
+	RunID                 string `json:"run_id"`
+	CanvasAssetID         string `json:"canvas_asset_id"`
+	OverviewPippitAssetID string `json:"overview_pippit_asset_id,omitempty"`
+	WebURL                string `json:"web_url"`
+	LogID                 string `json:"log_id,omitempty"`
+	PollAttempts          int    `json:"poll_attempts,omitempty"`
+	Warning               string `json:"warning,omitempty"`
+}
+
+type CreationTerminalError struct {
+	State string
+}
+
+func (e *CreationTerminalError) Error() string {
+	return fmt.Sprintf("canvas creation reached terminal state %q", strings.TrimSpace(e.State))
+}
+
+type createRequest struct {
+	Surface   string         `json:"surface"`
+	Title     string         `json:"title,omitempty"`
+	RequestID string         `json:"request_id"`
+	Base      map[string]any `json:"Base"`
+}
+
+type createData struct {
+	State                 string `json:"state"`
+	ProjectID             string `json:"project_id"`
+	ThreadID              string `json:"thread_id"`
+	RunID                 string `json:"run_id"`
+	CanvasAssetID         string `json:"canvas_asset_id"`
+	OverviewPippitAssetID string `json:"overview_pippit_asset_id"`
+	WebURL                string `json:"web_url"`
+}
+
+func Create(ctx context.Context, opts CreateOptions, runner *common.Runner) (*CreateResult, error) {
+	client, err := runnerClient(runner, "canvas create")
+	if err != nil {
+		return nil, err
+	}
+	if opts.PollInterval < 0 || opts.WaitTimeout < 0 {
+		return nil, fmt.Errorf("canvas create polling durations must not be negative")
+	}
+	requestID := strings.TrimSpace(opts.RequestID)
+	if requestID == "" {
+		return nil, fmt.Errorf("canvas create request_id is required")
+	}
+	if len([]rune(requestID)) > 128 {
+		return nil, fmt.Errorf("canvas create request_id must not exceed 128 characters")
+	}
+	title := strings.TrimSpace(opts.Title)
+	if len([]rune(title)) > 50 {
+		return nil, fmt.Errorf("canvas create title must not exceed 50 characters")
+	}
+
+	var envelope responseEnvelope
+	err = client.SendRequest(ctx, CreatePath, createRequest{
+		Surface:   SurfaceNovel,
+		Title:     title,
+		RequestID: requestID,
+		Base:      base(),
+	}, &envelope)
+	if err != nil {
+		return nil, fmt.Errorf("canvas create request failed; outcome may be ambiguous, do not retry blindly: %w", err)
+	}
+	if err := envelope.validate("canvas create"); err != nil {
+		return nil, err
+	}
+	var data createData
+	if err := json.Unmarshal(envelope.Data, &data); err != nil {
+		return nil, common.NewLogIDError(fmt.Sprintf("canvas create returned invalid data: %v", err), envelope.LogID)
+	}
+	result := &CreateResult{
+		RequestID:             requestID,
+		State:                 strings.TrimSpace(data.State),
+		ProjectID:             strings.TrimSpace(data.ProjectID),
+		ThreadID:              strings.TrimSpace(data.ThreadID),
+		RunID:                 strings.TrimSpace(data.RunID),
+		CanvasAssetID:         strings.TrimSpace(data.CanvasAssetID),
+		OverviewPippitAssetID: strings.TrimSpace(data.OverviewPippitAssetID),
+		WebURL:                strings.TrimSpace(data.WebURL),
+		LogID:                 strings.TrimSpace(envelope.LogID),
+	}
+	if err := validateCreateResult(result); err != nil {
+		return nil, common.NewLogIDError(err.Error(), envelope.LogID)
+	}
+	if !opts.Wait {
+		return result, nil
+	}
+	if result.OverviewPippitAssetID != "" {
+		return finalizeReadyCanvas(ctx, result, runner)
+	}
+
+	artifact, attempts, waitErr := waitForCreationArtifact(ctx, runner, result.ThreadID, result.RunID, opts.PollInterval, opts.WaitTimeout)
+	result.PollAttempts = attempts
+	if waitErr != nil {
+		result.Warning = waitErr.Error()
+		var terminal *CreationTerminalError
+		if errors.As(waitErr, &terminal) {
+			result.State = "failed"
+			return result, acceptedCreationError(result, waitErr)
+		}
+		// The create response was already accepted. A timeout or transient
+		// get_thread failure must preserve the operation IDs and must not make
+		// callers assume it is safe to create another project.
+		return result, nil
+	}
+	if artifact.CanvasAssetID != "" && artifact.CanvasAssetID != result.CanvasAssetID {
+		result.State = "failed"
+		result.Warning = fmt.Sprintf("canvas create artifact canvas_asset_id mismatch: got %q, want %q", artifact.CanvasAssetID, result.CanvasAssetID)
+		return result, acceptedCreationError(result, errors.New(result.Warning))
+	}
+	result.OverviewPippitAssetID = artifact.OverviewPippitAssetID
+	return finalizeReadyCanvas(ctx, result, runner)
+}
+
+func finalizeReadyCanvas(ctx context.Context, result *CreateResult, runner *common.Runner) (*CreateResult, error) {
+	// Preserve the confirmed overview locator even if the final root visibility
+	// check is temporarily unavailable. The state remains creating until that
+	// check succeeds, but callers can resume with the canonical project URL.
+	result.WebURL = readyCanvasURL(result.WebURL, result.ProjectID, result.OverviewPippitAssetID)
+	if _, err := queryAssets(ctx, []string{result.CanvasAssetID}, true, runner); err != nil {
+		result.State = StateCreating
+		result.Warning = fmt.Sprintf("canvas overview is complete but the root asset is not queryable yet: %v", err)
+		return result, nil
+	}
+	result.State = StateReady
+	return result, nil
+}
+
+func acceptedCreationError(result *CreateResult, cause error) error {
+	return fmt.Errorf(
+		"%w; accepted canvas IDs: project_id=%s thread_id=%s run_id=%s canvas_asset_id=%s; do not create again blindly",
+		cause, result.ProjectID, result.ThreadID, result.RunID, result.CanvasAssetID,
+	)
+}
+
+func validateCreateResult(result *CreateResult) error {
+	if result == nil {
+		return fmt.Errorf("canvas create response is empty")
+	}
+	missing := make([]string, 0, 4)
+	for name, value := range map[string]string{
+		"project_id": result.ProjectID, "thread_id": result.ThreadID,
+		"run_id": result.RunID, "canvas_asset_id": result.CanvasAssetID,
+	} {
+		if value == "" {
+			missing = append(missing, name)
+		}
+	}
+	if len(missing) != 0 {
+		return fmt.Errorf("canvas create response is missing %s", strings.Join(missing, ", "))
+	}
+	if result.State == "" {
+		return fmt.Errorf("canvas create response is missing state")
+	}
+	if result.WebURL == "" {
+		return fmt.Errorf("canvas create response is missing web_url")
+	}
+	return nil
+}
+
+type creationArtifact struct {
+	OverviewPippitAssetID string
+	CanvasAssetID         string
+}
+
+func waitForCreationArtifact(
+	ctx context.Context,
+	runner *common.Runner,
+	threadID, runID string,
+	pollInterval, waitTimeout time.Duration,
+) (creationArtifact, int, error) {
+	if pollInterval <= 0 {
+		pollInterval = defaultCreationPollInterval
+	}
+	if waitTimeout <= 0 {
+		waitTimeout = 2 * time.Minute
+	}
+	waitCtx, cancel := context.WithTimeout(ctx, waitTimeout)
+	defer cancel()
+	attempts := 0
+	for {
+		attempts++
+		result, err := common.GetThread(waitCtx, &common.GetThreadOptions{ThreadID: threadID, RunID: runID}, runner)
+		if err != nil {
+			if waitCtx.Err() != nil {
+				return creationArtifact{}, attempts, creationWaitError(waitCtx.Err(), waitTimeout)
+			}
+			return creationArtifact{}, attempts, fmt.Errorf("poll canvas creation: %w", err)
+		}
+		run := findRunByID(result.RawData, runID)
+		if run != nil {
+			state := normalizeState(run["state"])
+			artifact := findCreationArtifact(run)
+			if (state == "3" || state == "completed") && artifact.OverviewPippitAssetID != "" {
+				return artifact, attempts, nil
+			}
+			if _, terminal := terminalCreationStates[state]; terminal {
+				return creationArtifact{}, attempts, &CreationTerminalError{State: state}
+			}
+		}
+
+		timer := time.NewTimer(pollInterval)
+		select {
+		case <-waitCtx.Done():
+			timer.Stop()
+			return creationArtifact{}, attempts, creationWaitError(waitCtx.Err(), waitTimeout)
+		case <-timer.C:
+		}
+	}
+}
+
+func creationWaitError(err error, timeout time.Duration) error {
+	if errors.Is(err, context.DeadlineExceeded) {
+		return fmt.Errorf("canvas creation artifact was not ready within %s", timeout)
+	}
+	return fmt.Errorf("canvas creation wait canceled: %w", err)
+}
+
+func findRunByID(raw json.RawMessage, runID string) map[string]any {
+	var value any
+	if json.Unmarshal(raw, &value) != nil {
+		return nil
+	}
+	return walkForRun(value, runID, 0)
+}
+
+func walkForRun(value any, runID string, depth int) map[string]any {
+	if depth > 14 {
+		return nil
+	}
+	switch typed := parseJSONValue(value).(type) {
+	case map[string]any:
+		if stringValue(firstValue(typed, "run_id", "runId")) == runID {
+			return typed
+		}
+		for _, child := range typed {
+			if found := walkForRun(child, runID, depth+1); found != nil {
+				return found
+			}
+		}
+	case []any:
+		for _, child := range typed {
+			if found := walkForRun(child, runID, depth+1); found != nil {
+				return found
+			}
+		}
+	}
+	return nil
+}
+
+func findCreationArtifact(value any) creationArtifact {
+	artifact := creationArtifact{}
+	walkArtifact(parseJSONValue(value), 0, &artifact)
+	return artifact
+}
+
+func walkArtifact(value any, depth int, artifact *creationArtifact) {
+	if depth > 14 || (artifact.OverviewPippitAssetID != "" && artifact.CanvasAssetID != "") {
+		return
+	}
+	switch typed := parseJSONValue(value).(type) {
+	case map[string]any:
+		if stringValue(firstValue(typed, "sub_type", "subType")) == overviewPartSubtype {
+			data, _ := parseJSONValue(typed["data"]).(map[string]any)
+			if data == nil {
+				data = map[string]any{}
+			}
+			artifact.OverviewPippitAssetID = firstNonEmpty(
+				stringValue(firstValue(data, "pippit_asset_id", "pippitAssetId")),
+				stringValue(firstValue(typed, "pippit_asset_id", "pippitAssetId")),
+			)
+			artifact.CanvasAssetID = stringValue(firstValue(data, "canvas_asset_id", "canvasAssetId"))
+		}
+		for _, child := range typed {
+			walkArtifact(child, depth+1, artifact)
+		}
+	case []any:
+		for _, child := range typed {
+			walkArtifact(child, depth+1, artifact)
+		}
+	}
+}
+
+func parseJSONValue(value any) any {
+	text, ok := value.(string)
+	if !ok {
+		return value
+	}
+	text = strings.TrimSpace(text)
+	if text == "" || (text[0] != '{' && text[0] != '[') {
+		return value
+	}
+	var parsed any
+	if json.Unmarshal([]byte(text), &parsed) == nil {
+		return parsed
+	}
+	return value
+}
+
+func firstValue(values map[string]any, keys ...string) any {
+	for _, key := range keys {
+		if value, ok := values[key]; ok {
+			return value
+		}
+	}
+	return nil
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if value = strings.TrimSpace(value); value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func stringValue(value any) string {
+	switch typed := value.(type) {
+	case string:
+		return strings.TrimSpace(typed)
+	case json.Number:
+		return typed.String()
+	case float64:
+		return fmt.Sprintf("%.0f", typed)
+	default:
+		return ""
+	}
+}
+
+func normalizeState(value any) string {
+	return strings.ToLower(stringValue(value))
+}
+
+func readyCanvasURL(raw, projectID, overviewID string) string {
+	parsed, err := url.Parse(strings.TrimSpace(raw))
+	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
+		parsed, _ = url.Parse("https://xyq.jianying.com/novel/detail/canvas")
+	}
+	query := parsed.Query()
+	query.Set("projectId", projectID)
+	query.Set("overviewPippitAssetId", overviewID)
+	query.Del("canvasId")
+	parsed.RawQuery = query.Encode()
+	return parsed.String()
+}

package/internal/canvas/get.go

@@ -0,0 +1,156 @@
+package canvas
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
+
+type GetOptions struct {
+	AssetIDs []string
+}
+
+type GetResult struct {
+	RequestedAssetIDs []string          `json:"requested_asset_ids"`
+	Assets            []json.RawMessage `json:"assets"`
+	LogID             string            `json:"log_id,omitempty"`
+}
+
+type queryRequest struct {
+	PippitAssetIDs []string       `json:"pippit_asset_ids"`
+	Base           map[string]any `json:"Base"`
+}
+
+func Get(ctx context.Context, opts GetOptions, runner *common.Runner) (*GetResult, error) {
+	assetIDs, err := normalizeAssetIDs(opts.AssetIDs)
+	if err != nil {
+		return nil, err
+	}
+	return queryAssets(ctx, assetIDs, true, runner)
+}
+
+func queryAssets(ctx context.Context, assetIDs []string, requireAll bool, runner *common.Runner) (*GetResult, error) {
+	client, err := runnerClient(runner, "canvas get")
+	if err != nil {
+		return nil, err
+	}
+	var envelope responseEnvelope
+	if err := client.SendRequest(ctx, QueryPath, queryRequest{PippitAssetIDs: assetIDs, Base: base()}, &envelope); err != nil {
+		return nil, fmt.Errorf("canvas get request failed: %w", err)
+	}
+	if err := envelope.validate("canvas get"); err != nil {
+		return nil, err
+	}
+	assets, err := assetsFromData(envelope.Data)
+	if err != nil {
+		return nil, common.NewLogIDError(fmt.Sprintf("canvas get returned invalid data: %v", err), envelope.LogID)
+	}
+
+	byID := make(map[string]json.RawMessage, len(assets))
+	for _, asset := range assets {
+		assetID, err := assetIDFromRaw(asset)
+		if err != nil {
+			return nil, common.NewLogIDError(fmt.Sprintf("canvas get returned invalid asset: %v", err), envelope.LogID)
+		}
+		if _, duplicate := byID[assetID]; duplicate {
+			return nil, common.NewLogIDError(fmt.Sprintf("canvas get returned duplicate asset %q", assetID), envelope.LogID)
+		}
+		byID[assetID] = asset
+	}
+
+	ordered := make([]json.RawMessage, 0, len(assetIDs))
+	missing := make([]string, 0)
+	for _, assetID := range assetIDs {
+		asset, ok := byID[assetID]
+		if !ok {
+			missing = append(missing, assetID)
+			continue
+		}
+		ordered = append(ordered, asset)
+	}
+	if requireAll && len(missing) != 0 {
+		return nil, common.NewLogIDError(
+			fmt.Sprintf("canvas get did not return requested assets: %s", strings.Join(missing, ", ")),
+			envelope.LogID,
+		)
+	}
+	return &GetResult{
+		RequestedAssetIDs: append([]string(nil), assetIDs...),
+		Assets:            ordered,
+		LogID:             strings.TrimSpace(envelope.LogID),
+	}, nil
+}
+
+func normalizeAssetIDs(values []string) ([]string, error) {
+	if len(values) == 0 {
+		return nil, fmt.Errorf("at least one canvas asset_id is required")
+	}
+	result := make([]string, 0, len(values))
+	seen := make(map[string]struct{}, len(values))
+	for index, value := range values {
+		value = strings.TrimSpace(value)
+		if value == "" {
+			return nil, fmt.Errorf("canvas asset_id at index %d is empty", index)
+		}
+		if _, duplicate := seen[value]; duplicate {
+			return nil, fmt.Errorf("canvas asset_id %q is duplicated", value)
+		}
+		seen[value] = struct{}{}
+		result = append(result, value)
+	}
+	return result, nil
+}
+
+func assetsFromData(raw json.RawMessage) ([]json.RawMessage, error) {
+	var data map[string]json.RawMessage
+	if len(raw) == 0 || string(raw) == "null" {
+		return nil, fmt.Errorf("data is missing")
+	}
+	if err := json.Unmarshal(raw, &data); err != nil {
+		return nil, err
+	}
+	assetsRaw, ok := rawField(data, "Assets", "assets")
+	if !ok {
+		return nil, fmt.Errorf("data.assets is missing")
+	}
+	var assets []json.RawMessage
+	if err := json.Unmarshal(assetsRaw, &assets); err != nil {
+		return nil, fmt.Errorf("decode data.assets: %w", err)
+	}
+	if assets == nil {
+		assets = []json.RawMessage{}
+	}
+	return assets, nil
+}
+
+func assetIDFromRaw(raw json.RawMessage) (string, error) {
+	var asset map[string]json.RawMessage
+	if err := json.Unmarshal(raw, &asset); err != nil {
+		return "", err
+	}
+	value, ok := rawField(asset, "PippitAssetID", "pippit_asset_id", "pippitAssetId")
+	if !ok {
+		return "", fmt.Errorf("asset is missing pippit_asset_id")
+	}
+	var assetID string
+	if err := json.Unmarshal(value, &assetID); err != nil {
+		return "", fmt.Errorf("pippit_asset_id must be a JSON string")
+	}
+	assetID = strings.TrimSpace(assetID)
+	if assetID == "" {
+		return "", fmt.Errorf("pippit_asset_id is empty")
+	}
+	return assetID, nil
+}
+
+func rawField(values map[string]json.RawMessage, keys ...string) (json.RawMessage, bool) {
+	for _, key := range keys {
+		if value, ok := values[key]; ok {
+			return value, true
+		}
+	}
+	return nil, false
+}

package/internal/canvas/types.go

@@ -0,0 +1,68 @@
+package canvas
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
+
+const (
+	CreatePath   = "/api/biz/v1/skill/canvas/create"
+	QueryPath    = "/api/biz/v1/skill/canvas/query"
+	AllocatePath = "/api/biz/v1/skill/canvas/batch_generate_asset_id"
+	ApplyPath    = "/api/biz/v1/skill/canvas/batch_patch_asset"
+	UploadPath   = "/api/biz/v1/skill/upload_file"
+)
+
+const (
+	SurfaceNovel        = "novel"
+	StateCreating       = "creating"
+	StateProcessing     = "processing"
+	StateReady          = "ready"
+	overviewPartSubtype = "biz/x_data_novel_script_overview"
+)
+
+type responseEnvelope struct {
+	Ret    string          `json:"ret"`
+	Errmsg string          `json:"errmsg"`
+	LogID  string          `json:"log_id"`
+	Data   json.RawMessage `json:"data"`
+}
+
+func (r responseEnvelope) validate(operation string) error {
+	if r.Ret == "0" {
+		return nil
+	}
+	message := strings.TrimSpace(r.Errmsg)
+	if message == "" {
+		message = "unknown error"
+	}
+	return common.NewLogIDError(
+		fmt.Sprintf("%s failed: ret=%q errmsg=%s", operation, r.Ret, message),
+		r.LogID,
+	)
+}
+
+func base() map[string]any {
+	return map[string]any{}
+}
+
+func runnerClient(runner *common.Runner, operation string) (common.Client, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("%s client is missing", operation)
+	}
+	return runner.Client, nil
+}
+
+func pathWithProjectID(path, projectID string) string {
+	projectID = strings.TrimSpace(projectID)
+	if projectID == "" {
+		return path
+	}
+	query := url.Values{}
+	query.Set("project_id", projectID)
+	return path + "?" + query.Encode()
+}