@pippit-dev/cli 0.0.2 → 0.0.4

package/internal/common/access_key.go

@@ -21,9 +21,11 @@ func (a *accessKeyAuthorizer) Inject(ctx context.Context, req *http.Request) err
 	if err := ctx.Err(); err != nil {
 		return err
 	}
-	if a.accessKey == "" {
+	if a.accessKey == "" && req.Method == http.MethodPost {
 		return fmt.Errorf("%s is required for authenticated requests", config.EnvXYQAccessKey)
 	}
-	req.Header.Set("Authorization", "Bearer "+a.accessKey)
+	if a.accessKey != "" {
+		req.Header.Set("Authorization", "Bearer "+a.accessKey)
+	}
 	return nil
 }

package/internal/common/client.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"reflect"
 	"strings"
 	"time"
 
@@ -40,50 +41,77 @@ func NewHTTPClient(baseURL string, timeout time.Duration, authorizer RequestAuth
 }
 
 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)
+	method := http.MethodPost
+	if body == nil {
+		method = http.MethodGet
 	}
-	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
+		return 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)
+			return fmt.Errorf("encode body: %w", err)
 		}
 		reader = bytes.NewReader(payload)
 	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqURL, reader)
+
+	req, err := http.NewRequestWithContext(ctx, method, reqURL, reader)
 	if err != nil {
-		return nil, fmt.Errorf("build POST request: %w", err)
+		return fmt.Errorf("build %s request: %w", method, err)
 	}
 	if body != nil {
 		req.Header.Set("Content-Type", "application/json")
 	}
-	return req, nil
+
+	if c.authorizer == nil {
+		return fmt.Errorf("authorized request requires authorizer")
+	}
+	if err := c.authorizer.Inject(ctx, req); err != nil {
+		return fmt.Errorf("inject auth headers: %w", err)
+	}
+
+	c.injectHeaders(req)
+
+	// If out is **http.Response, return the raw response for streaming (e.g. file download).
+	if out != nil {
+		if rv := reflect.ValueOf(out); rv.Kind() == reflect.Ptr && rv.Elem().Kind() == reflect.Ptr {
+			if rv.Elem().Type().Elem() == reflect.TypeOf(http.Response{}) {
+				resp, err := c.httpClient.Do(req)
+				if err != nil {
+					return fmt.Errorf("%s %s failed: %w", method, reqURL, err)
+				}
+				if resp.StatusCode >= 400 {
+					defer resp.Body.Close()
+					return fmt.Errorf("%s %s returned HTTP %d", method, reqURL, resp.StatusCode)
+				}
+				rv.Elem().Set(reflect.ValueOf(resp))
+				return nil
+			}
+		}
+	}
+
+	req.Header.Set("Accept", "application/json")
+
+	return c.do(req, out)
 }
 
-func (c *httpClient) do(req *http.Request, out any) error {
+func (c *httpClient) injectHeaders(req *http.Request) {
 	for k, values := range c.headers {
 		for _, v := range values {
 			req.Header.Add(k, v)
 		}
 	}
-	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", "Pippit-CLI/1.0")
+	req.Header.Set("x-use-ppe", "1")
+	req.Header.Set("x-tt-env", "ppe_harness_novel_v2")
+}
 
+func (c *httpClient) do(req *http.Request, out any) error {
 	resp, err := c.httpClient.Do(req)
 	if err != nil {
 		return fmt.Errorf("%s %s failed: %w", req.Method, req.URL.String(), err)

package/internal/common/download_results.go

@@ -15,6 +15,10 @@ import (
 	"time"
 )
 
+// DownloadClient is a minimal interface for downloading files via HTTP GET.
+// It is satisfied by common.Client so that download logic can use the same
+// HTTP infrastructure (headers, auth, timeouts) as API calls.
+
 // DownloadResultOptions is the command-facing shape for downloading one result URL.
 type DownloadResultOptions struct {
 	URL       string `json:"url"`
@@ -51,7 +55,7 @@ type downloadTaskResult struct {
 	err      error
 }
 
-func DownloadResult(ctx context.Context, opts DownloadResultOptions, _ *Runner) (*DownloadResultResponse, error) {
+func DownloadResult(ctx context.Context, opts DownloadResultOptions, runner *Runner) (*DownloadResultResponse, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, err
 	}
@@ -104,7 +108,6 @@ func DownloadResult(ctx context.Context, opts DownloadResultOptions, _ *Runner)
 		workers = len(tasks)
 	}
 
-	client := &http.Client{Timeout: 600 * time.Second}
 	taskCh := make(chan downloadTask)
 	resultCh := make(chan downloadTaskResult, len(tasks))
 
@@ -116,7 +119,7 @@ func DownloadResult(ctx context.Context, opts DownloadResultOptions, _ *Runner)
 			for task := range taskCh {
 				resultCh <- downloadTaskResult{
 					filepath: task.filepath,
-					err:      downloadFileWithRetry(ctx, client, task.url, task.filepath),
+					err:      downloadFileWithRetry(ctx, runner.Client, task.url, task.filepath),
 				}
 			}
 		}()
@@ -167,7 +170,7 @@ func DownloadResult(ctx context.Context, opts DownloadResultOptions, _ *Runner)
 	return result, nil
 }
 
-func downloadFileWithRetry(ctx context.Context, client *http.Client, rawURL string, targetPath string) error {
+func downloadFileWithRetry(ctx context.Context, client Client, rawURL string, targetPath string) error {
 	var lastErr error
 	for attempt := 0; attempt <= maxDownloadRetries; attempt++ {
 		if attempt > 0 {
@@ -203,23 +206,13 @@ func isRetryableError(err error) bool {
 	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 {
+func downloadFile(ctx context.Context, client Client, rawURL string, targetPath string) error {
+	var resp *http.Response
+	if err := client.SendRequest(ctx, rawURL, nil, &resp); 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 {

package/package.json

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

package/scripts/install-wizard.js

@@ -39,11 +39,14 @@ function whichPippitCli() {
 function main() {
   const installed = getGloballyInstalledVersion();
   if (installed) {
-    console.log(`pippit-cli is already installed globally (${installed}).`);
+    console.log(`Updating global pippit-cli (${installed}) via ${PKG}...`);
   } else {
     console.log(`Installing ${PKG} globally...`);
-    run("npm", ["install", "-g", PKG], { timeout: 120000 });
   }
+  run("npm", ["install", "-g", PKG], {
+    timeout: 120000,
+    env: { ...process.env, PIPPIT_CLI_SKIP_SKILLS: "1" },
+  });
 
   console.log("Installing pippit-cli skills...");
   try {