High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
fix: a scheme-less or malformed --server / PINCHTAB_SERVER crashes every CLI command with a nil-pointer panic, because doRequest discards http.NewRequest's error (and json.Marshal's, sending an empty body) (PIN-374)
Luigi Agostid0b8f135ac60
diff --git a/cmd/pinchtab/cmd_cli_runtime.go b/cmd/pinchtab/cmd_cli_runtime.goindex c0bb499e..3518daa1 100644--- a/cmd/pinchtab/cmd_cli_runtime.go+++ b/cmd/pinchtab/cmd_cli_runtime.go@@ -126,7 +126,12 @@ func newCLIHTTPClient(agentID string) *http.Client {func resolveCLIBase(cfg *config.RuntimeConfig) string {defaultBase := resolveDefaultCLIBase(cfg)- resolved := resolveBaseURL(defaultBase)+ resolved, err := resolveBaseURL(defaultBase)+ if err != nil {+ fmt.Fprintf(os.Stderr, "pinchtab: %v\n", err)+ osExit(2)+ return ""+ }if resolved == defaultBase {if serverURL != "" {output.Advisory("--server " + resolved + " is the default and can be omitted")@@ -156,24 +161,31 @@ func resolveDefaultCLIBase(cfg *config.RuntimeConfig) string {// machine; the probe simply learns less.var resolveTabStateEndpoint = func() (base, token string) {cfg := config.Load()- base = resolveBaseURL(resolveDefaultCLIBase(cfg))- token, err := resolveCLIToken(cfg, base)+ base, err := resolveBaseURL(resolveDefaultCLIBase(cfg))+ if err != nil {+ return "", ""+ }+ token, err = resolveCLIToken(cfg, base)if err != nil {return base, ""}return base, token}-// resolveBaseURL returns the server base URL from flag/env/default.-// Shared by both the full CLI runtime path and the lightweight tab probe.-func resolveBaseURL(defaultBase string) string {- if serverURL != "" {- return strings.TrimRight(serverURL, "/")+func resolveBaseURL(defaultBase string) (string, error) {+ source, value := "--server", serverURL+ if value == "" {+ source, value = "PINCHTAB_SERVER", os.Getenv("PINCHTAB_SERVER")}- if u := os.Getenv("PINCHTAB_SERVER"); u != "" {- return strings.TrimRight(u, "/")+ if value == "" {+ return defaultBase, nil+ }+ base := strings.TrimRight(value, "/")+ u, err := url.Parse(base)+ if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {+ return "", fmt.Errorf("%s must be an absolute http(s) URL, e.g. http://127.0.0.1:9867: got %q", source, value)}- return defaultBase+ return base, nil}func canAutoStartServerForCLI(cfg *config.RuntimeConfig, baseURL string) bool {diff --git a/cmd/pinchtab/cmd_cli_runtime_test.go b/cmd/pinchtab/cmd_cli_runtime_test.goindex c007eed7..38949044 100644--- a/cmd/pinchtab/cmd_cli_runtime_test.go+++ b/cmd/pinchtab/cmd_cli_runtime_test.go@@ -1,9 +1,12 @@package mainimport (+ "bytes"+ "errors""io""net/http""os"+ "os/exec""path/filepath""strings""testing"@@ -250,3 +253,72 @@ type roundTripFunc func(*http.Request) (*http.Response, error)func (fn roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {return fn(req)}++func TestAnInvalidServerBaseExitsTwoNamingItsSource(t *testing.T) {+ if args := os.Getenv("PINCHTAB_BAD_BASE_ARGS"); args != "" {+ rootCmd.SetArgs(strings.Split(args, "\x1f"))+ if err := rootCmd.Execute(); err != nil {+ os.Exit(commandExitCode(err))+ }+ return+ }++ for _, tc := range []struct {+ name, env, source, value string+ args []string+ }{+ {"env without a scheme", "127.0.0.1:9867", "PINCHTAB_SERVER", "127.0.0.1:9867", []string{"tab"}},+ {"env host read as a scheme", "localhost:9867", "PINCHTAB_SERVER", "localhost:9867", []string{"tab"}},+ {"flag with a space in the host", "", "--server", "http://bad host:9867", []string{"--server", "http://bad host:9867", "tab"}},+ } {+ t.Run(tc.name, func(t *testing.T) {+ child := exec.Command(os.Args[0], "-test.run=^TestAnInvalidServerBaseExitsTwoNamingItsSource$", "-test.timeout=30s") // #nosec G204 -- re-executes this test binary with fixed arguments.+ child.Env = append(os.Environ(),+ "PINCHTAB_BAD_BASE_ARGS="+strings.Join(tc.args, "\x1f"),+ "PINCHTAB_SERVER="+tc.env,+ "PINCHTAB_TOKEN=x",+ "HOME="+t.TempDir(),+ "XDG_STATE_HOME="+t.TempDir(),+ )+ var stderr bytes.Buffer+ child.Stderr = &stderr+ err := child.Run()++ var exitErr *exec.ExitError+ if !errors.As(err, &exitErr) || exitErr.ExitCode() != 2 {+ t.Fatalf("exit = %v, want 2; stderr:\n%s", err, stderr.String())+ }+ out := stderr.String()+ if strings.Contains(out, "panic:") {+ t.Fatalf("the CLI panicked:\n%s", out)+ }+ if !strings.Contains(out, tc.source) || !strings.Contains(out, `"`+tc.value+`"`) {+ t.Fatalf("stderr does not name %s and %q:\n%s", tc.source, tc.value, out)+ }+ })+ }+}++func TestValidServerBasesStillResolve(t *testing.T) {+ oldServerURL := serverURL+ t.Cleanup(func() { serverURL = oldServerURL })+ for value, want := range map[string]string{+ "http://127.0.0.1:9867": "http://127.0.0.1:9867",+ "https://host": "https://host",+ "http://127.0.0.1:9867/": "http://127.0.0.1:9867",+ } {+ for _, viaFlag := range []bool{true, false} {+ serverURL = ""+ t.Setenv("PINCHTAB_SERVER", "")+ if viaFlag {+ serverURL = value+ } else {+ t.Setenv("PINCHTAB_SERVER", value)+ }+ got, err := resolveBaseURL("http://127.0.0.1:9999")+ if err != nil || got != want {+ t.Errorf("%q (flag=%v) resolved to %q, %v; want %q", value, viaFlag, got, err, want)+ }+ }+ }+}diff --git a/cmd/pinchtab/tab_state.go b/cmd/pinchtab/tab_state.goindex 2c970b9d..1d6ddb68 100644--- a/cmd/pinchtab/tab_state.go+++ b/cmd/pinchtab/tab_state.go@@ -32,6 +32,9 @@ func (tabStateStore) useLocal() bool {if strings.TrimSpace(os.Getenv("PINCHTAB_SESSION")) != "" {return false}+ if base, _ := resolveTabStateEndpoint(); base == "" {+ return false+ }return resolveCLIAgentID() == ""}diff --git a/cmd/pinchtab/tab_state_test.go b/cmd/pinchtab/tab_state_test.goindex 483cefed..f8a06b35 100644--- a/cmd/pinchtab/tab_state_test.go+++ b/cmd/pinchtab/tab_state_test.go@@ -264,3 +264,27 @@ func TestAnExplicitTabIsNotAnnouncedAsCached(t *testing.T) {t.Errorf("announced %q when --tab was set explicitly", got)}}++func TestAnInvalidServerBaseLeavesTheTabStateInconclusiveWithoutExiting(t *testing.T) {+ oldServerURL := serverURL+ serverURL = ""+ t.Cleanup(func() { serverURL = oldServerURL })+ t.Setenv("PINCHTAB_SERVER", "127.0.0.1:9867")+ t.Setenv("PINCHTAB_SESSION", "")+ t.Setenv("PINCHTAB_AGENT_ID", "")+ t.Setenv("XDG_STATE_HOME", t.TempDir())+ oldExit := osExit+ osExit = func(code int) { t.Fatalf("the tab-state helpers exited with %d on an invalid base", code) }+ t.Cleanup(func() { osExit = oldExit })++ if got := defaultTabState.probe("tab1"); got != tabProbeInconclusive {+ t.Fatalf("probe = %v, want inconclusive", got)+ }+ if defaultTabState.useLocal() {+ t.Fatal("an invalid base must mean no cached-tab state")+ }+ if got := defaultTabState.resolveArg(nil); got != "" {+ t.Fatalf("resolveArg = %q, want no cached tab", got)+ }+ defaultTabState.announceCachedTab("tab1")+}diff --git a/internal/cli/apiclient/transport.go b/internal/cli/apiclient/transport.goindex aa1be074..a6ae8f03 100644--- a/internal/cli/apiclient/transport.go+++ b/internal/cli/apiclient/transport.go@@ -38,10 +38,16 @@ func buildURL(base, path string, params url.Values) string {func doRequest(client *http.Client, token string, r request) (int, []byte, error) {var bodyReader io.Readerif r.body != nil {- data, _ := json.Marshal(r.body)+ data, err := json.Marshal(r.body)+ if err != nil {+ return 0, nil, fmt.Errorf("encode request body for %s: %w", r.url, err)+ }bodyReader = bytes.NewReader(data)}- req, _ := http.NewRequest(r.method, r.url, bodyReader)+ req, err := http.NewRequest(r.method, r.url, bodyReader)+ if err != nil {+ return 0, nil, fmt.Errorf("build request: %w", err)+ }if r.body != nil {req.Header.Set("Content-Type", "application/json")}diff --git a/internal/cli/apiclient/transport_test.go b/internal/cli/apiclient/transport_test.goindex 58917206..cba1195f 100644--- a/internal/cli/apiclient/transport_test.go+++ b/internal/cli/apiclient/transport_test.go@@ -3,10 +3,12 @@ package apiclientimport ("fmt""io"+ "math""net""net/http""net/http/httptest""strings"+ "sync/atomic""testing")@@ -64,3 +66,31 @@ func TestACompleteResponseIsStillReturnedWhole(t *testing.T) {t.Errorf("code %d body %q, want 200 and the whole body", code, string(body))}}++func TestAnUnbuildableRequestFailsBeforeTheWire(t *testing.T) {+ var arrived atomic.Int32+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ arrived.Add(1)+ }))+ defer srv.Close()++ for name, call := range map[string]func() error{+ "malformed base": func() error {+ _, err := DoPostRawE(srv.Client(), "http://bad host:9867", "", "/action", map[string]any{"kind": "click"})+ return err+ },+ "unencodable body": func() error {+ _, err := DoPostRawE(srv.Client(), srv.URL, "", "/geolocation", map[string]any{"latitude": math.NaN(), "longitude": 0.0})+ return err+ },+ } {+ t.Run(name, func(t *testing.T) {+ if err := call(); err == nil {+ t.Fatal("the call succeeded; it must refuse a request it could not build")+ }+ if got := arrived.Load(); got != 0 {+ t.Fatalf("%d request(s) reached the server", got)+ }+ })+ }+}