Merge branch 'main' into mason/pool-column-browsers-list

Author: masnwilliams

AGENTS.md

@@ -0,0 +1,28 @@
+# Kernel CLI
+
+## Cursor Cloud specific instructions
+
+This is a Go CLI application (no long-running services). Development commands are in the `Makefile`:
+
+- **Build:** `make build` → produces `./bin/kernel`
+- **Test:** `make test` → runs `go vet` + `go test ./...`
+- **Lint:** `make lint` → runs `golangci-lint run` (requires `golangci-lint` on `PATH`)
+
+### Testing against production
+
+When `KERNEL_API_KEY` is set (provided as a secret), the CLI hits the **production** Kernel API. After `make build`, test with `./bin/kernel`. Useful smoke-test sequence:
+
+1. `./bin/kernel auth status` — verify auth
+2. `./bin/kernel app list` — list deployed apps
+3. `./bin/kernel browsers create` — create a browser session (remember to delete it after)
+4. `./bin/kernel browsers delete <session_id>` — clean up
+
+Be mindful that these operations affect production resources.
+
+### Gotchas
+
+- `golangci-lint` is installed via `go install` to `$(go env GOPATH)/bin`. This directory must be on `PATH` (the update script handles this via `.bashrc`).
+- The Makefile's `lint` target uses `|| true`, so it always exits 0 even when lint issues exist. Pre-existing lint warnings (errcheck, staticcheck) are present in the codebase and expected.
+- The `go-keyring` dependency requires D-Bus and `libsecret` on Linux. These are pre-installed in the Cloud VM.
+- `kernel create` works locally without authentication. Most other commands (`deploy`, `invoke`, `browsers`, etc.) require a `KERNEL_API_KEY` env var or `kernel login` OAuth flow.
+- Go module path is `github.com/kernel/cli`. The project requires Go 1.25.0 (specified in `go.mod`).

cmd/proxies/check.go

@@ -40,6 +40,7 @@ func (p ProxyCmd) Check(ctx context.Context, in ProxyCheckInput) error {
 	}
 	rows = append(rows, []string{"Name", name})
 	rows = append(rows, []string{"Type", string(proxy.Type)})
+	rows = append(rows, []string{"Bypass Hosts", formatBypassHosts(proxy.BypassHosts)})
 
 	// Display protocol (default to https if not set)
 	protocol := string(proxy.Protocol)

cmd/proxies/check_test.go

@@ -0,0 +1,36 @@
+package proxies
+
+import (
+	"context"
+	"testing"
+
+	"github.com/kernel/kernel-go-sdk"
+	"github.com/kernel/kernel-go-sdk/option"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestProxyCheck_ShowsBypassHosts(t *testing.T) {
+	buf := captureOutput(t)
+
+	fake := &FakeProxyService{
+		CheckFunc: func(ctx context.Context, id string, opts ...option.RequestOption) (*kernel.ProxyCheckResponse, error) {
+			return &kernel.ProxyCheckResponse{
+				ID:          id,
+				Name:        "Proxy 1",
+				Type:        kernel.ProxyCheckResponseTypeDatacenter,
+				BypassHosts: []string{"localhost", "internal.service.local"},
+				Status:      kernel.ProxyCheckResponseStatusAvailable,
+			}, nil
+		},
+	}
+
+	p := ProxyCmd{proxies: fake}
+	err := p.Check(context.Background(), ProxyCheckInput{ID: "proxy-1"})
+
+	assert.NoError(t, err)
+	output := buf.String()
+	assert.Contains(t, output, "Bypass Hosts")
+	assert.Contains(t, output, "localhost")
+	assert.Contains(t, output, "internal.service.local")
+	assert.Contains(t, output, "Proxy health check passed")
+}

cmd/proxies/create.go

@@ -3,6 +3,7 @@ package proxies
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/kernel/cli/pkg/table"
 	"github.com/kernel/cli/pkg/util"
@@ -40,6 +41,9 @@ func (p ProxyCmd) Create(ctx context.Context, in ProxyCreateInput) error {
 	if in.Name != "" {
 		params.Name = kernel.Opt(in.Name)
 	}
+	if len(in.BypassHosts) > 0 {
+		params.BypassHosts = normalizeBypassHosts(in.BypassHosts)
+	}
 
 	// Build config based on type
 	switch proxyType {
@@ -189,6 +193,7 @@ func (p ProxyCmd) Create(ctx context.Context, in ProxyCreateInput) error {
 	}
 	rows = append(rows, []string{"Name", name})
 	rows = append(rows, []string{"Type", string(proxy.Type)})
+	rows = append(rows, []string{"Bypass Hosts", formatBypassHosts(proxy.BypassHosts)})
 
 	// Display protocol (default to https if not set)
 	protocol := string(proxy.Protocol)
@@ -219,26 +224,40 @@ func runProxiesCreate(cmd *cobra.Command, args []string) error {
 	port, _ := cmd.Flags().GetInt("port")
 	username, _ := cmd.Flags().GetString("username")
 	password, _ := cmd.Flags().GetString("password")
+	bypassHosts, _ := cmd.Flags().GetStringSlice("bypass-host")
 
 	output, _ := cmd.Flags().GetString("output")
 
 	svc := client.Proxies
 	p := ProxyCmd{proxies: &svc}
 	return p.Create(cmd.Context(), ProxyCreateInput{
-		Name:     name,
-		Type:     proxyType,
-		Protocol: protocol,
-		Country:  country,
-		City:     city,
-		State:    state,
-		Zip:      zip,
-		ASN:      asn,
-		OS:       os,
-		Carrier:  carrier,
-		Host:     host,
-		Port:     port,
-		Username: username,
-		Password: password,
-		Output:   output,
+		Name:        name,
+		Type:        proxyType,
+		Protocol:    protocol,
+		BypassHosts: bypassHosts,
+		Country:     country,
+		City:        city,
+		State:       state,
+		Zip:         zip,
+		ASN:         asn,
+		OS:          os,
+		Carrier:     carrier,
+		Host:        host,
+		Port:        port,
+		Username:    username,
+		Password:    password,
+		Output:      output,
 	})
 }
+
+func normalizeBypassHosts(hosts []string) []string {
+	normalized := make([]string, 0, len(hosts))
+	for _, host := range hosts {
+		trimmed := strings.TrimSpace(host)
+		if trimmed != "" {
+			normalized = append(normalized, trimmed)
+		}
+	}
+
+	return normalized
+}

cmd/proxies/create_test.go

@@ -18,25 +18,28 @@ func TestProxyCreate_Datacenter_Success(t *testing.T) {
 			// Verify the request
 			assert.Equal(t, kernel.ProxyNewParamsTypeDatacenter, body.Type)
 			assert.Equal(t, "My DC Proxy", body.Name.Value)
+			assert.Equal(t, []string{"localhost", "internal.service.local"}, body.BypassHosts)
 
 			// Check config
 			dcConfig := body.Config.OfProxyNewsConfigDatacenterProxyConfig
 			assert.NotNil(t, dcConfig)
 			assert.Equal(t, "US", dcConfig.Country.Value)
 
 			return &kernel.ProxyNewResponse{
-				ID:   "dc-new",
-				Name: "My DC Proxy",
-				Type: kernel.ProxyNewResponseTypeDatacenter,
+				ID:          "dc-new",
+				Name:        "My DC Proxy",
+				Type:        kernel.ProxyNewResponseTypeDatacenter,
+				BypassHosts: []string{"localhost", "internal.service.local"},
 			}, nil
 		},
 	}
 
 	p := ProxyCmd{proxies: fake}
 	err := p.Create(context.Background(), ProxyCreateInput{
-		Name:    "My DC Proxy",
-		Type:    "datacenter",
-		Country: "US",
+		Name:        "My DC Proxy",
+		Type:        "datacenter",
+		Country:     "US",
+		BypassHosts: []string{"localhost", "internal.service.local"},
 	})
 
 	assert.NoError(t, err)
@@ -46,6 +49,9 @@ func TestProxyCreate_Datacenter_Success(t *testing.T) {
 	assert.Contains(t, output, "Successfully created proxy")
 	assert.Contains(t, output, "dc-new")
 	assert.Contains(t, output, "My DC Proxy")
+	assert.Contains(t, output, "Bypass Hosts")
+	assert.Contains(t, output, "localhost")
+	assert.Contains(t, output, "internal.service.local")
 }
 
 func TestProxyCreate_Datacenter_WithoutCountry(t *testing.T) {
@@ -306,6 +312,27 @@ func TestProxyCreate_Protocol_Invalid(t *testing.T) {
 	assert.Contains(t, err.Error(), "invalid protocol: ftp")
 }
 
+func TestProxyCreate_BypassHosts_Normalized(t *testing.T) {
+	fake := &FakeProxyService{
+		NewFunc: func(ctx context.Context, body kernel.ProxyNewParams, opts ...option.RequestOption) (*kernel.ProxyNewResponse, error) {
+			assert.Equal(t, []string{"localhost", "internal.service.local"}, body.BypassHosts)
+			return &kernel.ProxyNewResponse{
+				ID:   "test-proxy",
+				Type: kernel.ProxyNewResponseTypeDatacenter,
+			}, nil
+		},
+	}
+
+	p := ProxyCmd{proxies: fake}
+	err := p.Create(context.Background(), ProxyCreateInput{
+		Type:        "datacenter",
+		Country:     "US",
+		BypassHosts: []string{" localhost ", "", "internal.service.local"},
+	})
+
+	assert.NoError(t, err)
+}
+
 func TestProxyCreate_APIError(t *testing.T) {
 	_ = captureOutput(t)
 

cmd/proxies/format.go

@@ -0,0 +1,11 @@
+package proxies
+
+import "strings"
+
+func formatBypassHosts(hosts []string) string {
+	if len(hosts) == 0 {
+		return "-"
+	}
+
+	return strings.Join(hosts, ", ")
+}

cmd/proxies/get.go

@@ -36,6 +36,7 @@ func (p ProxyCmd) Get(ctx context.Context, in ProxyGetInput) error {
 	}
 	rows = append(rows, []string{"Name", name})
 	rows = append(rows, []string{"Type", string(item.Type)})
+	rows = append(rows, []string{"Bypass Hosts", formatBypassHosts(item.BypassHosts)})
 
 	// Display protocol (default to https if not set)
 	protocol := string(item.Protocol)

cmd/proxies/get_test.go

@@ -17,9 +17,10 @@ func TestProxyGet_Datacenter(t *testing.T) {
 	fake := &FakeProxyService{
 		GetFunc: func(ctx context.Context, id string, opts ...option.RequestOption) (*kernel.ProxyGetResponse, error) {
 			return &kernel.ProxyGetResponse{
-				ID:   "dc-1",
-				Name: "US Datacenter",
-				Type: kernel.ProxyGetResponseTypeDatacenter,
+				ID:          "dc-1",
+				Name:        "US Datacenter",
+				Type:        kernel.ProxyGetResponseTypeDatacenter,
+				BypassHosts: []string{"localhost", "internal.service.local"},
 				Config: kernel.ProxyGetResponseConfigUnion{
 					Country: "US",
 				},
@@ -40,6 +41,9 @@ func TestProxyGet_Datacenter(t *testing.T) {
 	assert.Contains(t, output, "US Datacenter")
 	assert.Contains(t, output, "Type")
 	assert.Contains(t, output, "datacenter")
+	assert.Contains(t, output, "Bypass Hosts")
+	assert.Contains(t, output, "localhost")
+	assert.Contains(t, output, "internal.service.local")
 	assert.Contains(t, output, "Country")
 	assert.Contains(t, output, "US")
 }

cmd/proxies/list.go

@@ -41,7 +41,7 @@ func (p ProxyCmd) List(ctx context.Context, in ProxyListInput) error {
 
 	// Prepare table data
 	tableData := pterm.TableData{
-		{"ID", "Name", "Type", "Protocol", "Config", "Status", "Last Checked"},
+		{"ID", "Name", "Type", "Protocol", "Bypass Hosts", "Config", "Status", "Last Checked"},
 	}
 
 	for _, proxy := range *items {
@@ -77,6 +77,7 @@ func (p ProxyCmd) List(ctx context.Context, in ProxyListInput) error {
 			name,
 			string(proxy.Type),
 			protocol,
+			formatBypassHosts(proxy.BypassHosts),
 			configStr,
 			status,
 			lastChecked,

cmd/proxies/list_test.go

@@ -34,9 +34,10 @@ func TestProxyList_WithProxies(t *testing.T) {
 		createResidentialProxy("res-1", "SF Residential", "US", "sanfrancisco", "CA"),
 		createCustomProxy("custom-1", "My Proxy", "proxy.example.com", 8080),
 		{
-			ID:   "mobile-1",
-			Name: "Mobile Proxy",
-			Type: kernel.ProxyListResponseTypeMobile,
+			ID:          "mobile-1",
+			Name:        "Mobile Proxy",
+			Type:        kernel.ProxyListResponseTypeMobile,
+			BypassHosts: []string{"abc"},
 			Config: kernel.ProxyListResponseConfigUnion{
 				Country: "US",
 				Carrier: "verizon",
@@ -85,6 +86,7 @@ func TestProxyList_WithProxies(t *testing.T) {
 
 	assert.Contains(t, output, "mobile-1")
 	assert.Contains(t, output, "mobile")
+	assert.Contains(t, output, "abc")
 
 	assert.Contains(t, output, "isp-1")
 	assert.Contains(t, output, "-") // Empty name shows as "-"