Skip to content

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.go
index 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.go
index c007eed7..38949044 100644
--- a/cmd/pinchtab/cmd_cli_runtime_test.go
+++ b/cmd/pinchtab/cmd_cli_runtime_test.go
@@ -1,9 +1,12 @@
package main
import (
+ "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.go
index 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.go
index 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.go
index 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.Reader
if 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.go
index 58917206..cba1195f 100644
--- a/internal/cli/apiclient/transport_test.go
+++ b/internal/cli/apiclient/transport_test.go
@@ -3,10 +3,12 @@ package apiclient
import (
"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)
+ }
+ })
+ }
+}