@pippit-dev/cli 1.0.1 → 1.0.3

package/internal/generate_video/query_result.go

@@ -0,0 +1,344 @@
+package generate_video
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
+
+const (
+	successRunState = 3
+	failedRunState  = 4
+)
+
+// QueryResultOptions is the command-facing request shape for query-result.
+type QueryResultOptions struct {
+	ThreadID    string
+	RunID       string
+	DownloadDir string
+}
+
+// QueryResultResult describes the user-facing query-result outcome.
+type QueryResultResult struct {
+	Completed    bool               `json:"completed"`
+	ThreadID     string             `json:"thread_id"`
+	RunID        string             `json:"run_id"`
+	ErrorMessage string             `json:"error_message"`
+	Videos       []QueryResultVideo `json:"videos"`
+}
+
+// QueryResultVideo describes a downloaded video from query-result.
+type QueryResultVideo struct {
+	DownloadURL string `json:"download_url"`
+	OutputPath  string `json:"output_path"`
+}
+
+type queryThread struct {
+	ThreadID string     `json:"thread_id"`
+	RunList  []queryRun `json:"run_list"`
+}
+
+type queryRun struct {
+	RunID        string       `json:"run_id"`
+	State        int          `json:"state"`
+	ErrorMessage string       `json:"error_message"`
+	ErrorMsg     string       `json:"error_msg"`
+	Errmsg       string       `json:"errmsg"`
+	EntryList    []queryEntry `json:"entry_list"`
+}
+
+type queryEntry struct {
+	Artifact queryArtifact `json:"artifact"`
+}
+
+type queryArtifact struct {
+	Content []queryContent `json:"content"`
+}
+
+type queryContent struct {
+	SubType string           `json:"sub_type"`
+	Data    queryContentData `json:"data"`
+}
+
+type queryContentData struct {
+	Video        *queryVideo     `json:"video"`
+	ErrorMessage string          `json:"error_message"`
+	ErrorCode    json.RawMessage `json:"error_code"`
+}
+
+type queryVideo struct {
+	DownloadURL string `json:"download_url"`
+	Title       string `json:"title"`
+	VID         string `json:"vid"`
+	AssetID     string `json:"asset_id"`
+}
+
+func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.Runner) (*QueryResultResult, error) {
+	if err := validateQueryResultOptions(opts); err != nil {
+		return nil, err
+	}
+
+	threadResult, err := common.GetThread(ctx, &common.GetThreadOptions{
+		ThreadID: opts.ThreadID,
+		RunID:    opts.RunID,
+	}, runner)
+	if err != nil {
+		return nil, fmt.Errorf("查询失败：%w", err)
+	}
+
+	thread, err := parseQueryThread(threadResult)
+	if err != nil {
+		return nil, fmt.Errorf("查询失败：%w", err)
+	}
+
+	run, ok := findQueryRun(thread, opts.RunID)
+	if !ok {
+		return nil, fmt.Errorf("查询失败：未找到 run_id=%s 对应的 Run", opts.RunID)
+	}
+	if run.State != successRunState {
+		result := &QueryResultResult{
+			Completed: run.State == failedRunState,
+			ThreadID:  firstNonEmpty(thread.ThreadID, opts.ThreadID),
+			RunID:     opts.RunID,
+			Videos:    []QueryResultVideo{},
+		}
+		if run.State == failedRunState {
+			result.ErrorMessage = firstNonEmpty(extractQueryErrorMessage(run), "Run 失败")
+		}
+		return result, nil
+	}
+
+	videos := extractQueryVideos(run)
+	if len(videos) == 0 {
+		return nil, fmt.Errorf("下载失败：未找到可下载的视频产物")
+	}
+
+	downloadDir, err := expandPath(opts.DownloadDir)
+	if err != nil {
+		return nil, fmt.Errorf("下载失败：解析下载目录失败：%w", err)
+	}
+
+	resultVideos := make([]QueryResultVideo, 0, len(videos))
+	usedNames := make(map[string]int, len(videos))
+	for i, video := range videos {
+		if strings.TrimSpace(video.DownloadURL) == "" {
+			return nil, fmt.Errorf("下载失败：第 %d 个视频产物 download_url 为空", i+1)
+		}
+		outputPath := filepath.Join(downloadDir, uniqueQueryResultFileName(videoFileName(video, i+1), usedNames))
+		download, err := common.DownloadResult(ctx, common.DownloadResultOptions{
+			URL:        video.DownloadURL,
+			OutputPath: outputPath,
+			Workers:    5,
+		}, runner)
+		if err != nil {
+			return nil, fmt.Errorf("下载失败：%w", err)
+		}
+		actualOutputPath := outputPath
+		if len(download.Downloaded) > 0 {
+			actualOutputPath = download.Downloaded[0]
+		} else if len(download.AlreadyExist) > 0 {
+			actualOutputPath = download.AlreadyExist[0]
+		}
+		resultVideos = append(resultVideos, QueryResultVideo{
+			DownloadURL: video.DownloadURL,
+			OutputPath:  actualOutputPath,
+		})
+	}
+
+	return &QueryResultResult{
+		Completed: true,
+		ThreadID:  firstNonEmpty(thread.ThreadID, opts.ThreadID),
+		RunID:     opts.RunID,
+		Videos:    resultVideos,
+	}, nil
+}
+
+func validateQueryResultOptions(opts *QueryResultOptions) error {
+	if opts == nil {
+		return fmt.Errorf("查询失败：缺少必填参数 --thread-id")
+	}
+	opts.ThreadID = strings.TrimSpace(opts.ThreadID)
+	opts.RunID = strings.TrimSpace(opts.RunID)
+	opts.DownloadDir = strings.TrimSpace(opts.DownloadDir)
+	if opts.ThreadID == "" {
+		return fmt.Errorf("查询失败：缺少必填参数 --thread-id")
+	}
+	if opts.RunID == "" {
+		return fmt.Errorf("查询失败：缺少必填参数 --run-id")
+	}
+	if opts.DownloadDir == "" {
+		return fmt.Errorf("查询失败：缺少必填参数 --download-dir")
+	}
+	return nil
+}
+
+func parseQueryThread(result *common.GetThreadResult) (*queryThread, error) {
+	if result == nil {
+		return nil, fmt.Errorf("get_thread 响应为空")
+	}
+	if len(result.RawData) > 0 {
+		var data map[string]json.RawMessage
+		if err := json.Unmarshal(result.RawData, &data); err == nil {
+			if raw := data["thread"]; len(raw) > 0 {
+				if thread, ok := decodeQueryThread(raw); ok {
+					return thread, nil
+				}
+			}
+		}
+	}
+	return nil, fmt.Errorf("get_thread 响应中未找到 data.thread")
+}
+
+func decodeQueryThread(raw []byte) (*queryThread, bool) {
+	var thread queryThread
+	if err := json.Unmarshal(raw, &thread); err != nil {
+		return nil, false
+	}
+	if thread.ThreadID == "" && len(thread.RunList) == 0 {
+		return nil, false
+	}
+	return &thread, true
+}
+
+func findQueryRun(thread *queryThread, runID string) (queryRun, bool) {
+	for _, run := range thread.RunList {
+		if run.RunID == runID {
+			return run, true
+		}
+	}
+	return queryRun{}, false
+}
+
+func (data *queryContentData) UnmarshalJSON(raw []byte) error {
+	raw = []byte(strings.TrimSpace(string(raw)))
+	if len(raw) == 0 || string(raw) == "null" {
+		return nil
+	}
+	if raw[0] == '"' {
+		var encoded string
+		if err := json.Unmarshal(raw, &encoded); err != nil {
+			return err
+		}
+		encoded = strings.TrimSpace(encoded)
+		if encoded == "" {
+			return nil
+		}
+		raw = []byte(encoded)
+	}
+	if len(raw) == 0 || raw[0] != '{' {
+		return nil
+	}
+	type alias queryContentData
+	return json.Unmarshal(raw, (*alias)(data))
+}
+
+func extractQueryVideos(run queryRun) []queryVideo {
+	videos := make([]queryVideo, 0)
+	for _, entry := range run.EntryList {
+		artifact := entry.Artifact
+		for _, content := range artifact.Content {
+			if content.SubType != "biz/x_data_video" {
+				continue
+			}
+			data := content.Data
+			if data.Video != nil {
+				videos = append(videos, *data.Video)
+			}
+		}
+	}
+	return videos
+}
+
+func extractQueryErrorMessage(run queryRun) string {
+	if message := firstNonEmpty(run.ErrorMessage, run.ErrorMsg, run.Errmsg); message != "" {
+		return message
+	}
+	for _, entry := range run.EntryList {
+		for _, content := range entry.Artifact.Content {
+			data := content.Data
+			if message := firstNonEmpty(data.ErrorMessage); message != "" {
+				if code := rawMessageString(data.ErrorCode); code != "" {
+					return fmt.Sprintf("%s (error_code=%s)", message, code)
+				}
+				return message
+			}
+			if code := rawMessageString(data.ErrorCode); code != "" {
+				return "error_code=" + code
+			}
+		}
+	}
+	return ""
+}
+
+func rawMessageString(raw json.RawMessage) string {
+	raw = json.RawMessage(strings.TrimSpace(string(raw)))
+	if len(raw) == 0 || string(raw) == "null" {
+		return ""
+	}
+	var value string
+	if err := json.Unmarshal(raw, &value); err == nil {
+		return strings.TrimSpace(value)
+	}
+	return strings.TrimSpace(string(raw))
+}
+
+func videoFileName(video queryVideo, index int) string {
+	name := firstNonEmpty(video.VID, video.Title, video.AssetID)
+	if name == "" {
+		name = "result_" + strconv.Itoa(index)
+	}
+	name = sanitizeFileName(name)
+	if !hasVideoExtension(name) {
+		name += ".mp4"
+	}
+	return name
+}
+
+func hasVideoExtension(name string) bool {
+	switch strings.ToLower(strings.TrimSpace(filepath.Ext(name))) {
+	case ".mp4", ".mov", ".m4v", ".webm":
+		return true
+	default:
+		return false
+	}
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		value = strings.TrimSpace(value)
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func sanitizeFileName(name string) string {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		return "result.mp4"
+	}
+	return strings.Map(func(r rune) rune {
+		if unicode.IsControl(r) || r == '/' || r == '\\' || strings.ContainsRune(`<>:"|?*`, r) {
+			return '_'
+		}
+		return r
+	}, name)
+}
+
+func uniqueQueryResultFileName(name string, used map[string]int) string {
+	count := used[name] + 1
+	used[name] = count
+	if count == 1 {
+		return name
+	}
+	ext := filepath.Ext(name)
+	base := strings.TrimSuffix(name, ext)
+	return fmt.Sprintf("%s-%d%s", base, count, ext)
+}

package/internal/generate_video/query_result_test.go

@@ -0,0 +1,31 @@
+package generate_video
+
+import "testing"
+
+func TestVideoFileNameUsesVIDBeforeTimestampTitle(t *testing.T) {
+	got := videoFileName(queryVideo{
+		Title: "v03c76g10004d8jp38iljhtepa11k25g_2026-06-09T120814.516",
+		VID:   "v03c76g10004d8jp38iljhtepa11k25g",
+	}, 1)
+	want := "v03c76g10004d8jp38iljhtepa11k25g.mp4"
+	if got != want {
+		t.Fatalf("videoFileName() = %q, want %q", got, want)
+	}
+}
+
+func TestVideoFileNameAddsMP4ForTimestampTitleWithoutVID(t *testing.T) {
+	got := videoFileName(queryVideo{
+		Title: "v03c76g10004d8jp38iljhtepa11k25g_2026-06-09T120814.516",
+	}, 1)
+	want := "v03c76g10004d8jp38iljhtepa11k25g_2026-06-09T120814.516.mp4"
+	if got != want {
+		t.Fatalf("videoFileName() = %q, want %q", got, want)
+	}
+}
+
+func TestVideoFileNameKeepsVideoExtension(t *testing.T) {
+	got := videoFileName(queryVideo{Title: "cat_video.mp4"}, 1)
+	if got != "cat_video.mp4" {
+		t.Fatalf("videoFileName() = %q, want cat_video.mp4", got)
+	}
+}

package/internal/short_drama/submit_run.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 
 	"github.com/Pippit-dev/pippit-cli/internal/common"
-	"github.com/Pippit-dev/pippit-cli/internal/config"
 )
 
 // SubmitRunOptions is the stable command-facing request shape for short drama run submission.
@@ -22,21 +21,9 @@ type SubmitRunResult struct {
 	WebThreadLink string `json:"web_thread_link"`
 }
 
-type submitRunResponse struct {
-	Ret    string `json:"ret"`
-	Errmsg string `json:"errmsg"`
-	Data   struct {
-		WebThreadLink string `json:"web_thread_link"`
-		Run           struct {
-			ThreadID string `json:"thread_id"`
-			RunID    string `json:"run_id"`
-		} `json:"run"`
-	} `json:"data"`
-}
-
 func SubmitRun(ctx context.Context, opts *SubmitRunOptions, runner *common.Runner) (*SubmitRunResult, error) {
 	if runner == nil || runner.Client == nil {
-		return nil, fmt.Errorf("submit_run runner client is required")
+		return nil, fmt.Errorf("submit_run 运行器客户端缺失")
 	}
 
 	body := map[string]any{
@@ -50,21 +37,21 @@ func SubmitRun(ctx context.Context, opts *SubmitRunOptions, runner *common.Runne
 	}
 	body["agent_name"] = "pippit_nest_novel_agent"
 
-	var resp submitRunResponse
-	if err := runner.Client.SendRequest(ctx, submitRunPath(runner), body, &resp); err != nil {
-		return nil, fmt.Errorf("submit_run request failed: %w", err)
+	var resp common.SubmitRunResponse
+	if err := runner.Client.SendRequest(ctx, common.SubmitRunPath(runner), body, &resp); err != nil {
+		return nil, fmt.Errorf("提交 short_drama 请求失败: %w", err)
 	}
 	if resp.Ret != "0" {
 		if resp.Errmsg == "" {
-			resp.Errmsg = "unknown error"
+			resp.Errmsg = "未知错误"
 		}
-		return nil, fmt.Errorf("submit_run failed: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+		return nil, fmt.Errorf("short_drama 请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
 	}
 	if resp.Data.Run.ThreadID == "" {
-		return nil, fmt.Errorf("submit_run response missing data.run.thread_id")
+		return nil, fmt.Errorf("short_drama 响应缺少 data.run.thread_id")
 	}
 	if resp.Data.Run.RunID == "" {
-		return nil, fmt.Errorf("submit_run response missing data.run.run_id")
+		return nil, fmt.Errorf("short_drama 响应缺少 data.run.run_id")
 	}
 	return &SubmitRunResult{
 		ThreadID:      resp.Data.Run.ThreadID,
@@ -72,10 +59,3 @@ func SubmitRun(ctx context.Context, opts *SubmitRunOptions, runner *common.Runne
 		WebThreadLink: resp.Data.WebThreadLink,
 	}, nil
 }
-
-func submitRunPath(runner *common.Runner) string {
-	if runner != nil && runner.Config != nil && runner.Config.Paths != nil && runner.Config.Paths.SubmitRun != "" {
-		return runner.Config.Paths.SubmitRun
-	}
-	return config.SubmitRunPath
-}

package/package.json

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

package/skills/short-drama/SKILL.md

@@ -101,10 +101,10 @@ pippit-tool-cli get-thread --thread-id THREAD_ID --run-id RUN_ID
 
 ### 3. 上传文件
 
-当用户提供短剧大纲、人物设定、世界观设定、已有分集或剧本等本地参考文件时，可先上传文件。`upload-file` 当前只接收本地文件路径，并且只支持 `.doc`、`.docx` 和 `.txt` 后缀；不要把 `.md`、`.pdf`、图片、视频或 URL 传给该命令。
+当用户提供短剧大纲、人物设定、世界观设定、已有分集或剧本等本地参考文件时，可先上传文件。`+upload-file` 当前只接收本地文件路径，并且只支持 `.doc`、`.docx` 和 `.txt` 后缀；不要把 `.md`、`.pdf`、图片、视频或 URL 传给该命令。
 
 ```bash
-pippit-tool-cli upload-file --path /path/to/outline.txt
+pippit-tool-cli short-drama +upload-file --path /path/to/outline.txt
 ```
 
 上传成功后命令只返回 `asset_id`：
@@ -179,7 +179,7 @@ pippit-tool-cli download-result --url DOWNLOAD_URL --output-path FILE_PATH --upd
 
 ```
 1. 检查用户提供的是一个本地 `.doc`、`.docx` 或 `.txt` 剧本文件路径；如果不是，告知当前上传命令只支持这三类文件，不要擅自转换或改写文件。
-2. pippit-tool-cli upload-file --path /path/to/file.txt
+2. pippit-tool-cli short-drama +upload-file --path /path/to/file.txt
    → 拿到 asset_id
 3. pippit-tool-cli short-drama +submit-run --message "用户的原始短剧需求" --asset-ids asset_id
    → 拿到 thread_id、run_id 和 web_thread_link
@@ -242,7 +242,7 @@ Thread: thread_...
        [assistant] ...
 ```
 
-**upload-file** 返回：
+**short-drama +upload-file** 返回：
 
 ```json
 {
@@ -250,7 +250,7 @@ Thread: thread_...
 }
 ```
 
-`upload-file` 通过 `multipart/form-data` 上传文件，表单文件字段名为 `file`。本地文件必须存在、不能是目录，后缀必须是 `.doc`、`.docx` 或 `.txt`；不支持的后缀会直接报错。返回的 `asset_id` 来自服务端 `pippit_asset_id`，如果没有该字段才回退到 `asset_id`。
+`+upload-file` 通过 `multipart/form-data` 上传文件，表单文件字段名为 `file`。本地文件必须存在、不能是目录，后缀必须是 `.doc`、`.docx` 或 `.txt`；不支持的后缀会直接报错。返回的 `asset_id` 来自服务端 `pippit_asset_id`，如果没有该字段才回退到 `asset_id`。
 
 **list-thread-file** 返回：
 
@@ -323,7 +323,7 @@ Thread: thread_...
 
 你要做的只有三件事：
 
-1. **上传**：如果用户给了本地 `.doc` / `.docx` / `.txt` 参考文件，先调用 `upload-file`。
+1. **上传**：如果用户给了本地 `.doc` / `.docx` / `.txt` 参考文件，先调用 `+upload-file`。
 2. **提交任务**：首次创作时把用户原始短剧需求和唯一剧本 `asset_id` 通过 `+submit-run --asset-ids` 发给后端；同一 `thread_id` 后续续写或修改不再追加新的剧本文件。
 3. **传话、取文件、下载资源**：根据 `get-thread` 返回的 `readable_text` 展示进展、问题和结果；遇到表单、问卷、选项或按钮时，只做流程合理性清洗，不替用户决定创作内容；根据 `list-thread-file` 获取文件列表；再根据 `download_url` 调用 `download-result` 把缺失资源下载到用户本地。
 
@@ -341,8 +341,8 @@ Thread: thread_...
 - `--message` 是用户的原始短剧需求，不能为空。
 - 查询进展时优先使用 `+submit-run` 返回的 `thread_id` 和 `run_id`；如果需要查看整个会话，可以省略 `--run-id`。
 - `get-thread` 当前固定走服务端 v2 响应，输出字段是 `readable_text`；不要解析旧版 `messages` 数组。
-- `upload-file` 当前用于短剧场景文件上传链路，只支持本地 `.doc` / `.docx` / `.txt` 文件；`--path` 不能为空，路径必须指向真实文件，不能是目录。
-- `upload-file` 上传成功后只返回 `asset_id`；把该值原样作为 `+submit-run --asset-ids` 的参数。
+- `+upload-file` 当前用于短剧场景文件上传链路，只支持本地 `.doc` / `.docx` / `.txt` 文件；`--path` 不能为空，路径必须指向真实文件，不能是目录。
+- `+upload-file` 上传成功后只返回 `asset_id`；把该值原样作为 `+submit-run --asset-ids` 的参数。
 - 单次创作会话中（相同 `thread_id`），`+submit-run` 只支持绑定一个剧本文件。不要在同一 `thread_id` 下重复上传并追加第二个剧本 `asset_id`；用户给多个剧本时，先让用户选择一个，或分别开启新的创作会话。
 - `list-thread-file` 只需要 `thread_id`；分页参数使用 `--page-num 1 --page-size 200` 起步，`total` 达到 200 时下一轮递增 `page-num`。
 - `list-thread-file` 和 `download-result` 是两个不同的 CLI 指令：前者获取会话文件元信息，后者下载 URL 资源并写入到本地目标文件路径。

package/skills/xyq-nest-skill/scripts/download_results.py

@@ -11,6 +11,8 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 
 sys.path.insert(0, os.path.dirname(__file__))
 
+HTTP_TIMEOUT_SECONDS = 30 * 60
+
 
 def download_file(url, filepath):
     """下载单个文件"""
@@ -18,7 +20,7 @@ def download_file(url, filepath):
     req = urllib.request.Request(url, headers={"User-Agent": "XYQ-Nest-Skill/1.0"})
     tmp_path = filepath + ".tmp"
     try:
-        with urllib.request.urlopen(req, timeout=600) as resp:
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT_SECONDS) as resp:
             with open(tmp_path, "wb") as f:
                 shutil.copyfileobj(resp, f, length=1024 * 1024)
         os.replace(tmp_path, filepath)

package/skills/xyq-nest-skill/scripts/upload_file.py

@@ -11,7 +11,7 @@ import urllib.request
 import urllib.error
 
 sys.path.insert(0, os.path.dirname(__file__))
-from xyq_common import XYQ_BASE, ACCESS_KEY, UPLOAD_FILE_PATH, parse_response
+from xyq_common import XYQ_BASE, ACCESS_KEY, UPLOAD_FILE_PATH, HTTP_TIMEOUT_SECONDS, parse_response
 
 # 允许的 MIME 类型前缀
 ALLOWED_PREFIXES = ("image/", "video/")
@@ -70,7 +70,7 @@ def upload_file(file_path: str) -> dict:
         },
     )
     try:
-        with urllib.request.urlopen(req, timeout=120) as resp:
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT_SECONDS) as resp:
             result = json.loads(resp.read().decode("utf-8"))
             return parse_response(result)
     except urllib.error.HTTPError as e:

package/skills/xyq-nest-skill/scripts/xyq_common.py

@@ -13,6 +13,7 @@ ACCESS_KEY = os.environ.get("XYQ_ACCESS_KEY", "")
 SUBMIT_RUN_PATH = "/api/biz/v1/skill/submit_run"
 GET_THREAD_PATH = "/api/biz/v1/skill/get_thread"
 UPLOAD_FILE_PATH = "/api/biz/v1/skill/upload_file"
+HTTP_TIMEOUT_SECONDS = 30 * 60
 
 if not ACCESS_KEY:
     print("错误：请设置 XYQ_ACCESS_KEY 环境变量", file=sys.stderr)
@@ -22,7 +23,7 @@ if not ACCESS_KEY:
 def _headers():
     return {
         "Authorization": f"Bearer {ACCESS_KEY}",
-        "Content-Type": "application/json"
+        "Content-Type": "application/json",
     }
 
 
@@ -37,7 +38,7 @@ def api_post(path: str, body: dict) -> dict:
         headers=_headers(),
     )
     try:
-        with urllib.request.urlopen(req, timeout=30) as resp:
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT_SECONDS) as resp:
             return json.loads(resp.read().decode("utf-8"))
     except urllib.error.HTTPError as e:
         err_body = e.read().decode("utf-8") if e.fp else ""
@@ -53,7 +54,7 @@ def api_get(path: str) -> dict:
     url = f"{XYQ_BASE.rstrip('/')}{path}"
     req = urllib.request.Request(url, method="GET", headers=_headers())
     try:
-        with urllib.request.urlopen(req, timeout=30) as resp:
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT_SECONDS) as resp:
             return json.loads(resp.read().decode("utf-8"))
     except urllib.error.HTTPError as e:
         err_body = e.read().decode("utf-8") if e.fp else ""

package/cmd/upload_file.go

@@ -1,50 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"path/filepath"
-	"strings"
-
-	"github.com/Pippit-dev/pippit-cli/internal/common"
-	"github.com/spf13/cobra"
-)
-
-func newUploadFileCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
-	var opts common.UploadFileOptions
-
-	cmd := &cobra.Command{
-		Use:   "upload-file",
-		Short: "Upload a file",
-		Args:  cobra.NoArgs,
-		RunE: withErrorLog("upload-file", func() map[string]string {
-			return map[string]string{
-				"file_name": fileNameForLog(opts.Path),
-			}
-		}, func(cmd *cobra.Command, _ []string) error {
-			opts.Path = strings.TrimSpace(opts.Path)
-
-			if opts.Path == "" {
-				return fmt.Errorf("--path is required")
-			}
-
-			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 fileNameForLog(path string) string {
-	path = strings.TrimSpace(path)
-	if path == "" {
-		return ""
-	}
-	return filepath.Base(path)
-}