From 000ec32cb5fc85e509ff5bf0c0dbe0896c903de6 Mon Sep 17 00:00:00 2001
From: Rafael Garcia <rgarcia2009@gmail.com>
Date: Wed, 15 Oct 2025 14:19:55 -0400
Subject: [PATCH 1/6] click, type, move mouse, screenshot

---
 README.md            |  44 ++++++++
 cmd/browsers.go      | 258 +++++++++++++++++++++++++++++++++++++++++++
 cmd/browsers_test.go |  73 ++++++++++++
 go.mod               |   2 +
 go.sum               |   7 +-
 5 files changed, 379 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index fd87894..7ce3a0d 100644
--- a/README.md
+++ b/README.md
@@ -240,6 +240,29 @@ Create an API key from the [Kernel dashboard](https://dashboard.onkernel.com).
 
 - `kernel browsers extensions upload <id or persistent id> <extension-path>...` - Ad-hoc upload of one or more unpacked extensions to a running browser instance.
 
+### Browser Computer Controls
+
+- `kernel browsers computer click-mouse <id or persistent id>` - Click mouse at coordinates
+  - `--x <coordinate>` - X coordinate (required)
+  - `--y <coordinate>` - Y coordinate (required)
+  - `--num-clicks <n>` - Number of clicks (default: 1)
+  - `--button <button>` - Mouse button: left, right, middle, back, forward (default: left)
+  - `--click-type <type>` - Click type: down, up, click (default: click)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+- `kernel browsers computer move-mouse <id or persistent id>` - Move mouse to coordinates
+  - `--x <coordinate>` - X coordinate (required)
+  - `--y <coordinate>` - Y coordinate (required)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+- `kernel browsers computer screenshot <id or persistent id>` - Capture a screenshot
+  - `--to <path>` - Output file path for the PNG image (required)
+  - `--x <coordinate>` - Top-left X for region capture (optional)
+  - `--y <coordinate>` - Top-left Y for region capture (optional)
+  - `--width <pixels>` - Region width (optional)
+  - `--height <pixels>` - Region height (optional)
+- `kernel browsers computer type <id or persistent id>` - Type text on the browser instance
+  - `--text <text>` - Text to type (required)
+  - `--delay <ms>` - Delay in milliseconds between keystrokes (optional)
+
 ### Extension Management
 
 - `kernel extensions list` - List all uploaded extensions
@@ -326,6 +349,27 @@ kernel browsers fs upload my-browser --file "local.txt:remote.txt" --dest-dir "/
 
 # List files in a directory
 kernel browsers fs list-files my-browser --path "/tmp"
+
+# Click the mouse at coordinates (100, 200)
+kernel browsers computer click-mouse my-browser --x 100 --y 200
+
+# Double-click the right mouse button
+kernel browsers computer click-mouse my-browser --x 100 --y 200 --num-clicks 2 --button right
+
+# Move the mouse to coordinates (500, 300)
+kernel browsers computer move-mouse my-browser --x 500 --y 300
+
+# Take a full screenshot
+kernel browsers computer screenshot my-browser --to screenshot.png
+
+# Take a screenshot of a specific region
+kernel browsers computer screenshot my-browser --to region.png --x 0 --y 0 --width 800 --height 600
+
+# Type text in the browser
+kernel browsers computer type my-browser --text "Hello, World!"
+
+# Type text with a 100ms delay between keystrokes
+kernel browsers computer type my-browser --text "Slow typing..." --delay 100
 ```
 
 ### Extension management
diff --git a/cmd/browsers.go b/cmd/browsers.go
index af78289..892a372 100644
--- a/cmd/browsers.go
+++ b/cmd/browsers.go
@@ -73,6 +73,14 @@ type BrowserLogService interface {
 	StreamStreaming(ctx context.Context, id string, query kernel.BrowserLogStreamParams, opts ...option.RequestOption) (stream *ssestream.Stream[shared.LogEvent])
 }
 
+// BrowserComputerService defines the subset we use for OS-level mouse & screen.
+type BrowserComputerService interface {
+	CaptureScreenshot(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (res *http.Response, err error)
+	ClickMouse(ctx context.Context, id string, body kernel.BrowserComputerClickMouseParams, opts ...option.RequestOption) (err error)
+	MoveMouse(ctx context.Context, id string, body kernel.BrowserComputerMoveMouseParams, opts ...option.RequestOption) (err error)
+	TypeText(ctx context.Context, id string, body kernel.BrowserComputerTypeTextParams, opts ...option.RequestOption) (err error)
+}
+
 // BoolFlag captures whether a boolean flag was set explicitly and its value.
 type BoolFlag struct {
 	Set   bool
@@ -159,6 +167,7 @@ type BrowsersCmd struct {
 	fs       BrowserFSService
 	process  BrowserProcessService
 	logs     BrowserLogService
+	computer BrowserComputerService
 }
 
 type BrowsersListInput struct {
@@ -483,6 +492,161 @@ func (b BrowsersCmd) LogsStream(ctx context.Context, in BrowsersLogsStreamInput)
 	return nil
 }
 
+// Computer (mouse/screen)
+type BrowsersComputerClickMouseInput struct {
+	Identifier string
+	X          int64
+	Y          int64
+	NumClicks  int64
+	Button     string
+	ClickType  string
+	HoldKeys   []string
+}
+
+type BrowsersComputerMoveMouseInput struct {
+	Identifier string
+	X          int64
+	Y          int64
+	HoldKeys   []string
+}
+
+type BrowsersComputerScreenshotInput struct {
+	Identifier string
+	X          int64
+	Y          int64
+	Width      int64
+	Height     int64
+	To         string
+	HasRegion  bool
+}
+
+type BrowsersComputerTypeTextInput struct {
+	Identifier string
+	Text       string
+	Delay      int64
+}
+
+func (b BrowsersCmd) ComputerClickMouse(ctx context.Context, in BrowsersComputerClickMouseInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	body := kernel.BrowserComputerClickMouseParams{X: in.X, Y: in.Y}
+	if in.NumClicks > 0 {
+		body.NumClicks = kernel.Opt(in.NumClicks)
+	}
+	if in.Button != "" {
+		body.Button = kernel.BrowserComputerClickMouseParamsButton(in.Button)
+	}
+	if in.ClickType != "" {
+		body.ClickType = kernel.BrowserComputerClickMouseParamsClickType(in.ClickType)
+	}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.ClickMouse(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Clicked mouse at (%d,%d)\n", in.X, in.Y)
+	return nil
+}
+
+func (b BrowsersCmd) ComputerMoveMouse(ctx context.Context, in BrowsersComputerMoveMouseInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	body := kernel.BrowserComputerMoveMouseParams{X: in.X, Y: in.Y}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.MoveMouse(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Moved mouse to (%d,%d)\n", in.X, in.Y)
+	return nil
+}
+
+func (b BrowsersCmd) ComputerScreenshot(ctx context.Context, in BrowsersComputerScreenshotInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	var body kernel.BrowserComputerCaptureScreenshotParams
+	if in.HasRegion {
+		body.Region = kernel.BrowserComputerCaptureScreenshotParamsRegion{X: in.X, Y: in.Y, Width: in.Width, Height: in.Height}
+	}
+	res, err := b.computer.CaptureScreenshot(ctx, br.SessionID, body)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	defer res.Body.Close()
+	if in.To == "" {
+		pterm.Error.Println("--to is required to save the screenshot")
+		return nil
+	}
+	f, err := os.Create(in.To)
+	if err != nil {
+		pterm.Error.Printf("Failed to create file: %v\n", err)
+		return nil
+	}
+	defer f.Close()
+	if _, err := io.Copy(f, res.Body); err != nil {
+		pterm.Error.Printf("Failed to write file: %v\n", err)
+		return nil
+	}
+	pterm.Success.Printf("Saved screenshot to %s\n", in.To)
+	return nil
+}
+
+func (b BrowsersCmd) ComputerTypeText(ctx context.Context, in BrowsersComputerTypeTextInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	body := kernel.BrowserComputerTypeTextParams{Text: in.Text}
+	if in.Delay > 0 {
+		body.Delay = kernel.Opt(in.Delay)
+	}
+	if err := b.computer.TypeText(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Typed text: %s\n", in.Text)
+	return nil
+}
+
 // Replays
 type BrowsersReplaysListInput struct {
 	Identifier string
@@ -1537,6 +1701,41 @@ func init() {
 	extensionsRoot.AddCommand(extensionsUpload)
 	browsersCmd.AddCommand(extensionsRoot)
 
+	// computer
+	computerRoot := &cobra.Command{Use: "computer", Short: "OS-level mouse & screen controls"}
+	computerClick := &cobra.Command{Use: "click-mouse <id|persistent-id>", Short: "Click mouse at coordinates", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerClickMouse}
+	computerClick.Flags().Int64("x", 0, "X coordinate")
+	computerClick.Flags().Int64("y", 0, "Y coordinate")
+	_ = computerClick.MarkFlagRequired("x")
+	_ = computerClick.MarkFlagRequired("y")
+	computerClick.Flags().Int64("num-clicks", 1, "Number of clicks")
+	computerClick.Flags().String("button", "left", "Mouse button: left,right,middle,back,forward")
+	computerClick.Flags().String("click-type", "click", "Click type: down,up,click")
+	computerClick.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	computerMove := &cobra.Command{Use: "move-mouse <id|persistent-id>", Short: "Move mouse to coordinates", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerMoveMouse}
+	computerMove.Flags().Int64("x", 0, "X coordinate")
+	computerMove.Flags().Int64("y", 0, "Y coordinate")
+	_ = computerMove.MarkFlagRequired("x")
+	_ = computerMove.MarkFlagRequired("y")
+	computerMove.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	computerScreenshot := &cobra.Command{Use: "screenshot <id|persistent-id>", Short: "Capture a screenshot (optionally of a region)", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerScreenshot}
+	computerScreenshot.Flags().Int64("x", 0, "Top-left X")
+	computerScreenshot.Flags().Int64("y", 0, "Top-left Y")
+	computerScreenshot.Flags().Int64("width", 0, "Region width")
+	computerScreenshot.Flags().Int64("height", 0, "Region height")
+	computerScreenshot.Flags().String("to", "", "Output file path for the PNG image")
+	_ = computerScreenshot.MarkFlagRequired("to")
+
+	computerType := &cobra.Command{Use: "type <id|persistent-id>", Short: "Type text on the browser instance", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerTypeText}
+	computerType.Flags().String("text", "", "Text to type")
+	_ = computerType.MarkFlagRequired("text")
+	computerType.Flags().Int64("delay", 0, "Delay in milliseconds between keystrokes")
+
+	computerRoot.AddCommand(computerClick, computerMove, computerScreenshot, computerType)
+	browsersCmd.AddCommand(computerRoot)
+
 	// Add flags for create command
 	browsersCreateCmd.Flags().StringP("persistent-id", "p", "", "Unique identifier for browser session persistence")
 	browsersCreateCmd.Flags().BoolP("stealth", "s", false, "Launch browser in stealth mode to avoid detection")
@@ -1887,6 +2086,65 @@ func runBrowsersExtensionsUpload(cmd *cobra.Command, args []string) error {
 	return b.ExtensionsUpload(cmd.Context(), BrowsersExtensionsUploadInput{Identifier: args[0], ExtensionPaths: args[1:]})
 }
 
+func runBrowsersComputerClickMouse(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	x, _ := cmd.Flags().GetInt64("x")
+	y, _ := cmd.Flags().GetInt64("y")
+	numClicks, _ := cmd.Flags().GetInt64("num-clicks")
+	button, _ := cmd.Flags().GetString("button")
+	clickType, _ := cmd.Flags().GetString("click-type")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerClickMouse(cmd.Context(), BrowsersComputerClickMouseInput{Identifier: args[0], X: x, Y: y, NumClicks: numClicks, Button: button, ClickType: clickType, HoldKeys: holdKeys})
+}
+
+func runBrowsersComputerMoveMouse(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	x, _ := cmd.Flags().GetInt64("x")
+	y, _ := cmd.Flags().GetInt64("y")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerMoveMouse(cmd.Context(), BrowsersComputerMoveMouseInput{Identifier: args[0], X: x, Y: y, HoldKeys: holdKeys})
+}
+
+func runBrowsersComputerScreenshot(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	x, _ := cmd.Flags().GetInt64("x")
+	y, _ := cmd.Flags().GetInt64("y")
+	w, _ := cmd.Flags().GetInt64("width")
+	h, _ := cmd.Flags().GetInt64("height")
+	to, _ := cmd.Flags().GetString("to")
+	bx := cmd.Flags().Changed("x")
+	by := cmd.Flags().Changed("y")
+	bw := cmd.Flags().Changed("width")
+	bh := cmd.Flags().Changed("height")
+	useRegion := bx || by || bw || bh
+	if useRegion {
+		if !(bx && by && bw && bh) {
+			pterm.Error.Println("if specifying region, you must provide --x, --y, --width, and --height")
+			return nil
+		}
+		if w <= 0 || h <= 0 {
+			pterm.Error.Println("--width and --height must be greater than zero")
+			return nil
+		}
+	}
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerScreenshot(cmd.Context(), BrowsersComputerScreenshotInput{Identifier: args[0], X: x, Y: y, Width: w, Height: h, To: to, HasRegion: useRegion})
+}
+
+func runBrowsersComputerTypeText(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	text, _ := cmd.Flags().GetString("text")
+	delay, _ := cmd.Flags().GetInt64("delay")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerTypeText(cmd.Context(), BrowsersComputerTypeTextInput{Identifier: args[0], Text: text, Delay: delay})
+}
+
 func truncateURL(url string, maxLen int) string {
 	if len(url) <= maxLen {
 		return url
diff --git a/cmd/browsers_test.go b/cmd/browsers_test.go
index 0f9c4d3..c589e9e 100644
--- a/cmd/browsers_test.go
+++ b/cmd/browsers_test.go
@@ -523,6 +523,33 @@ func makeStream[T any](vals []T) *ssestream.Stream[T] {
 	return ssestream.NewStream[T](&testDecoder{data: events}, nil)
 }
 
+// --- Fake for Computer ---
+
+type FakeComputerService struct {
+	ClickMouseFunc        func(ctx context.Context, id string, body kernel.BrowserComputerClickMouseParams, opts ...option.RequestOption) error
+	MoveMouseFunc         func(ctx context.Context, id string, body kernel.BrowserComputerMoveMouseParams, opts ...option.RequestOption) error
+	CaptureScreenshotFunc func(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (*http.Response, error)
+}
+
+func (f *FakeComputerService) ClickMouse(ctx context.Context, id string, body kernel.BrowserComputerClickMouseParams, opts ...option.RequestOption) error {
+	if f.ClickMouseFunc != nil {
+		return f.ClickMouseFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) MoveMouse(ctx context.Context, id string, body kernel.BrowserComputerMoveMouseParams, opts ...option.RequestOption) error {
+	if f.MoveMouseFunc != nil {
+		return f.MoveMouseFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) CaptureScreenshot(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (*http.Response, error) {
+	if f.CaptureScreenshotFunc != nil {
+		return f.CaptureScreenshotFunc(ctx, id, body, opts...)
+	}
+	return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"image/png"}}, Body: io.NopCloser(strings.NewReader("pngdata"))}, nil
+}
+
 // --- Tests for Logs ---
 
 func TestBrowsersLogsStream_PrintsEvents(t *testing.T) {
@@ -882,6 +909,52 @@ func __writeTempFile(t *testing.T, data string) string {
 	return f.Name()
 }
 
+// --- Tests for Computer ---
+
+func TestBrowsersComputerClickMouse_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerClickMouse(context.Background(), BrowsersComputerClickMouseInput{Identifier: "id", X: 10, Y: 20, NumClicks: 2, Button: string(kernel.BrowserComputerClickMouseParamsButtonLeft), ClickType: string(kernel.BrowserComputerClickMouseParamsClickTypeClick), HoldKeys: []string{"shift"}})
+	out := outBuf.String()
+	assert.Contains(t, out, "Clicked mouse at (10,20)")
+}
+
+func TestBrowsersComputerMoveMouse_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerMoveMouse(context.Background(), BrowsersComputerMoveMouseInput{Identifier: "id", X: 5, Y: 6})
+	out := outBuf.String()
+	assert.Contains(t, out, "Moved mouse to (5,6)")
+}
+
+func TestBrowsersComputerScreenshot_SavesFile(t *testing.T) {
+	setupStdoutCapture(t)
+	dir := t.TempDir()
+	outPath := filepath.Join(dir, "shot.png")
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{CaptureScreenshotFunc: func(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (*http.Response, error) {
+		return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"image/png"}}, Body: io.NopCloser(strings.NewReader("pngDATA"))}, nil
+	}}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerScreenshot(context.Background(), BrowsersComputerScreenshotInput{Identifier: "id", X: 0, Y: 0, Width: 10, Height: 10, To: outPath})
+	data, err := os.ReadFile(outPath)
+	assert.NoError(t, err)
+	assert.Equal(t, "pngDATA", string(data))
+}
+
 func TestParseViewport_ValidFormats(t *testing.T) {
 	tests := []struct {
 		input       string
diff --git a/go.mod b/go.mod
index 2646552..64d18a8 100644
--- a/go.mod
+++ b/go.mod
@@ -58,3 +58,5 @@ require (
 	golang.org/x/text v0.24.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
+
+replace github.com/onkernel/kernel-go-sdk => github.com/stainless-sdks/kernel-go v0.0.0-20251015181321-ae43476ba10a
diff --git a/go.sum b/go.sum
index bfef52d..899774f 100644
--- a/go.sum
+++ b/go.sum
@@ -91,10 +91,6 @@ github.com/muesli/mango-pflag v0.1.0 h1:UADqbYgpUyRoBja3g6LUL+3LErjpsOwaC9ywvBWe
 github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0=
 github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
 github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
-github.com/onkernel/kernel-go-sdk v0.14.1 h1:r4drk5uM1phiXl0dZXhnH1zz5iTmApPC0cGSSiNKbVk=
-github.com/onkernel/kernel-go-sdk v0.14.1/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
-github.com/onkernel/kernel-go-sdk v0.14.2-0.20251013154713-58a9d56ff62f h1:/cXzVNPxWryqNsIo2Kvc5fYLBlk7CHus3JZIv1JVoU4=
-github.com/onkernel/kernel-go-sdk v0.14.2-0.20251013154713-58a9d56ff62f/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -120,6 +116,8 @@ github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
 github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
 github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
 github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stainless-sdks/kernel-go v0.0.0-20251015181321-ae43476ba10a h1:ZShjGBNUII0dfwC+uC05xMePpxJoQ1qUsus/0CyT8qo=
+github.com/stainless-sdks/kernel-go v0.0.0-20251015181321-ae43476ba10a/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
@@ -131,7 +129,6 @@ github.com/stretchr/testify v1.11.0/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD
 github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
 github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
 github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
-github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
 github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
 github.com/tidwall/match v1.2.0 h1:0pt8FlkOwjN2fPt4bIl4BoNxb98gGHN2ObFEDkrfZnM=
 github.com/tidwall/match v1.2.0/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=

From c97cc0dc3d716ce4819f87a0eeaf0e16b4655f9b Mon Sep 17 00:00:00 2001
From: Rafael Garcia <rgarcia2009@gmail.com>
Date: Thu, 16 Oct 2025 10:35:01 -0400
Subject: [PATCH 2/6] add press key, scroll, drag mouse commands

---
 cmd/browsers.go      | 207 ++++++++++++++++++++++++++++++++++++++++++-
 cmd/browsers_test.go |  69 +++++++++++++++
 go.mod               |   2 +-
 go.sum               |   4 +-
 4 files changed, 278 insertions(+), 4 deletions(-)

diff --git a/cmd/browsers.go b/cmd/browsers.go
index 892a372..69164d9 100644
--- a/cmd/browsers.go
+++ b/cmd/browsers.go
@@ -77,7 +77,10 @@ type BrowserLogService interface {
 type BrowserComputerService interface {
 	CaptureScreenshot(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (res *http.Response, err error)
 	ClickMouse(ctx context.Context, id string, body kernel.BrowserComputerClickMouseParams, opts ...option.RequestOption) (err error)
+	DragMouse(ctx context.Context, id string, body kernel.BrowserComputerDragMouseParams, opts ...option.RequestOption) (err error)
 	MoveMouse(ctx context.Context, id string, body kernel.BrowserComputerMoveMouseParams, opts ...option.RequestOption) (err error)
+	PressKey(ctx context.Context, id string, body kernel.BrowserComputerPressKeyParams, opts ...option.RequestOption) (err error)
+	Scroll(ctx context.Context, id string, body kernel.BrowserComputerScrollParams, opts ...option.RequestOption) (err error)
 	TypeText(ctx context.Context, id string, body kernel.BrowserComputerTypeTextParams, opts ...option.RequestOption) (err error)
 }
 
@@ -526,6 +529,32 @@ type BrowsersComputerTypeTextInput struct {
 	Delay      int64
 }
 
+type BrowsersComputerPressKeyInput struct {
+	Identifier string
+	Keys       []string
+	Duration   int64
+	HoldKeys   []string
+}
+
+type BrowsersComputerScrollInput struct {
+	Identifier string
+	X          int64
+	Y          int64
+	DeltaX     int64
+	DeltaXSet  bool
+	DeltaY     int64
+	DeltaYSet  bool
+	HoldKeys   []string
+}
+
+type BrowsersComputerDragMouseInput struct {
+	Identifier string
+	Path       [][]int64
+	Delay      int64
+	Button     string
+	HoldKeys   []string
+}
+
 func (b BrowsersCmd) ComputerClickMouse(ctx context.Context, in BrowsersComputerClickMouseInput) error {
 	if b.computer == nil {
 		pterm.Error.Println("computer service not available")
@@ -647,6 +676,101 @@ func (b BrowsersCmd) ComputerTypeText(ctx context.Context, in BrowsersComputerTy
 	return nil
 }
 
+func (b BrowsersCmd) ComputerPressKey(ctx context.Context, in BrowsersComputerPressKeyInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	if len(in.Keys) == 0 {
+		pterm.Error.Println("no keys specified")
+		return nil
+	}
+	body := kernel.BrowserComputerPressKeyParams{Keys: in.Keys}
+	if in.Duration > 0 {
+		body.Duration = kernel.Opt(in.Duration)
+	}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.PressKey(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Pressed keys: %s\n", strings.Join(in.Keys, ","))
+	return nil
+}
+
+func (b BrowsersCmd) ComputerScroll(ctx context.Context, in BrowsersComputerScrollInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	body := kernel.BrowserComputerScrollParams{X: in.X, Y: in.Y}
+	if in.DeltaXSet {
+		body.DeltaX = kernel.Opt(in.DeltaX)
+	}
+	if in.DeltaYSet {
+		body.DeltaY = kernel.Opt(in.DeltaY)
+	}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.Scroll(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Scrolled at (%d,%d)\n", in.X, in.Y)
+	return nil
+}
+
+func (b BrowsersCmd) ComputerDragMouse(ctx context.Context, in BrowsersComputerDragMouseInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	if len(in.Path) < 2 {
+		pterm.Error.Println("path must include at least two points")
+		return nil
+	}
+	body := kernel.BrowserComputerDragMouseParams{Path: in.Path}
+	if in.Delay > 0 {
+		body.Delay = kernel.Opt(in.Delay)
+	}
+	if in.Button != "" {
+		body.Button = kernel.BrowserComputerDragMouseParamsButton(in.Button)
+	}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.DragMouse(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Dragged mouse over %d points\n", len(in.Path))
+	return nil
+}
+
 // Replays
 type BrowsersReplaysListInput struct {
 	Identifier string
@@ -1733,7 +1857,31 @@ func init() {
 	_ = computerType.MarkFlagRequired("text")
 	computerType.Flags().Int64("delay", 0, "Delay in milliseconds between keystrokes")
 
-	computerRoot.AddCommand(computerClick, computerMove, computerScreenshot, computerType)
+	// computer press-key
+	computerPressKey := &cobra.Command{Use: "press-key <id|persistent-id>", Short: "Press one or more keys", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerPressKey}
+	computerPressKey.Flags().StringSlice("key", []string{}, "Key symbols to press (repeatable)")
+	_ = computerPressKey.MarkFlagRequired("key")
+	computerPressKey.Flags().Int64("duration", 0, "Duration to hold keys down in ms (0=tap)")
+	computerPressKey.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	// computer scroll
+	computerScroll := &cobra.Command{Use: "scroll <id|persistent-id>", Short: "Scroll the mouse wheel", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerScroll}
+	computerScroll.Flags().Int64("x", 0, "X coordinate")
+	computerScroll.Flags().Int64("y", 0, "Y coordinate")
+	_ = computerScroll.MarkFlagRequired("x")
+	_ = computerScroll.MarkFlagRequired("y")
+	computerScroll.Flags().Int64("delta-x", 0, "Horizontal scroll amount (+right, -left)")
+	computerScroll.Flags().Int64("delta-y", 0, "Vertical scroll amount (+down, -up)")
+	computerScroll.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	// computer drag-mouse
+	computerDrag := &cobra.Command{Use: "drag-mouse <id|persistent-id>", Short: "Drag the mouse along a path", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerDragMouse}
+	computerDrag.Flags().StringSlice("point", []string{}, "Add a point as x,y (repeatable)")
+	computerDrag.Flags().Int64("delay", 0, "Delay before dragging starts in ms")
+	computerDrag.Flags().String("button", "left", "Mouse button: left,middle,right")
+	computerDrag.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	computerRoot.AddCommand(computerClick, computerMove, computerScreenshot, computerType, computerPressKey, computerScroll, computerDrag)
 	browsersCmd.AddCommand(computerRoot)
 
 	// Add flags for create command
@@ -2145,6 +2293,63 @@ func runBrowsersComputerTypeText(cmd *cobra.Command, args []string) error {
 	return b.ComputerTypeText(cmd.Context(), BrowsersComputerTypeTextInput{Identifier: args[0], Text: text, Delay: delay})
 }
 
+func runBrowsersComputerPressKey(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	keys, _ := cmd.Flags().GetStringSlice("key")
+	duration, _ := cmd.Flags().GetInt64("duration")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerPressKey(cmd.Context(), BrowsersComputerPressKeyInput{Identifier: args[0], Keys: keys, Duration: duration, HoldKeys: holdKeys})
+}
+
+func runBrowsersComputerScroll(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	x, _ := cmd.Flags().GetInt64("x")
+	y, _ := cmd.Flags().GetInt64("y")
+	dx, _ := cmd.Flags().GetInt64("delta-x")
+	dy, _ := cmd.Flags().GetInt64("delta-y")
+	dxSet := cmd.Flags().Changed("delta-x")
+	dySet := cmd.Flags().Changed("delta-y")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerScroll(cmd.Context(), BrowsersComputerScrollInput{Identifier: args[0], X: x, Y: y, DeltaX: dx, DeltaXSet: dxSet, DeltaY: dy, DeltaYSet: dySet, HoldKeys: holdKeys})
+}
+
+func runBrowsersComputerDragMouse(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	points, _ := cmd.Flags().GetStringSlice("point")
+	delay, _ := cmd.Flags().GetInt64("delay")
+	button, _ := cmd.Flags().GetString("button")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+
+	// Parse points of form x,y into [][]int64
+	var path [][]int64
+	for _, p := range points {
+		parts := strings.SplitN(p, ",", 2)
+		if len(parts) != 2 {
+			pterm.Error.Printf("invalid --point value: %s (expected x,y)\n", p)
+			return nil
+		}
+		x, err := strconv.ParseInt(strings.TrimSpace(parts[0]), 10, 64)
+		if err != nil {
+			pterm.Error.Printf("invalid x in --point %s: %v\n", p, err)
+			return nil
+		}
+		y, err := strconv.ParseInt(strings.TrimSpace(parts[1]), 10, 64)
+		if err != nil {
+			pterm.Error.Printf("invalid y in --point %s: %v\n", p, err)
+			return nil
+		}
+		path = append(path, []int64{x, y})
+	}
+
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerDragMouse(cmd.Context(), BrowsersComputerDragMouseInput{Identifier: args[0], Path: path, Delay: delay, Button: button, HoldKeys: holdKeys})
+}
+
 func truncateURL(url string, maxLen int) string {
 	if len(url) <= maxLen {
 		return url
diff --git a/cmd/browsers_test.go b/cmd/browsers_test.go
index c589e9e..d68e9b8 100644
--- a/cmd/browsers_test.go
+++ b/cmd/browsers_test.go
@@ -529,6 +529,10 @@ type FakeComputerService struct {
 	ClickMouseFunc        func(ctx context.Context, id string, body kernel.BrowserComputerClickMouseParams, opts ...option.RequestOption) error
 	MoveMouseFunc         func(ctx context.Context, id string, body kernel.BrowserComputerMoveMouseParams, opts ...option.RequestOption) error
 	CaptureScreenshotFunc func(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (*http.Response, error)
+	PressKeyFunc          func(ctx context.Context, id string, body kernel.BrowserComputerPressKeyParams, opts ...option.RequestOption) error
+	ScrollFunc            func(ctx context.Context, id string, body kernel.BrowserComputerScrollParams, opts ...option.RequestOption) error
+	DragMouseFunc         func(ctx context.Context, id string, body kernel.BrowserComputerDragMouseParams, opts ...option.RequestOption) error
+	TypeTextFunc          func(ctx context.Context, id string, body kernel.BrowserComputerTypeTextParams, opts ...option.RequestOption) error
 }
 
 func (f *FakeComputerService) ClickMouse(ctx context.Context, id string, body kernel.BrowserComputerClickMouseParams, opts ...option.RequestOption) error {
@@ -550,6 +554,31 @@ func (f *FakeComputerService) CaptureScreenshot(ctx context.Context, id string,
 	return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"image/png"}}, Body: io.NopCloser(strings.NewReader("pngdata"))}, nil
 }
 
+func (f *FakeComputerService) PressKey(ctx context.Context, id string, body kernel.BrowserComputerPressKeyParams, opts ...option.RequestOption) error {
+	if f.PressKeyFunc != nil {
+		return f.PressKeyFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) Scroll(ctx context.Context, id string, body kernel.BrowserComputerScrollParams, opts ...option.RequestOption) error {
+	if f.ScrollFunc != nil {
+		return f.ScrollFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) DragMouse(ctx context.Context, id string, body kernel.BrowserComputerDragMouseParams, opts ...option.RequestOption) error {
+	if f.DragMouseFunc != nil {
+		return f.DragMouseFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) TypeText(ctx context.Context, id string, body kernel.BrowserComputerTypeTextParams, opts ...option.RequestOption) error {
+	if f.TypeTextFunc != nil {
+		return f.TypeTextFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+
 // --- Tests for Logs ---
 
 func TestBrowsersLogsStream_PrintsEvents(t *testing.T) {
@@ -955,6 +984,46 @@ func TestBrowsersComputerScreenshot_SavesFile(t *testing.T) {
 	assert.Equal(t, "pngDATA", string(data))
 }
 
+func TestBrowsersComputerPressKey_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerPressKey(context.Background(), BrowsersComputerPressKeyInput{Identifier: "id", Keys: []string{"Return", "Shift"}, Duration: 25, HoldKeys: []string{"Ctrl"}})
+	out := outBuf.String()
+	assert.Contains(t, out, "Pressed keys: Return,Shift")
+}
+
+func TestBrowsersComputerScroll_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerScroll(context.Background(), BrowsersComputerScrollInput{Identifier: "id", X: 100, Y: 200, DeltaY: 120, DeltaYSet: true})
+	out := outBuf.String()
+	assert.Contains(t, out, "Scrolled at (100,200)")
+}
+
+func TestBrowsersComputerDragMouse_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	path := [][]int64{{0, 0}, {50, 50}, {100, 100}}
+	_ = b.ComputerDragMouse(context.Background(), BrowsersComputerDragMouseInput{Identifier: "id", Path: path, Delay: 50, Button: string(kernel.BrowserComputerDragMouseParamsButtonLeft)})
+	out := outBuf.String()
+	assert.Contains(t, out, "Dragged mouse over 3 points")
+}
+
 func TestParseViewport_ValidFormats(t *testing.T) {
 	tests := []struct {
 		input       string
diff --git a/go.mod b/go.mod
index 64d18a8..038a2fa 100644
--- a/go.mod
+++ b/go.mod
@@ -59,4 +59,4 @@ require (
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
-replace github.com/onkernel/kernel-go-sdk => github.com/stainless-sdks/kernel-go v0.0.0-20251015181321-ae43476ba10a
+replace github.com/onkernel/kernel-go-sdk => github.com/stainless-sdks/kernel-go v0.0.0-20251016141419-7d31efd9f150
diff --git a/go.sum b/go.sum
index 899774f..a2664f3 100644
--- a/go.sum
+++ b/go.sum
@@ -116,8 +116,8 @@ github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
 github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
 github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
 github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stainless-sdks/kernel-go v0.0.0-20251015181321-ae43476ba10a h1:ZShjGBNUII0dfwC+uC05xMePpxJoQ1qUsus/0CyT8qo=
-github.com/stainless-sdks/kernel-go v0.0.0-20251015181321-ae43476ba10a/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
+github.com/stainless-sdks/kernel-go v0.0.0-20251016141419-7d31efd9f150 h1:cnuASQ/VQBLjDrvNM74lf+QtnIkH0HLhZaQEczwWaYM=
+github.com/stainless-sdks/kernel-go v0.0.0-20251016141419-7d31efd9f150/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=

From 70abf97b05836afc9d835610f8915d1a77c697b4 Mon Sep 17 00:00:00 2001
From: Rafael Garcia <rgarcia2009@gmail.com>
Date: Thu, 16 Oct 2025 10:39:45 -0400
Subject: [PATCH 3/6] readme update

---
 README.md | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/README.md b/README.md
index 7ce3a0d..d4b7036 100644
--- a/README.md
+++ b/README.md
@@ -260,9 +260,30 @@ Create an API key from the [Kernel dashboard](https://dashboard.onkernel.com).
   - `--width <pixels>` - Region width (optional)
   - `--height <pixels>` - Region height (optional)
 - `kernel browsers computer type <id or persistent id>` - Type text on the browser instance
+
   - `--text <text>` - Text to type (required)
   - `--delay <ms>` - Delay in milliseconds between keystrokes (optional)
 
+- `kernel browsers computer press-key <id or persistent id>` - Press one or more keys
+
+  - `--key <key>` - Key symbols to press (repeatable)
+  - `--duration <ms>` - Duration to hold keys down in ms (0=tap)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+
+- `kernel browsers computer scroll <id or persistent id>` - Scroll the mouse wheel
+
+  - `--x <coordinate>` - X coordinate (required)
+  - `--y <coordinate>` - Y coordinate (required)
+  - `--delta-x <pixels>` - Horizontal scroll amount (+right, -left)
+  - `--delta-y <pixels>` - Vertical scroll amount (+down, -up)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+
+- `kernel browsers computer drag-mouse <id or persistent id>` - Drag the mouse along a path
+  - `--point <x,y>` - Add a point as x,y (repeatable)
+  - `--delay <ms>` - Delay before dragging starts in ms
+  - `--button <button>` - Mouse button: left, middle, right (default: left)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+
 ### Extension Management
 
 - `kernel extensions list` - List all uploaded extensions

From d32ec762a81aecdbd23a4ed70c30f9a74461746e Mon Sep 17 00:00:00 2001
From: Rafael Garcia <rgarcia2009@gmail.com>
Date: Thu, 16 Oct 2025 11:46:59 -0400
Subject: [PATCH 4/6] string array not slice

---
 cmd/browsers.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/browsers.go b/cmd/browsers.go
index 69164d9..602e932 100644
--- a/cmd/browsers.go
+++ b/cmd/browsers.go
@@ -1876,7 +1876,7 @@ func init() {
 
 	// computer drag-mouse
 	computerDrag := &cobra.Command{Use: "drag-mouse <id|persistent-id>", Short: "Drag the mouse along a path", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerDragMouse}
-	computerDrag.Flags().StringSlice("point", []string{}, "Add a point as x,y (repeatable)")
+	computerDrag.Flags().StringArray("point", []string{}, "Add a point as x,y (repeatable)")
 	computerDrag.Flags().Int64("delay", 0, "Delay before dragging starts in ms")
 	computerDrag.Flags().String("button", "left", "Mouse button: left,middle,right")
 	computerDrag.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
@@ -2320,7 +2320,7 @@ func runBrowsersComputerScroll(cmd *cobra.Command, args []string) error {
 func runBrowsersComputerDragMouse(cmd *cobra.Command, args []string) error {
 	client := getKernelClient(cmd)
 	svc := client.Browsers
-	points, _ := cmd.Flags().GetStringSlice("point")
+	points, _ := cmd.Flags().GetStringArray("point")
 	delay, _ := cmd.Flags().GetInt64("delay")
 	button, _ := cmd.Flags().GetString("button")
 	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")

From 5a12616280636dbb490a6b3d10f4063807c645f5 Mon Sep 17 00:00:00 2001
From: Rafael Garcia <rgarcia2009@gmail.com>
Date: Fri, 17 Oct 2025 12:17:19 -0400
Subject: [PATCH 5/6] update for new params to drag-mouse

---
 cmd/browsers.go | 24 ++++++++++++++++++------
 go.mod          |  2 +-
 go.sum          |  4 ++--
 3 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/cmd/browsers.go b/cmd/browsers.go
index 602e932..6d27ce7 100644
--- a/cmd/browsers.go
+++ b/cmd/browsers.go
@@ -548,11 +548,13 @@ type BrowsersComputerScrollInput struct {
 }
 
 type BrowsersComputerDragMouseInput struct {
-	Identifier string
-	Path       [][]int64
-	Delay      int64
-	Button     string
-	HoldKeys   []string
+	Identifier      string
+	Path            [][]int64
+	Delay           int64
+	StepDelayMs     int64
+	StepsPerSegment int64
+	Button          string
+	HoldKeys        []string
 }
 
 func (b BrowsersCmd) ComputerClickMouse(ctx context.Context, in BrowsersComputerClickMouseInput) error {
@@ -758,6 +760,12 @@ func (b BrowsersCmd) ComputerDragMouse(ctx context.Context, in BrowsersComputerD
 	if in.Delay > 0 {
 		body.Delay = kernel.Opt(in.Delay)
 	}
+	if in.StepDelayMs > 0 {
+		body.StepDelayMs = kernel.Opt(in.StepDelayMs)
+	}
+	if in.StepsPerSegment > 0 {
+		body.StepsPerSegment = kernel.Opt(in.StepsPerSegment)
+	}
 	if in.Button != "" {
 		body.Button = kernel.BrowserComputerDragMouseParamsButton(in.Button)
 	}
@@ -1878,6 +1886,8 @@ func init() {
 	computerDrag := &cobra.Command{Use: "drag-mouse <id|persistent-id>", Short: "Drag the mouse along a path", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerDragMouse}
 	computerDrag.Flags().StringArray("point", []string{}, "Add a point as x,y (repeatable)")
 	computerDrag.Flags().Int64("delay", 0, "Delay before dragging starts in ms")
+	computerDrag.Flags().Int64("step-delay-ms", 0, "Delay between steps while dragging (ms)")
+	computerDrag.Flags().Int64("steps-per-segment", 0, "Number of move steps per path segment")
 	computerDrag.Flags().String("button", "left", "Mouse button: left,middle,right")
 	computerDrag.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
 
@@ -2322,6 +2332,8 @@ func runBrowsersComputerDragMouse(cmd *cobra.Command, args []string) error {
 	svc := client.Browsers
 	points, _ := cmd.Flags().GetStringArray("point")
 	delay, _ := cmd.Flags().GetInt64("delay")
+	stepDelayMs, _ := cmd.Flags().GetInt64("step-delay-ms")
+	stepsPerSegment, _ := cmd.Flags().GetInt64("steps-per-segment")
 	button, _ := cmd.Flags().GetString("button")
 	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
 
@@ -2347,7 +2359,7 @@ func runBrowsersComputerDragMouse(cmd *cobra.Command, args []string) error {
 	}
 
 	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
-	return b.ComputerDragMouse(cmd.Context(), BrowsersComputerDragMouseInput{Identifier: args[0], Path: path, Delay: delay, Button: button, HoldKeys: holdKeys})
+	return b.ComputerDragMouse(cmd.Context(), BrowsersComputerDragMouseInput{Identifier: args[0], Path: path, Delay: delay, StepDelayMs: stepDelayMs, StepsPerSegment: stepsPerSegment, Button: button, HoldKeys: holdKeys})
 }
 
 func truncateURL(url string, maxLen int) string {
diff --git a/go.mod b/go.mod
index 038a2fa..8eef325 100644
--- a/go.mod
+++ b/go.mod
@@ -59,4 +59,4 @@ require (
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
-replace github.com/onkernel/kernel-go-sdk => github.com/stainless-sdks/kernel-go v0.0.0-20251016141419-7d31efd9f150
+replace github.com/onkernel/kernel-go-sdk => github.com/stainless-sdks/kernel-go v0.0.0-20251017160852-55dc0f22575e
diff --git a/go.sum b/go.sum
index a2664f3..46eb603 100644
--- a/go.sum
+++ b/go.sum
@@ -116,8 +116,8 @@ github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
 github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
 github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
 github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stainless-sdks/kernel-go v0.0.0-20251016141419-7d31efd9f150 h1:cnuASQ/VQBLjDrvNM74lf+QtnIkH0HLhZaQEczwWaYM=
-github.com/stainless-sdks/kernel-go v0.0.0-20251016141419-7d31efd9f150/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
+github.com/stainless-sdks/kernel-go v0.0.0-20251017160852-55dc0f22575e h1:I6/8Hj0xdqem3Ji/MwQESXsR99CyDqlSb9NlzsDXQYw=
+github.com/stainless-sdks/kernel-go v0.0.0-20251017160852-55dc0f22575e/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=

From c5b953cc05912247500befee1073c9af7df24670 Mon Sep 17 00:00:00 2001
From: Rafael Garcia <rgarcia2009@gmail.com>
Date: Fri, 17 Oct 2025 14:54:42 -0400
Subject: [PATCH 6/6] update go.mod to point to official

---
 cmd/deploy.go | 2 +-
 go.mod        | 4 +---
 go.sum        | 4 ++--
 3 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/cmd/deploy.go b/cmd/deploy.go
index 2fb3385..822c35e 100644
--- a/cmd/deploy.go
+++ b/cmd/deploy.go
@@ -262,7 +262,7 @@ func runDeploy(cmd *cobra.Command, args []string) (err error) {
 		File:              file,
 		Version:           kernel.Opt(version),
 		Force:             kernel.Opt(force),
-		EntrypointRelPath: filepath.Base(resolvedEntrypoint),
+		EntrypointRelPath: kernel.Opt(filepath.Base(resolvedEntrypoint)),
 		EnvVars:           envVars,
 	}, option.WithMaxRetries(0))
 	if err != nil {
diff --git a/go.mod b/go.mod
index b072337..769b59e 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/charmbracelet/fang v0.2.0
 	github.com/golang-jwt/jwt/v5 v5.2.2
 	github.com/joho/godotenv v1.5.1
-	github.com/onkernel/kernel-go-sdk v0.14.2
+	github.com/onkernel/kernel-go-sdk v0.15.0
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c
 	github.com/pterm/pterm v0.12.80
 	github.com/samber/lo v1.51.0
@@ -58,5 +58,3 @@ require (
 	golang.org/x/text v0.24.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
-
-replace github.com/onkernel/kernel-go-sdk => github.com/stainless-sdks/kernel-go v0.0.0-20251017160852-55dc0f22575e
diff --git a/go.sum b/go.sum
index 46eb603..4f3e67f 100644
--- a/go.sum
+++ b/go.sum
@@ -91,6 +91,8 @@ github.com/muesli/mango-pflag v0.1.0 h1:UADqbYgpUyRoBja3g6LUL+3LErjpsOwaC9ywvBWe
 github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0=
 github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
 github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
+github.com/onkernel/kernel-go-sdk v0.15.0 h1:gLeZixS9bhOy1WuEk/eFogHUBjG6UJKN2l+OJNNdE+4=
+github.com/onkernel/kernel-go-sdk v0.15.0/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -116,8 +118,6 @@ github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
 github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
 github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
 github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stainless-sdks/kernel-go v0.0.0-20251017160852-55dc0f22575e h1:I6/8Hj0xdqem3Ji/MwQESXsR99CyDqlSb9NlzsDXQYw=
-github.com/stainless-sdks/kernel-go v0.0.0-20251017160852-55dc0f22575e/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=