@pippit-dev/cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pippit-dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# pippit-cli
+
+Minimal demo CLI for Pippit workflows.
+
+## Short Drama Run Demo
+
+Install from npm after the package is published. The installer downloads the
+matching prebuilt binary for macOS, Linux, or Windows:
+
+```bash
+npx @pippit-dev/cli@latest install
+export XYQ_ACCESS_KEY="<access-key>"
+pippit-cli short-drama +submit-run --message "写一个赛博朋克短剧开头"
+pippit-cli short-drama +upload-file --path ./story.md
+pippit-cli short-drama +get-thread --thread-id thread_123 --run-id run_456 --after-seq 0
+pippit-cli short-drama +download-result --output-dir ./thread_123/results/result.mp4 --url URL
+```
+
+NPM package names must be lowercase, so the publishable package name is
+`@pippit-dev/cli` rather than `@Pippit-dev/cli`.
+
+Submit a Run task for the short drama scene:
+
+```bash
+export XYQ_ACCESS_KEY="<access-key>"
+go run . short-drama +submit-run --message "写一个赛博朋克短剧开头"
+go run . short-drama +upload-file --path ./story.md
+go run . short-drama +get-thread --thread-id thread_123 --run-id run_456 --after-seq 0
+go run . short-drama +download-result --output-dir ./thread_123/results/result.mp4 --url URL
+```
+
+`+submit-run` calls `/api/biz/v1/skill/submit_run` and prints `thread_id`,
+`run_id`, and `web_thread_link`; `--message` is required.
+`+get-thread` calls
+`/api/biz/v1/skill/get_thread` and prints extracted `messages`.
+`+download-result` downloads the result URL to
+the `--output-dir` file path. `+upload-file` is still mocked while
+its real service contract is wired.
+
+## HTTP Client
+
+Command modules should receive `common.Runner` for service calls. Runtime
+settings such as base URL, HTTP timeout, and API paths are loaded by
+`internal/config` and paired with `common.Client` in the runner.
+
+## Auth
+
+`short-drama +submit-run` and `short-drama +get-thread` authenticate with
+`Authorization: Bearer <XYQ_ACCESS_KEY>`. OAuth command code remains available,
+but runtime short drama requests do not use it.

package/cmd/auth/auth.go

@@ -0,0 +1,144 @@
+package authcmd
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"time"
+
+	"github.com/Pippit-dev/pippit-cli/internal/auth"
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/bytedance/sonic"
+	"github.com/spf13/cobra"
+)
+
+type checkResult struct {
+	Pending bool `json:"pending"`
+	State   any  `json:"state,omitempty"`
+}
+
+func NewCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "auth",
+		Short: "Manage Pippit OAuth login state",
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.AddCommand(newLoginCommand(stdout, stderr, runner))
+	cmd.AddCommand(newCheckCommand(stdout, stderr, runner))
+	cmd.AddCommand(newStatusCommand(stdout, stderr, runner))
+	cmd.AddCommand(newLogoutCommand(stdout, stderr, runner))
+	return cmd
+}
+
+func newLoginCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "login",
+		Short: "Start an OAuth device login flow",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			if runner == nil || runner.AuthAuthorizer == nil {
+				return fmt.Errorf("auth manager is required")
+			}
+			flow, err := runner.AuthAuthorizer.NewLoginFlow(cmd.Context())
+			if err != nil {
+				return err
+			}
+			return writeJSON(stdout, flow)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	return cmd
+}
+
+func newCheckCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	var deviceCode string
+	cmd := &cobra.Command{
+		Use:   "check",
+		Short: "Check whether an OAuth device login has completed",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			deviceCode = strings.TrimSpace(deviceCode)
+			if deviceCode == "" {
+				return fmt.Errorf("--device-code is required")
+			}
+			if runner == nil || runner.AuthAuthorizer == nil {
+				return fmt.Errorf("auth manager is required")
+			}
+			state, err := runner.AuthAuthorizer.CheckLogin(cmd.Context(), deviceCode)
+			if auth.IsLoginPending(err) {
+				return writeJSON(stdout, checkResult{Pending: true})
+			}
+			if err != nil {
+				return err
+			}
+			v := map[string]any{
+				"logged_in":  state.LoggedIn,
+				"expires_at": state.ExpiresAt.Format(time.RFC3339),
+			}
+			return writeJSON(stdout, checkResult{State: v})
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.Flags().StringVar(&deviceCode, "device-code", "", "device code returned by auth login")
+	return cmd
+}
+
+func newStatusCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "status",
+		Short: "Show current OAuth login state",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			if runner == nil || runner.AuthAuthorizer == nil {
+				return fmt.Errorf("auth manager is required")
+			}
+			state, err := runner.AuthAuthorizer.State(cmd.Context())
+			if err != nil {
+				return err
+			}
+			if !state.LoggedIn {
+				return fmt.Errorf("not logged in")
+			}
+			v := map[string]any{
+				"logged_in":  state.LoggedIn,
+				"expires_at": state.ExpiresAt.Format(time.RFC3339),
+			}
+			return writeJSON(stdout, v)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	return cmd
+}
+
+func newLogoutCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "logout",
+		Short: "Clear local OAuth login state",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			if runner == nil || runner.AuthAuthorizer == nil {
+				return fmt.Errorf("auth manager is required")
+			}
+			if err := runner.AuthAuthorizer.Logout(cmd.Context()); err != nil {
+				return err
+			}
+			return writeJSON(stdout, map[string]bool{"logged_out": true})
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	return cmd
+}
+
+func writeJSON(w io.Writer, v any) error {
+	data, err := sonic.Marshal(v)
+	if err != nil {
+		return err
+	}
+	_, err = fmt.Fprintln(w, string(data))
+	return err
+}

package/cmd/root.go

@@ -0,0 +1,42 @@
+package cmd
+
+import (
+	"io"
+	"os"
+
+	// 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"
+	"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/spf13/cobra"
+)
+
+// Execute runs the pippit-cli command tree.
+func Execute() error {
+	return NewRootCommand(os.Stdout, os.Stderr).Execute()
+}
+
+func NewRootCommand(stdout, stderr io.Writer) *cobra.Command {
+	cfg := config.Load()
+	authManager := auth.NewManager(cfg)
+	client := common.NewHTTPClient(cfg.BaseURL, cfg.HTTPTimeout, common.NewAccessKeyAuthorizer(cfg.AccessKey))
+	runner := common.NewRunner(cfg, client, authManager)
+	return newRootCommand(stdout, stderr, runner)
+}
+
+func newRootCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	root := &cobra.Command{
+		Use:           "pippit-cli",
+		Short:         "Pippit CLI",
+		SilenceUsage:  true,
+		SilenceErrors: true,
+	}
+	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))
+	return root
+}

package/cmd/short_drama/short_drama.go

@@ -0,0 +1,196 @@
+package short_drama
+
+import (
+	"fmt"
+	"io"
+	"path/filepath"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/Pippit-dev/pippit-cli/internal/short_drama"
+	"github.com/bytedance/sonic"
+	"github.com/spf13/cobra"
+)
+
+// NewCommand builds the short_drama scene command tree.
+func NewCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "short-drama",
+		Short: "Short drama generation workflows",
+	}
+
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.AddCommand(newShortDramaSubmitRunCommand(stdout, stderr, runner))
+	cmd.AddCommand(newShortDramaUploadFileCommand(stdout, stderr, runner))
+	cmd.AddCommand(newShortDramaDownloadResultCommand(stdout, stderr, runner))
+	cmd.AddCommand(newShortDramaGetThreadCommand(stdout, stderr, runner))
+	cmd.AddCommand(newShortDramaListThreadFileCommand(stdout, stderr, runner))
+	return cmd
+}
+
+func newShortDramaSubmitRunCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	var opts short_drama.SubmitRunOptions
+
+	cmd := &cobra.Command{
+		Use:   "+submit-run",
+		Short: "Submit a Run task for the short drama scene",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			opts.Message = strings.TrimSpace(opts.Message)
+			opts.ThreadID = strings.TrimSpace(opts.ThreadID)
+
+			if opts.Message == "" {
+				return fmt.Errorf("--message is required")
+			}
+
+			result, err := short_drama.SubmitRun(cmd.Context(), &opts, runner)
+			if err != nil {
+				return err
+			}
+			return writeJSON(stdout, result)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.Flags().StringVar(&opts.Message, "message", "", "message to send to the short drama agent")
+	cmd.Flags().StringVar(&opts.ThreadID, "thread-id", "", "existing thread ID; omit to create a new thread")
+	cmd.Flags().StringArrayVar(&opts.AssetIDs, "asset-ids", nil, "asset ID to attach; repeat for multiple assets")
+	return cmd
+}
+
+func newShortDramaUploadFileCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	var opts common.UploadFileOptions
+
+	cmd := &cobra.Command{
+		Use:   "+upload-file",
+		Short: "Upload a file for the short drama scene",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			opts.Path = strings.TrimSpace(opts.Path)
+
+			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 {
+				return err
+			}
+			return writeJSON(stdout, result)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.Flags().StringVar(&opts.Path, "path", "", "local file path to upload")
+	return cmd
+}
+
+func newShortDramaDownloadResultCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	var opts common.DownloadResultOptions
+
+	cmd := &cobra.Command{
+		Use:   "+download-result",
+		Short: "Download a generated result URL",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			opts.OutputDir = strings.TrimSpace(opts.OutputDir)
+			if opts.OutputDir == "" {
+				return fmt.Errorf("--output-dir is required")
+			}
+			opts.URL = strings.TrimSpace(opts.URL)
+			if opts.URL == "" {
+				return fmt.Errorf("--url is required")
+			}
+			if opts.Workers <= 0 {
+				return fmt.Errorf("--workers must be greater than 0")
+			}
+
+			result, err := common.DownloadResult(cmd.Context(), opts, runner)
+			if err != nil {
+				return err
+			}
+			return writeJSON(stdout, result)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.Flags().StringVar(&opts.URL, "url", "", "URL to download")
+	cmd.Flags().StringVar(&opts.OutputDir, "output-dir", "", "output file path")
+	cmd.Flags().IntVar(&opts.Workers, "workers", 5, "parallel download workers")
+	return cmd
+}
+
+func newShortDramaGetThreadCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	var opts short_drama.GetThreadOptions
+
+	cmd := &cobra.Command{
+		Use:   "+get-thread",
+		Short: "Get a short drama thread detail",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			opts.ThreadID = strings.TrimSpace(opts.ThreadID)
+			if opts.ThreadID == "" {
+				return fmt.Errorf("--thread-id is required")
+			}
+			opts.RunID = strings.TrimSpace(opts.RunID)
+
+			result, err := short_drama.GetThread(cmd.Context(), &opts, runner)
+			if err != nil {
+				return err
+			}
+			return writeJSON(stdout, result)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.Flags().StringVar(&opts.ThreadID, "thread-id", "", "thread ID to fetch")
+	cmd.Flags().StringVar(&opts.RunID, "run-id", "", "run ID to fetch")
+	cmd.Flags().IntVar(&opts.AfterSeq, "after-seq", 0, "return messages whose sequence is greater than or equal to this value")
+	return cmd
+}
+
+func newShortDramaListThreadFileCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	var opts common.ListThreadFileOptions
+
+	cmd := &cobra.Command{
+		Use:   "+list-thread-file",
+		Short: "List files in a short drama thread",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			opts.ThreadID = strings.TrimSpace(opts.ThreadID)
+			if opts.ThreadID == "" {
+				return fmt.Errorf("--thread-id is required")
+			}
+			if opts.PageSize <= 0 || opts.PageSize > 100 {
+				return fmt.Errorf("--page-size must be between 1 and 100")
+			}
+			if opts.PageNum <= 0 {
+				return fmt.Errorf("--page-num must be greater than 0")
+			}
+
+			result, err := common.ListThreadFile(cmd.Context(), &opts, runner)
+			if err != nil {
+				return err
+			}
+			return writeJSON(stdout, result)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.Flags().StringVar(&opts.ThreadID, "thread-id", "", "thread ID to list files for")
+	cmd.Flags().IntVar(&opts.PageNum, "page-num", 1, "page number (1-based)")
+	cmd.Flags().IntVar(&opts.PageSize, "page-size", 100, "number of files per page (between 1 and 100)")
+	return cmd
+}
+
+func writeJSON(w io.Writer, v any) error {
+	data, err := sonic.Marshal(v)
+	if err != nil {
+		return err
+	}
+	_, err = fmt.Fprintln(w, string(data))
+	return err
+}