browsers + acquire: support session name and tags

Surface the new Kernel API name/tags fields in the CLI, modeled on the
profiles command and the hypeman CLI tag convention.

browsers:
- create: --name and repeatable --tag KEY=VALUE (parsed with a hypeman-style
  parser that warns on malformed pairs); forwarded to BrowserNewParams.
- get/view/update/delete now accept <id-or-name> (SDK resolves either); name
  and tags are shown in the get detail table, the JSON output, and a new Name
  column in list.
- list: --tag KEY=VALUE filter (deepObject, ANDed) and --query now also
  matches name.
- create --pool-id/--pool-name: --name/--tag now apply to the acquired lease.
- Note: name/tags are creation-time only. get/list and JSON responses echo
  them, but update cannot change them (the SDK BrowserUpdateParams has no
  name/tags), so update offers no such flags.

browser-pools acquire: --name and --tag apply per-lease (cleared on release),
forwarded to BrowserPoolAcquireParams and shown in the acquired-session table.

The per-lease acquire params (name/tags/timeout) are built by a single shared
buildAcquireParams helper used by both `browser-pools acquire` and the
`browsers create --pool-*` path, so the two cannot silently diverge.

Adds parseKeyValueSpecs/tagsFromFlag/formatTags helpers and tests for create,
list, get (incl. JSON output), acquire, pool-list limit/offset forwarding, the
buildAcquireParams forwarding contract, the parser, and the malformed-tag
warning path. README is updated for the new browser and acquire flags.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: bmsaadat

README.md

@@ -205,25 +205,29 @@ Commands with JSON output support:
 ### Browser Management
 
 - `kernel browsers list` - List running browsers
+  - `--query <q>` - Search by name, session ID, profile ID, proxy ID, or pool name
+  - `--tag <KEY=VALUE>` - Filter by tag, repeatable; a session must match every pair
   - `--output json`, `-o json` - Output raw JSON array
 - `kernel browsers create` - Create a new browser session
   - `-s, --stealth` - Launch browser in stealth mode to avoid detection
   - `-H, --headless` - Launch browser without GUI access
   - `--kiosk` - Launch browser in kiosk mode
   - `--start-url <url>` - Initial page to open on launch
-  - `--pool-id <id>` - Acquire a browser from the specified pool (mutually exclusive with --pool-name; ignores other session flags)
+  - `--name <name>` - Optional unique name for the session (set at creation; used to find it later by name)
+  - `--tag <KEY=VALUE>` - Set a tag on the session, repeatable; up to 50 pairs
+  - `--pool-id <id>` - Acquire a browser from the specified pool (mutually exclusive with --pool-name; ignores other session flags). `--name`/`--tag` still apply to the acquired session.
   - `--pool-name <name>` - Acquire a browser from the pool name (mutually exclusive with --pool-id; ignores other session flags)
   - `--telemetry=all` - Enable telemetry for all categories
   - `--telemetry=off` - Disable telemetry
   - `--telemetry=<list>` - Per-category config, e.g. `--telemetry=network=on,page=off`
   - `--output json`, `-o json` - Output raw JSON object
   - _Note: When a pool is specified, omit other session configuration flags—pool settings determine profile, proxy, viewport, etc._
-- `kernel browsers delete <id>` - Delete a browser
-- `kernel browsers view <id>` - Get live view URL for a browser
+- `kernel browsers delete <id-or-name>` - Delete a browser by ID or name
+- `kernel browsers view <id-or-name>` - Get live view URL for a browser by ID or name
   - `--output json`, `-o json` - Output JSON with liveViewUrl
-- `kernel browsers get <id>` - Get detailed browser session info
+- `kernel browsers get <id-or-name>` - Get detailed browser session info by ID or name
   - `--output json`, `-o json` - Output raw JSON object
-- `kernel browsers update <id>` - Update a running browser session
+- `kernel browsers update <id-or-name>` - Update a running browser session by ID or name
   - `--telemetry=all` - Enable telemetry for all categories
   - `--telemetry=off` - Disable telemetry
   - `--telemetry=<list>` - Per-category config, e.g. `--telemetry=network=on,page=off`
@@ -264,6 +268,8 @@ Commands with JSON output support:
   - `--force` - Force delete even if browsers are leased
 - `kernel browser-pools acquire <id-or-name>` - Acquire a browser from the pool
   - `--timeout <seconds>` - Acquire timeout before returning 204
+  - `--name <name>` - Optional name for the acquired session (applies to this lease; cleared on release)
+  - `--tag <KEY=VALUE>` - Set a tag on the acquired session, repeatable; applies to this lease
   - `--output json`, `-o json` - Output raw JSON object
 - `kernel browser-pools release <id-or-name>` - Release a browser back to the pool
   - `--session-id <id>` - Browser session ID to release (required)

cmd/browser_pools.go

@@ -354,18 +354,34 @@ func (c BrowserPoolsCmd) Delete(ctx context.Context, in BrowserPoolsDeleteInput)
 type BrowserPoolsAcquireInput struct {
 	IDOrName       string
 	TimeoutSeconds int64
+	Name           string
+	Tags           map[string]string
 	Output         string
 }
 
+// buildAcquireParams builds the SDK params for acquiring a browser from a pool.
+// Shared by `browser-pools acquire` and the `browsers create --pool-id/--pool-name`
+// path so the per-lease name/tags forwarding cannot silently diverge between them.
+func buildAcquireParams(name string, tags map[string]string, timeoutSeconds int64) kernel.BrowserPoolAcquireParams {
+	params := kernel.BrowserPoolAcquireParams{}
+	if timeoutSeconds > 0 {
+		params.AcquireTimeoutSeconds = kernel.Int(timeoutSeconds)
+	}
+	if name != "" {
+		params.Name = kernel.Opt(name)
+	}
+	if len(tags) > 0 {
+		params.Tags = kernel.Tags(tags)
+	}
+	return params
+}
+
 func (c BrowserPoolsCmd) Acquire(ctx context.Context, in BrowserPoolsAcquireInput) error {
 	if err := validateJSONOutput(in.Output); err != nil {
 		return err
 	}
 
-	params := kernel.BrowserPoolAcquireParams{}
-	if in.TimeoutSeconds > 0 {
-		params.AcquireTimeoutSeconds = kernel.Int(in.TimeoutSeconds)
-	}
+	params := buildAcquireParams(in.Name, in.Tags, in.TimeoutSeconds)
 	resp, err := c.client.Acquire(ctx, in.IDOrName, params)
 	if err != nil {
 		return util.CleanedUpSdkError{Err: err}
@@ -386,12 +402,20 @@ func (c BrowserPoolsCmd) Acquire(ctx context.Context, in BrowserPoolsAcquireInpu
 	tableData := pterm.TableData{
 		{"Property", "Value"},
 		{"Session ID", resp.SessionID},
-		{"CDP WebSocket URL", resp.CdpWsURL},
-		{"Live View URL", resp.BrowserLiveViewURL},
 	}
+	if resp.Name != "" {
+		tableData = append(tableData, []string{"Name", resp.Name})
+	}
+	tableData = append(tableData,
+		[]string{"CDP WebSocket URL", resp.CdpWsURL},
+		[]string{"Live View URL", resp.BrowserLiveViewURL},
+	)
 	if resp.StartURL != "" {
 		tableData = append(tableData, []string{"Start URL", resp.StartURL})
 	}
+	if len(resp.Tags) > 0 {
+		tableData = append(tableData, []string{"Tags", formatTags(resp.Tags)})
+	}
 	PrintTableNoPad(tableData, true)
 	return nil
 }
@@ -541,6 +565,8 @@ func init() {
 	browserPoolsDeleteCmd.Flags().Bool("force", false, "Force delete even if browsers are leased")
 
 	browserPoolsAcquireCmd.Flags().Int64("timeout", 0, "Acquire timeout in seconds")
+	browserPoolsAcquireCmd.Flags().String("name", "", "Optional name for the acquired session (applies to this lease; cleared on release)")
+	browserPoolsAcquireCmd.Flags().StringArray("tag", nil, "Set a tag KEY=VALUE on the acquired session (repeatable; applies to this lease)")
 	addJSONOutputFlag(browserPoolsAcquireCmd)
 
 	browserPoolsReleaseCmd.Flags().String("session-id", "", "Browser session ID to release")
@@ -676,9 +702,17 @@ func runBrowserPoolsDelete(cmd *cobra.Command, args []string) error {
 func runBrowserPoolsAcquire(cmd *cobra.Command, args []string) error {
 	client := getKernelClient(cmd)
 	timeout, _ := cmd.Flags().GetInt64("timeout")
+	name, _ := cmd.Flags().GetString("name")
+	tags := tagsFromFlag(cmd, "tag")
 	output, _ := cmd.Flags().GetString("output")
 	c := BrowserPoolsCmd{client: &client.BrowserPools}
-	return c.Acquire(cmd.Context(), BrowserPoolsAcquireInput{IDOrName: args[0], TimeoutSeconds: timeout, Output: output})
+	return c.Acquire(cmd.Context(), BrowserPoolsAcquireInput{
+		IDOrName:       args[0],
+		TimeoutSeconds: timeout,
+		Name:           name,
+		Tags:           tags,
+		Output:         output,
+	})
 }
 
 func runBrowserPoolsRelease(cmd *cobra.Command, args []string) error {

cmd/browser_pools_test.go

@@ -0,0 +1,130 @@
+package cmd
+
+import (
+	"context"
+	"testing"
+
+	"github.com/kernel/kernel-go-sdk"
+	"github.com/kernel/kernel-go-sdk/option"
+	"github.com/kernel/kernel-go-sdk/packages/pagination"
+	"github.com/stretchr/testify/assert"
+)
+
+// FakeBrowserPoolsService is a configurable fake implementing BrowserPoolsService.
+type FakeBrowserPoolsService struct {
+	AcquireFunc func(ctx context.Context, id string, body kernel.BrowserPoolAcquireParams, opts ...option.RequestOption) (*kernel.BrowserPoolAcquireResponse, error)
+	ListFunc    func(ctx context.Context, query kernel.BrowserPoolListParams, opts ...option.RequestOption) (*pagination.OffsetPagination[kernel.BrowserPool], error)
+}
+
+func (f *FakeBrowserPoolsService) List(ctx context.Context, query kernel.BrowserPoolListParams, opts ...option.RequestOption) (*pagination.OffsetPagination[kernel.BrowserPool], error) {
+	if f.ListFunc != nil {
+		return f.ListFunc(ctx, query, opts...)
+	}
+	return &pagination.OffsetPagination[kernel.BrowserPool]{Items: []kernel.BrowserPool{}}, nil
+}
+
+func (f *FakeBrowserPoolsService) New(ctx context.Context, body kernel.BrowserPoolNewParams, opts ...option.RequestOption) (*kernel.BrowserPool, error) {
+	return &kernel.BrowserPool{}, nil
+}
+
+func (f *FakeBrowserPoolsService) Get(ctx context.Context, id string, opts ...option.RequestOption) (*kernel.BrowserPool, error) {
+	return &kernel.BrowserPool{}, nil
+}
+
+func (f *FakeBrowserPoolsService) Update(ctx context.Context, id string, body kernel.BrowserPoolUpdateParams, opts ...option.RequestOption) (*kernel.BrowserPool, error) {
+	return &kernel.BrowserPool{}, nil
+}
+
+func (f *FakeBrowserPoolsService) Delete(ctx context.Context, id string, body kernel.BrowserPoolDeleteParams, opts ...option.RequestOption) error {
+	return nil
+}
+
+func (f *FakeBrowserPoolsService) Acquire(ctx context.Context, id string, body kernel.BrowserPoolAcquireParams, opts ...option.RequestOption) (*kernel.BrowserPoolAcquireResponse, error) {
+	if f.AcquireFunc != nil {
+		return f.AcquireFunc(ctx, id, body, opts...)
+	}
+	return &kernel.BrowserPoolAcquireResponse{}, nil
+}
+
+func (f *FakeBrowserPoolsService) Release(ctx context.Context, id string, body kernel.BrowserPoolReleaseParams, opts ...option.RequestOption) error {
+	return nil
+}
+
+func (f *FakeBrowserPoolsService) Flush(ctx context.Context, id string, opts ...option.RequestOption) error {
+	return nil
+}
+
+func TestBrowserPoolsAcquire_WithNameAndTags(t *testing.T) {
+	setupStdoutCapture(t)
+
+	var capturedID string
+	var captured kernel.BrowserPoolAcquireParams
+	fake := &FakeBrowserPoolsService{
+		AcquireFunc: func(ctx context.Context, id string, body kernel.BrowserPoolAcquireParams, opts ...option.RequestOption) (*kernel.BrowserPoolAcquireResponse, error) {
+			capturedID = id
+			captured = body
+			return &kernel.BrowserPoolAcquireResponse{
+				SessionID: "sess-acq",
+				CdpWsURL:  "ws://cdp-acq",
+				Name:      "lease-name",
+				Tags:      kernel.Tags{"env": "prod"},
+			}, nil
+		},
+	}
+
+	c := BrowserPoolsCmd{client: fake}
+	err := c.Acquire(context.Background(), BrowserPoolsAcquireInput{
+		IDOrName: "my-pool",
+		Name:     "lease-name",
+		Tags:     map[string]string{"env": "prod"},
+	})
+	assert.NoError(t, err)
+
+	// Pool lookup is by id or name; name + tags are forwarded per-lease.
+	assert.Equal(t, "my-pool", capturedID)
+	assert.True(t, captured.Name.Valid())
+	assert.Equal(t, "lease-name", captured.Name.Value)
+	assert.Equal(t, "prod", captured.Tags["env"])
+
+	// And surfaced in the acquired-session table.
+	out := outBuf.String()
+	assert.Contains(t, out, "lease-name")
+	assert.Contains(t, out, "Tags")
+	assert.Contains(t, out, "env=prod")
+}
+
+func TestBrowserPoolsList_ForwardsLimitOffset(t *testing.T) {
+	setupStdoutCapture(t)
+
+	var captured kernel.BrowserPoolListParams
+	fake := &FakeBrowserPoolsService{
+		ListFunc: func(ctx context.Context, query kernel.BrowserPoolListParams, opts ...option.RequestOption) (*pagination.OffsetPagination[kernel.BrowserPool], error) {
+			captured = query
+			return &pagination.OffsetPagination[kernel.BrowserPool]{Items: []kernel.BrowserPool{}}, nil
+		},
+	}
+
+	c := BrowserPoolsCmd{client: fake}
+	err := c.List(context.Background(), BrowserPoolsListInput{Limit: 4, Offset: 8})
+
+	assert.NoError(t, err)
+	assert.Equal(t, int64(4), captured.Limit.Value)
+	assert.Equal(t, int64(8), captured.Offset.Value)
+}
+
+// TestBuildAcquireParams covers the shared name/tags/timeout forwarding used by
+// both `browser-pools acquire` and the `browsers create --pool-id` lease path.
+func TestBuildAcquireParams(t *testing.T) {
+	p := buildAcquireParams("lease", map[string]string{"env": "prod"}, 30)
+	assert.True(t, p.Name.Valid())
+	assert.Equal(t, "lease", p.Name.Value)
+	assert.Equal(t, "prod", p.Tags["env"])
+	assert.True(t, p.AcquireTimeoutSeconds.Valid())
+	assert.Equal(t, int64(30), p.AcquireTimeoutSeconds.Value)
+
+	// Unset inputs produce an empty params struct (nothing forwarded).
+	empty := buildAcquireParams("", nil, 0)
+	assert.False(t, empty.Name.Valid())
+	assert.Len(t, empty.Tags, 0)
+	assert.False(t, empty.AcquireTimeoutSeconds.Valid())
+}