@pippit-dev/cli 0.0.10 → 0.0.12

package/README.md

@@ -10,9 +10,9 @@ matching prebuilt binary for macOS, Linux, or Windows:
 ```bash
 npx @pippit-dev/cli@latest install
 export XYQ_ACCESS_KEY="<access-key>"
-pippit-cli version
+pippit-cli --version
 pippit-cli short-drama +submit-run --message "写一个赛博朋克短剧开头"
-pippit-cli short-drama +upload-file --path ./story.md
+pippit-cli short-drama +upload-file --path ./reference.doc
 pippit-cli short-drama +get-thread --thread-id thread_123 --run-id run_456 --after-seq 0
 pippit-cli short-drama +download-result --output-path ./thread_123/results/result.mp4 --url URL
 ```
@@ -24,9 +24,9 @@ Submit a Run task for the short drama scene:
 
 ```bash
 export XYQ_ACCESS_KEY="<access-key>"
-go run . version
+go run . --version
 go run . short-drama +submit-run --message "写一个赛博朋克短剧开头"
-go run . short-drama +upload-file --path ./story.md
+go run . short-drama +upload-file --path ./reference.doc
 go run . short-drama +get-thread --thread-id thread_123 --run-id run_456 --after-seq 0
 go run . short-drama +download-result --output-path ./thread_123/results/result.mp4 --url URL
 ```
@@ -35,9 +35,11 @@ go run . short-drama +download-result --output-path ./thread_123/results/result.
 `run_id`, and `web_thread_link`; `--message` is required.
 `+get-thread` calls
 `/api/biz/v1/skill/get_thread` and prints extracted `messages`.
+`+upload-file` calls `/api/biz/v1/skill/upload_file` with
+`multipart/form-data` and prints the returned `asset_id`.
+Only `.doc` and `.txt` file extensions are supported.
 `+download-result` downloads the result URL to
-the `--output-path` file path. `+upload-file` is still mocked while
-its real service contract is wired.
+the `--output-path` file path.
 
 ## HTTP Client
 
@@ -47,6 +49,6 @@ settings such as base URL, HTTP timeout, and API paths are loaded by
 
 ## Auth
 
-`short-drama +submit-run` and `short-drama +get-thread` authenticate with
+`short-drama +submit-run`, `short-drama +get-thread`, and `short-drama +upload-file` authenticate with
 `Authorization: Bearer <XYQ_ACCESS_KEY>`. OAuth command code remains available,
 but runtime short drama requests do not use it.

package/checksums.txt

@@ -1,6 +1,6 @@
-5aca1f46d99e5ab9d748cf14d4cfe5fa68b2d2cb248073db0c92d0de361e5fb8  pippit-cli-0.0.10-darwin-amd64.tar.gz
-b56de7e3bdd202d449ea5658171b52dbde313c1e3f12f999c583a6b321624d11  pippit-cli-0.0.10-darwin-arm64.tar.gz
-b9ddcbd19ffa7aada4c114f7be8b8d6fb870b9a0b9ffed99c0df196ce05658d4  pippit-cli-0.0.10-linux-amd64.tar.gz
-3b8a11becb6229f22c39e2c86caaa897f4ae9147e0960414c0d763ce00bbdd5b  pippit-cli-0.0.10-linux-arm64.tar.gz
-26a57f485227f9674591ed20536baa281c443b5ac1c26711e064a77d9ebc6174  pippit-cli-0.0.10-windows-amd64.zip
-8fd4eca3a8977b901d74aa6455293c3c400151e5981491f6d3df1d568781c3eb  pippit-cli-0.0.10-windows-arm64.zip
+5062d1d4950aa9e0d8b1770e62476d9bb2076f4492cd24a541ad93b05a254f49  pippit-cli-0.0.12-darwin-amd64.tar.gz
+5a0c8d044ebcb717d18954147433ac5f54f2dc89285e2e50f6be6755431ee99c  pippit-cli-0.0.12-darwin-arm64.tar.gz
+456420a71cd9909e152907faa96f35abb93e62079786021d1bee28cfac61e8ff  pippit-cli-0.0.12-linux-amd64.tar.gz
+1c6681fa8f8edaa19dac835dd9bdf4bc17c06936700316f7d74b68d55d572460  pippit-cli-0.0.12-linux-arm64.tar.gz
+e7c156bb35fb373fa89d05c729252b20951a41c70f3bbd4e8794e4c5abe65e06  pippit-cli-0.0.12-windows-amd64.zip
+2832786f9c13069f3580407e24037e95cc9452534e9996366dc6751f841fcd26  pippit-cli-0.0.12-windows-arm64.zip

package/cmd/root.go

@@ -7,7 +7,6 @@ import (
 	// authcmd "github.com/Pippit-dev/pippit-cli/cmd/auth"
 	"github.com/Pippit-dev/pippit-cli/cmd/short_drama"
 	updatecmd "github.com/Pippit-dev/pippit-cli/cmd/update"
-	versioncmd "github.com/Pippit-dev/pippit-cli/cmd/version"
 	"github.com/Pippit-dev/pippit-cli/internal/common"
 	"github.com/Pippit-dev/pippit-cli/internal/config"
 	"github.com/Pippit-dev/pippit-cli/internal/version"
@@ -30,15 +29,17 @@ func newRootCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Comm
 	root := &cobra.Command{
 		Use:           "pippit-cli",
 		Short:         "Pippit CLI",
+		Long:          "Pippit CLI submits short-drama workflows, downloads generated assets, and updates the installed CLI package.",
 		Version:       version.Current(),
 		SilenceUsage:  true,
 		SilenceErrors: true,
 	}
+	root.CompletionOptions.DisableDefaultCmd = true
+	root.SetVersionTemplate("{{.Version}}\n")
 	root.SetOut(stdout)
 	root.SetErr(stderr)
 	// root.AddCommand(authcmd.NewCommand(stdout, stderr, runner)) // temporarily disabled; auth is via access key injection
 	root.AddCommand(short_drama.NewCommand(stdout, stderr, runner))
 	root.AddCommand(updatecmd.NewCommand(stdout, stderr))
-	root.AddCommand(versioncmd.NewCommand(stdout))
 	return root
 }

package/cmd/short_drama/short_drama.go

@@ -3,7 +3,6 @@ package short_drama
 import (
 	"fmt"
 	"io"
-	"path/filepath"
 	"strings"
 
 	"github.com/Pippit-dev/pippit-cli/internal/common"
@@ -72,8 +71,6 @@ func newShortDramaUploadFileCommand(stdout, stderr io.Writer, runner *common.Run
 			if opts.Path == "" {
 				return fmt.Errorf("--path is required")
 			}
-			opts.FileName = filepath.Base(opts.Path)
-			opts.Mock = true
 
 			result, err := common.UploadFile(cmd.Context(), opts, runner)
 			if err != nil {

package/cmd/short_drama_test.go

@@ -91,28 +91,38 @@ func TestRootIncludesUpdateCommand(t *testing.T) {
 	}
 }
 
-func TestRootIncludesVersionCommand(t *testing.T) {
+func TestRootDoesNotIncludeVersionCommand(t *testing.T) {
 	var stdout, stderr bytes.Buffer
 	root := NewRootCommand(&stdout, &stderr)
 	cmd, _, err := root.Find([]string{"version"})
-	if err != nil {
-		t.Fatalf("Find(version) error = %v", err)
-	}
-	if cmd == nil || cmd.Name() != "version" {
-		t.Fatalf("Find(version) = %#v, want version command", cmd)
+	if err == nil || cmd != root {
+		t.Fatalf("Find(version) = (%#v, %v), want unknown command", cmd, err)
 	}
 }
 
-func TestVersionCommandPrintsVersion(t *testing.T) {
+func TestRootHelpListsSupportedCommands(t *testing.T) {
 	var stdout, stderr bytes.Buffer
 	root := NewRootCommand(&stdout, &stderr)
-	root.SetArgs([]string{"version"})
+	root.SetArgs([]string{"--help"})
 
 	if err := root.Execute(); err != nil {
 		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
 	}
-	if got := strings.TrimSpace(stdout.String()); got != version.Current() {
-		t.Fatalf("version output = %q, want %s", got, version.Current())
+	got := stdout.String()
+	for _, want := range []string{
+		"Pippit CLI submits short-drama workflows",
+		"short-drama",
+		"update",
+		"--version",
+	} {
+		if !strings.Contains(got, want) {
+			t.Fatalf("help output = %q, want %q", got, want)
+		}
+	}
+	for _, unwanted := range []string{"completion", "version     "} {
+		if strings.Contains(got, unwanted) {
+			t.Fatalf("help output = %q, should not contain %q", got, unwanted)
+		}
 	}
 }
 
@@ -124,8 +134,8 @@ func TestVersionFlagPrintsVersion(t *testing.T) {
 	if err := root.Execute(); err != nil {
 		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
 	}
-	if got := stdout.String(); !strings.Contains(got, version.Current()) {
-		t.Fatalf("version flag output = %q, want version", got)
+	if got := strings.TrimSpace(stdout.String()); got != version.Current() {
+		t.Fatalf("version flag output = %q, want %s", got, version.Current())
 	}
 }
 
@@ -166,23 +176,65 @@ func TestShortDramaSubmitRunRequiresAccessKey(t *testing.T) {
 }
 
 func TestShortDramaUploadFile(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			t.Fatalf("method = %s, want POST", r.Method)
+		}
+		if r.URL.Path != "/api/biz/v1/skill/upload_file" {
+			t.Fatalf("path = %s, want upload_file path", r.URL.Path)
+		}
+		if r.Header.Get("Authorization") != "Bearer test-token" {
+			t.Fatalf("Authorization = %q, want test bearer token", r.Header.Get("Authorization"))
+		}
+		if err := r.ParseMultipartForm(1 << 20); err != nil {
+			t.Fatalf("ParseMultipartForm(): %v", err)
+		}
+		if got := r.FormValue("accessKey"); got != "" {
+			t.Fatalf("accessKey = %q, want empty (auth via header only)", got)
+		}
+		files := r.MultipartForm.File["file"]
+		if len(files) != 1 {
+			t.Fatalf("file parts = %d, want 1", len(files))
+		}
+		if files[0].Filename != "story.txt" {
+			t.Fatalf("filename = %q, want story.txt", files[0].Filename)
+		}
+		if got := files[0].Header.Get("Content-Type"); got != "text/plain; charset=utf-8" {
+			t.Fatalf("Content-Type = %q, want text/plain; charset=utf-8", got)
+		}
+		file, err := files[0].Open()
+		if err != nil {
+			t.Fatalf("Open multipart file: %v", err)
+		}
+		defer file.Close()
+		data, err := io.ReadAll(file)
+		if err != nil {
+			t.Fatalf("ReadAll multipart file: %v", err)
+		}
+		if string(data) != "txt-data" {
+			t.Fatalf("file content = %q, want txt-data", string(data))
+		}
+		_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"pippit_asset_id":"asset_123"}}`))
+	}))
+	defer server.Close()
+
+	cwd := chdirTemp(t)
+	path := filepath.Join(cwd, "story.txt")
+	if err := os.WriteFile(path, []byte("txt-data"), 0o644); err != nil {
+		t.Fatalf("WriteFile(): %v", err)
+	}
+
 	var stdout, stderr bytes.Buffer
-	root := NewRootCommand(&stdout, &stderr)
-	root.SetArgs([]string{"short-drama", "+upload-file", "--path", "/tmp/story.md"})
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{"short-drama", "+upload-file", "--path", path})
 
 	if err := root.Execute(); err != nil {
 		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
 	}
 
 	got := decodeJSON(t, stdout.Bytes())
-	if got["scene"] != "short-drama" {
-		t.Fatalf("scene = %v, want short-drama", got["scene"])
-	}
-	if got["status"] != "uploaded" {
-		t.Fatalf("status = %v, want uploaded", got["status"])
-	}
-	if !strings.HasPrefix(got["file_id"].(string), "file_mock_") {
-		t.Fatalf("file_id = %v, want mock file id", got["file_id"])
+	if got["asset_id"] != "asset_123" {
+		t.Fatalf("asset_id = %v, want asset_123", got["asset_id"])
 	}
 }
 
@@ -200,6 +252,51 @@ func TestShortDramaUploadFileRequiresPath(t *testing.T) {
 	}
 }
 
+func TestShortDramaUploadFileRequiresAccessKey(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		t.Fatal("server should not receive request without access key")
+	}))
+	defer server.Close()
+
+	cwd := chdirTemp(t)
+	path := filepath.Join(cwd, "story.txt")
+	if err := os.WriteFile(path, []byte("txt-data"), 0o644); err != nil {
+		t.Fatalf("WriteFile(): %v", err)
+	}
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommandWithAccessKey(t, &stdout, &stderr, server.URL, "")
+	root.SetArgs([]string{"short-drama", "+upload-file", "--path", path})
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("Execute() error = nil, want access key error")
+	}
+	if !strings.Contains(err.Error(), "XYQ_ACCESS_KEY is required") {
+		t.Fatalf("error = %q, want access key guidance", err)
+	}
+}
+
+func TestShortDramaUploadFileRejectsUnsupportedFileType(t *testing.T) {
+	cwd := chdirTemp(t)
+	path := filepath.Join(cwd, "story.png")
+	if err := os.WriteFile(path, []byte("png-data"), 0o644); err != nil {
+		t.Fatalf("WriteFile(): %v", err)
+	}
+
+	var stdout, stderr bytes.Buffer
+	root := NewRootCommand(&stdout, &stderr)
+	root.SetArgs([]string{"short-drama", "+upload-file", "--path", path})
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("Execute() error = nil, want file type validation error")
+	}
+	if !strings.Contains(err.Error(), "only .doc and .txt uploads are supported") {
+		t.Fatalf("error = %q, want unsupported type validation", err)
+	}
+}
+
 func TestShortDramaDownloadResult(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.Header.Get("User-Agent") != "Pippit-CLI/1.0" {

package/internal/common/client.go

@@ -5,8 +5,12 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"mime/multipart"
 	"net/http"
+	"net/textproto"
 	"net/url"
+	"os"
+	"path/filepath"
 	"reflect"
 	"strings"
 	"time"
@@ -16,12 +20,20 @@ import (
 
 type Client interface {
 	SendRequest(ctx context.Context, path string, body any, out any) error
+	SendMultipartRequest(ctx context.Context, path string, fields map[string]string, file MultipartFile, out any) error
 }
 
 type RequestAuthorizer interface {
 	Inject(ctx context.Context, req *http.Request) error
 }
 
+type MultipartFile struct {
+	FieldName   string
+	Path        string
+	FileName    string
+	ContentType string
+}
+
 type httpClient struct {
 	baseURL    string
 	httpClient *http.Client
@@ -100,6 +112,89 @@ func (c *httpClient) SendRequest(ctx context.Context, path string, body any, out
 	return c.do(req, out)
 }
 
+func (c *httpClient) SendMultipartRequest(ctx context.Context, path string, fields map[string]string, file MultipartFile, out any) error {
+	reqURL, err := c.resolveURL(path, nil)
+	if err != nil {
+		return err
+	}
+	if file.FieldName == "" {
+		return fmt.Errorf("multipart file field name is required")
+	}
+	if file.FileName == "" {
+		file.FileName = filepath.Base(file.Path)
+	}
+	if file.ContentType == "" {
+		file.ContentType = "application/octet-stream"
+	}
+
+	pr, pw := io.Pipe()
+	writer := multipart.NewWriter(pw)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqURL, pr)
+	if err != nil {
+		_ = pr.Close()
+		_ = pw.Close()
+		return fmt.Errorf("build POST request: %w", err)
+	}
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+	req.Header.Set("Accept", "application/json")
+
+	if c.authorizer == nil {
+		_ = pr.Close()
+		_ = pw.Close()
+		return fmt.Errorf("authorized request requires authorizer")
+	}
+	if err := c.authorizer.Inject(ctx, req); err != nil {
+		_ = pr.Close()
+		_ = pw.Close()
+		return fmt.Errorf("inject auth headers: %w", err)
+	}
+	c.injectHeaders(req)
+
+	go func() {
+		err := writeMultipartBody(writer, fields, file)
+		closeErr := writer.Close()
+		if err != nil {
+			_ = pw.CloseWithError(err)
+			return
+		}
+		_ = pw.CloseWithError(closeErr)
+	}()
+
+	return c.do(req, out)
+}
+
+func writeMultipartBody(writer *multipart.Writer, fields map[string]string, file MultipartFile) error {
+	for key, value := range fields {
+		if err := writer.WriteField(key, value); err != nil {
+			return err
+		}
+	}
+
+	f, err := os.Open(file.Path)
+	if err != nil {
+		return fmt.Errorf("open upload file: %w", err)
+	}
+	defer f.Close()
+
+	header := make(textproto.MIMEHeader)
+	header.Set("Content-Disposition", fmt.Sprintf(`form-data; name="%s"; filename="%s"`, escapeQuotes(file.FieldName), escapeQuotes(file.FileName)))
+	header.Set("Content-Type", file.ContentType)
+	part, err := writer.CreatePart(header)
+	if err != nil {
+		return err
+	}
+	if _, err := io.Copy(part, f); err != nil {
+		return fmt.Errorf("write upload file: %w", err)
+	}
+	return nil
+}
+
+var quotesReplacer = strings.NewReplacer("\\", "\\\\", `"`, `\"`)
+
+func escapeQuotes(s string) string {
+	return quotesReplacer.Replace(s)
+}
+
 func (c *httpClient) injectHeaders(req *http.Request) {
 	for k, values := range c.headers {
 		for _, v := range values {

package/internal/common/upload_file.go

@@ -2,48 +2,103 @@ package common
 
 import (
 	"context"
-	"crypto/sha1"
-	"encoding/hex"
-	"time"
+	"fmt"
+	"mime"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/config"
 )
 
 // UploadFileOptions is the stable command-facing request shape for file upload.
 type UploadFileOptions struct {
 	Path     string `json:"path"`
 	FileName string `json:"file_name"`
-	Purpose  string `json:"purpose"`
-	Mock     bool   `json:"mock"`
 }
 
 // UploadFileResult is the JSON envelope printed by `pippit-cli short-drama +upload-file`.
 type UploadFileResult struct {
-	Scene    string            `json:"scene"`
-	FileID   string            `json:"file_id"`
-	Status   string            `json:"status"`
-	Uploaded string            `json:"uploaded_at"`
-	Request  UploadFileOptions `json:"request"`
+	AssetID string `json:"asset_id"`
+}
+
+type uploadFileResponse struct {
+	Ret     string `json:"ret"`
+	Errmsg  string `json:"errmsg"`
+	SvrTime int64  `json:"svr_time"`
+	LogID   string `json:"log_id"`
+	Data    struct {
+		PippitAssetID string `json:"pippit_asset_id"`
+		AssetID       string `json:"asset_id"`
+	} `json:"data"`
+}
+
+const uploadFileFieldName = "file"
+
+var allowedUploadExtensions = map[string]bool{
+	".doc": true,
+	".txt": true,
 }
 
-func UploadFile(ctx context.Context, opts UploadFileOptions, _ *Runner) (*UploadFileResult, error) {
+func UploadFile(ctx context.Context, opts UploadFileOptions, runner *Runner) (*UploadFileResult, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, err
 	}
-	key := opts.Purpose + "\x00" + opts.FileName + "\x00" + opts.Path
-	id := stableID(key, 10)
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("upload_file runner client is required")
+	}
+
+	path := strings.TrimSpace(opts.Path)
+	if path == "" {
+		return nil, fmt.Errorf("upload file path is required")
+	}
+	info, err := os.Stat(path)
+	if err != nil {
+		return nil, fmt.Errorf("stat upload file: %w", err)
+	}
+	if info.IsDir() {
+		return nil, fmt.Errorf("upload path %q is a directory", path)
+	}
+
+	ext := strings.ToLower(filepath.Ext(path))
+	if !allowedUploadExtensions[ext] {
+		return nil, fmt.Errorf("unsupported file extension %q; only .doc and .txt uploads are supported", ext)
+	}
+	fileName := filepath.Base(path)
+	contentType := mime.TypeByExtension(ext)
+
+	var resp uploadFileResponse
+	if err := runner.Client.SendMultipartRequest(ctx, uploadFilePath(runner), nil, MultipartFile{
+		FieldName:   uploadFileFieldName,
+		Path:        path,
+		FileName:    fileName,
+		ContentType: contentType,
+	}, &resp); err != nil {
+		return nil, fmt.Errorf("upload_file request failed: %w", err)
+	}
+	if resp.Ret != "0" {
+		if resp.Errmsg == "" {
+			resp.Errmsg = "unknown error"
+		}
+		return nil, fmt.Errorf("upload_file failed: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+	}
+
+	assetID := strings.TrimSpace(resp.Data.PippitAssetID)
+	if assetID == "" {
+		assetID = strings.TrimSpace(resp.Data.AssetID)
+	}
+	if assetID == "" {
+		return nil, fmt.Errorf("upload_file response missing pippit_asset_id")
+	}
+
 	return &UploadFileResult{
-		Scene:    "short-drama",
-		FileID:   "file_mock_" + id,
-		Status:   "uploaded",
-		Uploaded: time.Now().UTC().Format(time.RFC3339),
-		Request:  opts,
+		AssetID: assetID,
 	}, nil
 }
 
-func stableID(key string, n int) string {
-	sum := sha1.Sum([]byte(key))
-	id := hex.EncodeToString(sum[:])
-	if n > len(id) {
-		return id
+func uploadFilePath(runner *Runner) string {
+	if runner != nil && runner.Config != nil && runner.Config.Paths != nil && runner.Config.Paths.UploadFile != "" {
+		return runner.Config.Paths.UploadFile
 	}
-	return id[:n]
+	return config.UploadFilePath
 }

package/package.json

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

package/cmd/version/version.go

@@ -1,21 +0,0 @@
-package versioncmd
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/Pippit-dev/pippit-cli/internal/version"
-	"github.com/spf13/cobra"
-)
-
-func NewCommand(stdout io.Writer) *cobra.Command {
-	return &cobra.Command{
-		Use:   "version",
-		Short: "Print pippit-cli version",
-		Args:  cobra.NoArgs,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			_, err := fmt.Fprintln(stdout, version.Current())
-			return err
-		},
-	}
-}