@pippit-dev/cli 0.0.1

package/internal/auth/manager.go

@@ -0,0 +1,146 @@
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"sync"
+	"time"
+
+	"code.byted.org/passport/auth_client/go/authsdk"
+
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+type Authorizer interface {
+	Refresh(ctx context.Context, ensureTTL time.Duration) error
+	Inject(ctx context.Context, req *http.Request) error
+	NewLoginFlow(ctx context.Context) (*LoginFlow, error)
+	CheckLogin(ctx context.Context, deviceCode string) (*State, error)
+	State(ctx context.Context) (*State, error)
+	Logout(ctx context.Context) error
+}
+
+type OAuthManager struct {
+	cfg    *config.Config
+	mu     sync.Mutex
+	client *authsdk.Client
+}
+
+type LoginFlow struct {
+	DeviceCode      string `json:"device_code"`
+	UserCode        string `json:"user_code"`
+	VerificationURI string `json:"verification_uri"`
+}
+
+type State struct {
+	LoggedIn  bool      `json:"logged_in"`
+	ExpiresAt time.Time `json:"expires_at,omitempty"`
+}
+
+func NewManager(cfg *config.Config) *OAuthManager {
+	return &OAuthManager{cfg: cfg}
+}
+
+func (m *OAuthManager) NewLoginFlow(ctx context.Context) (*LoginFlow, error) {
+	client, err := m.clientInstance()
+	if err != nil {
+		return nil, err
+	}
+	flow, err := client.Authenticator().NewLoginFlow(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return &LoginFlow{
+		DeviceCode:      flow.DeviceCode,
+		UserCode:        flow.UserCode,
+		VerificationURI: flow.VerificationURI,
+	}, nil
+}
+
+func (m *OAuthManager) CheckLogin(ctx context.Context, deviceCode string) (*State, error) {
+	client, err := m.clientInstance()
+	if err != nil {
+		return nil, err
+	}
+	state, err := client.Authenticator().CheckLogin(ctx, deviceCode)
+	if err != nil {
+		return nil, err
+	}
+	return authState(state), nil
+}
+
+func (m *OAuthManager) State(ctx context.Context) (*State, error) {
+	client, err := m.clientInstance()
+	if err != nil {
+		return nil, err
+	}
+	state, err := client.Authorizer().State(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return authState(state), nil
+}
+
+func (m *OAuthManager) Refresh(ctx context.Context, ensureTTL time.Duration) error {
+	client, err := m.clientInstance()
+	if err != nil {
+		return err
+	}
+	_, err = client.Authorizer().Refresh(ctx, ensureTTL)
+	return err
+}
+
+func (m *OAuthManager) Inject(ctx context.Context, req *http.Request) error {
+	client, err := m.clientInstance()
+	if err != nil {
+		return err
+	}
+	return client.Authorizer().Inject(ctx, req)
+}
+
+func (m *OAuthManager) Logout(ctx context.Context) error {
+	client, err := m.clientInstance()
+	if err != nil {
+		return err
+	}
+	return client.Authorizer().Logout(ctx)
+}
+
+func IsLoginPending(err error) bool {
+	return errors.Is(err, authsdk.ErrLoginPending)
+}
+
+func (m *OAuthManager) clientInstance() (*authsdk.Client, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.client != nil {
+		return m.client, nil
+	}
+	if m.cfg == nil || m.cfg.OAuth == nil {
+		return nil, errors.New("oauth config is required")
+	}
+	oauth := m.cfg.OAuth
+	client, err := authsdk.NewClient(authsdk.Config{
+		ClientKey:        oauth.ClientKey,
+		BaseURL:          oauth.BaseURL,
+		StoreServiceName: oauth.StoreServiceName,
+		Scopes:           oauth.Scopes,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("initialize oauth client: %w", err)
+	}
+	m.client = client
+	return client, nil
+}
+
+func authState(state *authsdk.AuthStateView) *State {
+	if state == nil {
+		return &State{}
+	}
+	return &State{
+		LoggedIn:  state.LoggedIn,
+		ExpiresAt: state.ExpiresAt,
+	}
+}

package/internal/common/access_key.go

@@ -0,0 +1,29 @@
+package common
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+type accessKeyAuthorizer struct {
+	accessKey string
+}
+
+func NewAccessKeyAuthorizer(accessKey string) RequestAuthorizer {
+	return &accessKeyAuthorizer{accessKey: strings.TrimSpace(accessKey)}
+}
+
+func (a *accessKeyAuthorizer) Inject(ctx context.Context, req *http.Request) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	if a.accessKey == "" {
+		return fmt.Errorf("%s is required for authenticated requests", config.EnvXYQAccessKey)
+	}
+	req.Header.Set("Authorization", "Bearer "+a.accessKey)
+	return nil
+}

package/internal/common/client.go

@@ -0,0 +1,137 @@
+package common
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/bytedance/sonic"
+)
+
+type Client interface {
+	SendRequest(ctx context.Context, path string, body any, out any) error
+}
+
+type RequestAuthorizer interface {
+	Inject(ctx context.Context, req *http.Request) error
+}
+
+type httpClient struct {
+	baseURL    string
+	httpClient *http.Client
+	headers    http.Header
+	authorizer RequestAuthorizer
+}
+
+func NewHTTPClient(baseURL string, timeout time.Duration, authorizer RequestAuthorizer) Client {
+	return &httpClient{
+		baseURL: strings.TrimRight(baseURL, "/"),
+		httpClient: &http.Client{
+			Timeout: timeout,
+		},
+		headers:    make(http.Header),
+		authorizer: authorizer,
+	}
+}
+
+func (c *httpClient) SendRequest(ctx context.Context, path string, body any, out any) error {
+	if c.authorizer == nil {
+		return fmt.Errorf("authorized request requires authorizer")
+	}
+	req, err := c.newJSONRequest(ctx, path, body)
+	if err != nil {
+		return err
+	}
+	if err := c.authorizer.Inject(ctx, req); err != nil {
+		return fmt.Errorf("inject auth headers: %w", err)
+	}
+	return c.do(req, out)
+}
+
+func (c *httpClient) newJSONRequest(ctx context.Context, path string, body any) (*http.Request, error) {
+	reqURL, err := c.resolveURL(path, nil)
+	if err != nil {
+		return nil, err
+	}
+	var reader io.Reader
+	if body != nil {
+		payload, err := sonic.Marshal(body)
+		if err != nil {
+			return nil, fmt.Errorf("encode POST body: %w", err)
+		}
+		reader = bytes.NewReader(payload)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqURL, reader)
+	if err != nil {
+		return nil, fmt.Errorf("build POST request: %w", err)
+	}
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	return req, nil
+}
+
+func (c *httpClient) do(req *http.Request, out any) error {
+	for k, values := range c.headers {
+		for _, v := range values {
+			req.Header.Add(k, v)
+		}
+	}
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("%s %s failed: %w", req.Method, req.URL.String(), err)
+	}
+	defer resp.Body.Close()
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("read response body: %w", err)
+	}
+	if resp.StatusCode >= 400 {
+		msg := strings.TrimSpace(string(data))
+		if msg == "" {
+			msg = http.StatusText(resp.StatusCode)
+		}
+		return fmt.Errorf("%s %s returned HTTP %d: %s", req.Method, req.URL.String(), resp.StatusCode, msg)
+	}
+	if out == nil || len(data) == 0 {
+		return nil
+	}
+	if err := sonic.Unmarshal(data, out); err != nil {
+		return fmt.Errorf("decode response body: %w", err)
+	}
+	return nil
+}
+
+func (c *httpClient) resolveURL(path string, query map[string]string) (string, error) {
+	if strings.HasPrefix(path, "http://") || strings.HasPrefix(path, "https://") {
+		return appendQuery(path, query)
+	}
+	if c.baseURL == "" {
+		return "", fmt.Errorf("base URL is required for relative path %q", path)
+	}
+	if !strings.HasPrefix(path, "/") {
+		path = "/" + path
+	}
+	return appendQuery(c.baseURL+path, query)
+}
+
+func appendQuery(raw string, query map[string]string) (string, error) {
+	u, err := url.Parse(raw)
+	if err != nil {
+		return "", fmt.Errorf("parse URL: %w", err)
+	}
+	values := u.Query()
+	for k, v := range query {
+		values.Set(k, v)
+	}
+	u.RawQuery = values.Encode()
+	return u.String(), nil
+}

package/internal/common/download_results.go

@@ -0,0 +1,243 @@
+package common
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+// DownloadResultOptions is the command-facing shape for downloading one result URL.
+type DownloadResultOptions struct {
+	URL       string `json:"url"`
+	OutputDir string `json:"output_dir"`
+	Workers   int    `json:"workers"`
+}
+
+type DownloadResultError struct {
+	File  string `json:"file"`
+	Error string `json:"error"`
+}
+
+// DownloadResultResponse is the JSON envelope printed by `pippit-cli short-drama +download-result`.
+type DownloadResultResponse struct {
+	OutputDir    string                 `json:"output_dir"`
+	Downloaded   []string               `json:"downloaded"`
+	AlreadyExist []string               `json:"already_exist,omitempty"`
+	Total        int                    `json:"total"`
+	Errors       []*DownloadResultError `json:"errors,omitempty"`
+}
+
+const (
+	maxDownloadRetries = 3
+	retryBaseDelay     = 500 * time.Millisecond
+)
+
+type downloadTask struct {
+	url      string
+	filepath string
+}
+
+type downloadTaskResult struct {
+	filepath string
+	err      error
+}
+
+func DownloadResult(ctx context.Context, opts DownloadResultOptions, _ *Runner) (*DownloadResultResponse, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	rawURL := strings.TrimSpace(opts.URL)
+	if rawURL == "" {
+		return nil, fmt.Errorf("download url is required")
+	}
+
+	outputPath := strings.TrimSpace(opts.OutputDir)
+	if outputPath == "" {
+		return nil, fmt.Errorf("output_dir is required")
+	}
+	// check if the output path exists and is a file
+	if info, err := os.Stat(outputPath); err == nil {
+		if info.IsDir() {
+			return nil, fmt.Errorf("output path %q is a directory", outputPath)
+		}
+		return &DownloadResultResponse{
+			OutputDir:    outputPath,
+			AlreadyExist: []string{outputPath},
+			Total:        0,
+		}, nil
+	} else if !os.IsNotExist(err) {
+		return nil, fmt.Errorf("stat output path: %w", err)
+	}
+	outputDir := filepath.Dir(outputPath)
+	if err := os.MkdirAll(outputDir, 0o755); err != nil {
+		return nil, fmt.Errorf("create output dir: %w", err)
+	}
+
+	parsed, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, fmt.Errorf("invalid url %q: %w", rawURL, err)
+	}
+	if parsed.Scheme != "http" && parsed.Scheme != "https" {
+		return nil, fmt.Errorf("invalid url scheme %q in %q, only http and https are allowed", parsed.Scheme, rawURL)
+	}
+	tasks := []downloadTask{
+		{
+			url:      rawURL,
+			filepath: outputPath,
+		},
+	}
+
+	workers := opts.Workers
+	if workers <= 0 {
+		workers = 5
+	}
+	if workers > len(tasks) {
+		workers = len(tasks)
+	}
+
+	client := &http.Client{Timeout: 600 * time.Second}
+	taskCh := make(chan downloadTask)
+	resultCh := make(chan downloadTaskResult, len(tasks))
+
+	var wg sync.WaitGroup
+	for i := 0; i < workers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for task := range taskCh {
+				resultCh <- downloadTaskResult{
+					filepath: task.filepath,
+					err:      downloadFileWithRetry(ctx, client, task.url, task.filepath),
+				}
+			}
+		}()
+	}
+
+	go func() {
+		defer close(taskCh)
+		for _, task := range tasks {
+			select {
+			case <-ctx.Done():
+				return
+			case taskCh <- task:
+			}
+		}
+	}()
+
+	go func() {
+		wg.Wait()
+		close(resultCh)
+	}()
+
+	downloaded := make([]string, 0, len(tasks))
+	errorList := make([]*DownloadResultError, 0)
+	for result := range resultCh {
+		if result.err != nil {
+			errorList = append(errorList, &DownloadResultError{
+				File:  result.filepath,
+				Error: result.err.Error(),
+			})
+			continue
+		}
+		downloaded = append(downloaded, result.filepath)
+	}
+	sort.Strings(downloaded)
+	sort.Slice(errorList, func(i, j int) bool {
+		return errorList[i].File < errorList[j].File
+	})
+
+	result := &DownloadResultResponse{
+		OutputDir:  outputPath,
+		Downloaded: downloaded,
+		Total:      len(downloaded),
+		Errors:     errorList,
+	}
+	if len(downloaded) == 0 && len(errorList) > 0 {
+		return result, fmt.Errorf("all %d download(s) failed", len(errorList))
+	}
+	return result, nil
+}
+
+func downloadFileWithRetry(ctx context.Context, client *http.Client, rawURL string, targetPath string) error {
+	var lastErr error
+	for attempt := 0; attempt <= maxDownloadRetries; attempt++ {
+		if attempt > 0 {
+			delay := retryBaseDelay * time.Duration(1<<(attempt-1))
+			timer := time.NewTimer(delay)
+			select {
+			case <-ctx.Done():
+				timer.Stop()
+				return ctx.Err()
+			case <-timer.C:
+			}
+		}
+		err := downloadFile(ctx, client, rawURL, targetPath)
+		if err == nil {
+			return nil
+		}
+		lastErr = err
+		if !isRetryableError(err) {
+			return err
+		}
+	}
+	return fmt.Errorf("failed after %d retries: %w", maxDownloadRetries, lastErr)
+}
+
+func isRetryableError(err error) bool {
+	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+		return false
+	}
+	var urlErr *url.Error
+	if errors.As(err, &urlErr) {
+		return urlErr.Timeout() || urlErr.Temporary()
+	}
+	return false
+}
+
+func downloadFile(ctx context.Context, client *http.Client, rawURL string, targetPath string) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
+	if err != nil {
+		return fmt.Errorf("build download request: %w", err)
+	}
+	req.Header.Set("User-Agent", "Pippit-CLI/1.0")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("HTTP %d: %s", resp.StatusCode, http.StatusText(resp.StatusCode))
+	}
+
+	tmpPath := targetPath + ".tmp"
+	out, err := os.Create(tmpPath)
+	if err != nil {
+		return fmt.Errorf("create temp file: %w", err)
+	}
+	_, copyErr := io.Copy(out, resp.Body)
+	closeErr := out.Close()
+	if copyErr != nil {
+		_ = os.Remove(tmpPath)
+		return fmt.Errorf("write temp file: %w", copyErr)
+	}
+	if closeErr != nil {
+		_ = os.Remove(tmpPath)
+		return fmt.Errorf("close temp file: %w", closeErr)
+	}
+	if err := os.Rename(tmpPath, targetPath); err != nil {
+		_ = os.Remove(tmpPath)
+		return fmt.Errorf("replace target file: %w", err)
+	}
+	return nil
+}

package/internal/common/list_thread_file.go

@@ -0,0 +1,104 @@
+package common
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+// ListThreadFileOptions is the command-facing request shape for listing thread files.
+type ListThreadFileOptions struct {
+	ThreadID string `json:"thread_id"`
+	PageSize int    `json:"page_size,omitempty"`
+	PageNum  int    `json:"page_num,omitempty"`
+}
+
+// ThreadFile is a file entry in a thread.
+type ThreadFile struct {
+	FilePath    string `json:"file_path"`
+	DownloadURL string `json:"download_url"`
+}
+
+// ListThreadFileResult is the JSON envelope printed by `pippit-cli short-drama +list-thread-file`.
+type ListThreadFileResult struct {
+	Files []*ThreadFile `json:"files"`
+	Total int64         `json:"total"`
+}
+
+type listThreadFileResponse struct {
+	Ret     string `json:"ret"`
+	Errmsg  string `json:"errmsg"`
+	SvrTime int64  `json:"svr_time"`
+	LogID   string `json:"log_id"`
+	Data    struct {
+		Files []*threadFileResponse `json:"files"`
+		Total int64                 `json:"total"`
+	} `json:"data"`
+}
+
+type threadFileResponse struct {
+	FilePath    string `json:"file_path"`
+	DownloadURL string `json:"download_url"`
+}
+
+func ListThreadFile(ctx context.Context, opts *ListThreadFileOptions, runner *Runner) (*ListThreadFileResult, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("list_thread_file runner client is required")
+	}
+
+	body := map[string]any{
+		"thread_id": opts.ThreadID,
+	}
+	if opts.PageSize > 0 {
+		body["page_size"] = opts.PageSize
+	}
+	if opts.PageNum > 0 {
+		body["page_num"] = opts.PageNum
+	}
+
+	var resp listThreadFileResponse
+	if err := runner.Client.SendRequest(ctx, listThreadFilePath(runner), body, &resp); err != nil {
+		return nil, fmt.Errorf("list_thread_file request failed: %w", err)
+	}
+	if resp.Ret != "0" {
+		if resp.Errmsg == "" {
+			resp.Errmsg = "unknown error"
+		}
+		return nil, fmt.Errorf("list_thread_file failed: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+	}
+
+	files := make([]*ThreadFile, 0, len(resp.Data.Files))
+	for _, file := range resp.Data.Files {
+		if file == nil {
+			continue
+		}
+		files = append(files, &ThreadFile{
+			FilePath:    threadFilePath(opts.ThreadID, file.FilePath),
+			DownloadURL: file.DownloadURL,
+		})
+	}
+
+	return &ListThreadFileResult{
+		Files: files,
+		Total: resp.Data.Total,
+	}, nil
+}
+
+func threadFilePath(threadID string, filePath string) string {
+	parts := []string{strings.TrimSpace(threadID)}
+	trimmedFilePath := strings.Trim(strings.TrimSpace(filePath), `/\`)
+	if trimmedFilePath != "" {
+		parts = append(parts, trimmedFilePath)
+	}
+	return "." + string(filepath.Separator) + filepath.Join(parts...)
+}
+
+func listThreadFilePath(runner *Runner) string {
+	if runner != nil && runner.Config != nil && runner.Config.Paths != nil && runner.Config.Paths.ListThreadFile != "" {
+		return runner.Config.Paths.ListThreadFile
+	}
+	return config.ListThreadFilePath
+}

package/internal/common/runner.go

@@ -0,0 +1,21 @@
+package common
+
+import (
+	"github.com/Pippit-dev/pippit-cli/internal/auth"
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+// Runner carries runtime dependencies for command execution.
+type Runner struct {
+	Config         *config.Config
+	Client         Client
+	AuthAuthorizer auth.Authorizer
+}
+
+func NewRunner(cfg *config.Config, client Client, authAuthorizer auth.Authorizer) *Runner {
+	return &Runner{
+		Config:         cfg,
+		Client:         client,
+		AuthAuthorizer: authAuthorizer,
+	}
+}