Address review feedback on telemetry events command

- Use the shared addJSONOutputFlag for `browsers telemetry events` instead of a
  hand-rolled --output flag (consistency with extensions get). [Bugbot]
- Don't send --since/--until when --offset is set: offset is an opaque
  X-Next-Offset cursor that already encodes the query window, so the window
  flags are ignored when paging. Aligns behavior with the flag help and updates
  --until's help to match --since. Added a test. [Bugbot]
- Surface the pagination cursor in JSON mode: `--output json` now emits
  {"events": [...], "next_offset": "..."} so scripted callers can paginate
  (table mode already printed the hint). Updated the empty-JSON test. [Bugbot]
- README: document `extensions get`, `browsers telemetry events`, and the
  `--replay` flag on `telemetry stream`. [review]

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: IlyaasK

README.md

@@ -317,8 +317,14 @@ Per-category updates are partial — only categories you name are changed; other
   - `--categories <list>` - Filter by event category (`console`, `network`, `page`, `interaction`, `control`, `connection`, `system`, `screenshot`, `captcha`, `monitor`)
   - `--types <list>` - Filter by event type (e.g. `network_response`, `console_error`)
   - `--seq <n>` - Resume after sequence number N (Last-Event-ID); replays events with `seq > N`. Omit to stream from now.
+  - `--replay all` - Replay buffered events on connect, starting from the oldest retained event (mutually exclusive with `--seq`)
   - `-o, --output json` - Output newline-delimited JSON envelopes
   - Default output: tab-separated `<time>\t[<category>]\t<type>`, e.g. `15:04:05  [network]  network_response`
+- `kernel browsers telemetry events <id>` - Read historical telemetry events (paged)
+  - `--limit <n>` - Maximum number of events per page (default 20)
+  - `--offset <cursor>` - Pagination cursor: pass the `X-Next-Offset` from a previous response
+  - `--since <ts|dur>` / `--until <ts|dur>` - Time window (RFC-3339 timestamp or duration like `5m`); ignored when `--offset` is set
+  - `-o, --output json` - Output `{ "events": [...], "next_offset": "..." }` (omit `next_offset` when there is no next page)
 
 ### Browser Process Control
 
@@ -444,6 +450,8 @@ Per-category updates are partial — only categories you name are changed; other
 
 - `kernel extensions list` - List all uploaded extensions
   - `--output json`, `-o json` - Output raw JSON array
+- `kernel extensions get <id-or-name>` - Show extension metadata (id, name, created, size, last used)
+  - `--output json`, `-o json` - Output raw JSON object
 - `kernel extensions upload <directory>` - Upload an unpacked browser extension directory
   - `--name <name>` - Optional unique extension name
   - `--output json`, `-o json` - Output raw JSON object

cmd/browsers.go

@@ -2756,8 +2756,8 @@ followed automatically by Chromium.`,
 	telemetryEvents.Flags().Int64("limit", 0, "Maximum number of events per page (default 20)")
 	telemetryEvents.Flags().Int64("offset", 0, "Pagination cursor: pass the X-Next-Offset from a previous response")
 	telemetryEvents.Flags().String("since", "", "Window start: RFC-3339 timestamp or a duration like 5m (default 5m). Ignored when --offset is set")
-	telemetryEvents.Flags().String("until", "", "Window end (exclusive): RFC-3339 timestamp or a duration like 5m")
-	telemetryEvents.Flags().StringP("output", "o", "", "Output format: json")
+	telemetryEvents.Flags().String("until", "", "Window end (exclusive): RFC-3339 timestamp or a duration like 5m. Ignored when --offset is set")
+	addJSONOutputFlag(telemetryEvents)
 	telemetryRoot.AddCommand(telemetryEvents)
 	browsersCmd.AddCommand(telemetryRoot)
 

cmd/browsers_telemetry.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
@@ -272,13 +273,16 @@ func (b BrowsersCmd) TelemetryEvents(ctx context.Context, in BrowsersTelemetryEv
 		params.Limit = kernel.Opt(in.Limit)
 	}
 	if in.Offset > 0 {
+		// Offset is an opaque cursor (X-Next-Offset) that already encodes the
+		// query window, so since/until are ignored when paging by offset.
 		params.Offset = kernel.Opt(in.Offset)
-	}
-	if in.Since != "" {
-		params.Since = kernel.Opt(in.Since)
-	}
-	if in.Until != "" {
-		params.Until = kernel.Opt(in.Until)
+	} else {
+		if in.Since != "" {
+			params.Since = kernel.Opt(in.Since)
+		}
+		if in.Until != "" {
+			params.Until = kernel.Opt(in.Until)
+		}
 	}
 
 	var raw *http.Response
@@ -293,11 +297,32 @@ func (b BrowsersCmd) TelemetryEvents(ctx context.Context, in BrowsersTelemetryEv
 	}
 
 	if in.Output == "json" {
-		if len(items) == 0 {
-			fmt.Println("[]")
-			return nil
+		// Surface the X-Next-Offset cursor in JSON mode too, so scripted callers
+		// can paginate (table mode prints it as a hint below).
+		nextOffset := ""
+		if raw != nil {
+			if n := raw.Header.Get("X-Next-Offset"); n != "" && n != "0" {
+				nextOffset = n
+			}
 		}
-		return util.PrintPrettyJSONSlice(items)
+		events := make([]json.RawMessage, 0, len(items))
+		for _, it := range items {
+			r := it.RawJSON()
+			if r == "" {
+				r = "{}"
+			}
+			events = append(events, json.RawMessage(r))
+		}
+		payload := struct {
+			Events     []json.RawMessage `json:"events"`
+			NextOffset string            `json:"next_offset,omitempty"`
+		}{Events: events, NextOffset: nextOffset}
+		data, err := json.MarshalIndent(payload, "", "  ")
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(data))
+		return nil
 	}
 
 	if len(items) == 0 {

cmd/browsers_telemetry_test.go

@@ -400,5 +400,27 @@ func TestTelemetryEvents_EmptyJSON(t *testing.T) {
 		err := b.TelemetryEvents(context.Background(), BrowsersTelemetryEventsInput{Identifier: "br-1", Output: "json"})
 		assert.NoError(t, err)
 	})
-	assert.Equal(t, "[]\n", out)
+	// JSON mode emits an envelope so scripted callers can read the pagination
+	// cursor; with no events and no next page it is just an empty events list.
+	assert.JSONEq(t, `{"events":[]}`, out)
+}
+
+func TestTelemetryEvents_OffsetIgnoresWindow(t *testing.T) {
+	buf := capturePtermOutput(t)
+	fakeBrowsers := &FakeBrowsersService{GetFunc: func(ctx context.Context, id string, query kernel.BrowserGetParams, opts ...option.RequestOption) (*kernel.BrowserGetResponse, error) {
+		return &kernel.BrowserGetResponse{SessionID: "sess-1"}, nil
+	}}
+	fakeTelemetry := &FakeBrowserTelemetryService{
+		EventsFunc: func(ctx context.Context, id string, query kernel.BrowserTelemetryEventsParams, opts ...option.RequestOption) (*pagination.OffsetPagination[kernel.BrowserTelemetryEventsResponse], error) {
+			// When paging by the opaque offset cursor, since/until must not be sent.
+			assert.True(t, query.Offset.Valid(), "offset should be forwarded")
+			assert.False(t, query.Since.Valid(), "since must be omitted when --offset is set")
+			assert.False(t, query.Until.Valid(), "until must be omitted when --offset is set")
+			return &pagination.OffsetPagination[kernel.BrowserTelemetryEventsResponse]{}, nil
+		},
+	}
+	b := BrowsersCmd{browsers: fakeBrowsers, telemetry: fakeTelemetry}
+	err := b.TelemetryEvents(context.Background(), BrowsersTelemetryEventsInput{Identifier: "br-1", Offset: 5, Since: "5m", Until: "1m"})
+	assert.NoError(t, err)
+	_ = buf
 }