Update Go SDK and add deploy/app delete commands (#118)

## Summary
This PR updates the Go SDK dependency to the latest version and updates
CLI commands to match SDK interface changes.

## SDK Update
- Updated kernel-go-sdk to v0.37.0
(cb6bef95524033ec889ef9dc2eb8a2c43507ba36)

## Coverage Analysis
A full enumeration of SDK methods and CLI commands was performed. The
SDK update included a breaking change to the `ProfileService.List`
method signature.

## Changes
- **ProfileService.List**: Updated to accept `ProfileListParams`
parameter (breaking change from SDK)
- Added `--limit`, `--offset`, `--query` flags to `kernel profiles list`
command
- Updated ProfilesService interface and tests

## New Flags
- `--limit` for `ProfileListParams.Limit` on `kernel profiles list`
- `--offset` for `ProfileListParams.Offset` on `kernel profiles list`
- `--query` for `ProfileListParams.Query` on `kernel profiles list`

Triggered by:
kernel/kernel-go-sdk@cb6bef9
Reviewer: @dcruzeneil2

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Introduces new deletion flows (including concurrent deletes) that can
remove deployments/apps, so correctness of filtering/confirmation and
error handling is important despite relatively localized CLI changes.
> 
> **Overview**
> Updates `kernel-go-sdk` to `v0.37.0` (and adds `golang.org/x/sync`)
and adapts the CLI to the SDK’s breaking `Profiles.List` signature by
introducing paginated, queryable `kernel profiles list` (`--page`,
`--per-page`, `--query`) with updated tests.
> 
> Adds destructive-management commands: `kernel app delete <app_name>`
(optionally `--version`, with confirmation and concurrent deletion of
all matching deployments) and `kernel deploy delete <deployment_id>`
(with confirmation/`--yes` and not-found handling).
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
74ca985. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: kernel-internal[bot] <260533166+kernel-internal[bot]@users.noreply.github.com>
Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: Rafael Garcia <raf@kernel.sh>
Co-authored-by: Neil Dcruze <neildcruze@Neils-MacBook-Pro-203.local>

Author: 4 people

cmd/app.go

@@ -9,6 +9,7 @@ import (
 	"github.com/pterm/pterm"
 	"github.com/samber/lo"
 	"github.com/spf13/cobra"
+	"golang.org/x/sync/errgroup"
 )
 
 var appCmd = &cobra.Command{
@@ -25,7 +26,14 @@ var appListCmd = &cobra.Command{
 	RunE:  runAppList,
 }
 
-// --- app history subcommand (scaffold)
+var appDeleteCmd = &cobra.Command{
+	Use:   "delete <app_name>",
+	Short: "Delete an app and all its deployments",
+	Long:  "Deletes all deployments for an application. Use --version to scope deletion to a specific version.",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runAppDelete,
+}
+
 var appHistoryCmd = &cobra.Command{
 	Use:   "history <app_name>",
 	Short: "Show deployment history for an application",
@@ -36,8 +44,13 @@ var appHistoryCmd = &cobra.Command{
 func init() {
 	// register subcommands under app
 	appCmd.AddCommand(appListCmd)
+	appCmd.AddCommand(appDeleteCmd)
 	appCmd.AddCommand(appHistoryCmd)
 
+	// Flags for delete
+	appDeleteCmd.Flags().String("version", "", "Only delete deployments for this version (default: all versions)")
+	appDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+
 	// Add optional filters for list
 	appListCmd.Flags().String("name", "", "Filter by application name")
 	appListCmd.Flags().String("version", "", "Filter by version label")
@@ -206,6 +219,76 @@ func runAppList(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
+func runAppDelete(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	appName := args[0]
+	version, _ := cmd.Flags().GetString("version")
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+
+	params := kernel.DeploymentListParams{
+		AppName: kernel.Opt(appName),
+		Limit:   kernel.Opt(int64(100)),
+		Offset:  kernel.Opt(int64(0)),
+	}
+	if version != "" {
+		params.AppVersion = kernel.Opt(version)
+	}
+
+	initial, err := client.Deployments.List(cmd.Context(), params)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if initial == nil || len(initial.Items) == 0 {
+		pterm.Info.Printf("No deployments found for app '%s'\n", appName)
+		return nil
+	}
+
+	if !skipConfirm {
+		scope := "all versions"
+		if version != "" {
+			scope = fmt.Sprintf("version '%s'", version)
+		}
+		msg := fmt.Sprintf("Delete all deployments for app '%s' (%s)? This cannot be undone.", appName, scope)
+		pterm.DefaultInteractiveConfirm.DefaultText = msg
+		ok, _ := pterm.DefaultInteractiveConfirm.Show()
+		if !ok {
+			pterm.Info.Println("Deletion cancelled")
+			return nil
+		}
+	}
+
+	spinner, _ := pterm.DefaultSpinner.Start(fmt.Sprintf("Deleting deployments for app '%s'...", appName))
+	deleted := 0
+
+	for {
+		page, err := client.Deployments.List(cmd.Context(), params)
+		if err != nil {
+			spinner.Fail("Failed to list deployments")
+			return util.CleanedUpSdkError{Err: err}
+		}
+		items := page.Items
+		if len(items) == 0 {
+			break
+		}
+
+		g, gctx := errgroup.WithContext(cmd.Context())
+		for _, dep := range items {
+			g.Go(func() error {
+				return client.Deployments.Delete(gctx, dep.ID)
+			})
+		}
+		if err := g.Wait(); err != nil {
+			spinner.Fail("Failed to delete deployments")
+			return util.CleanedUpSdkError{Err: err}
+		}
+		deleted += len(items)
+		spinner.UpdateText(fmt.Sprintf("Deleted %d deployment(s) so far...", deleted))
+	}
+
+	spinner.Success(fmt.Sprintf("Deleted %d deployment(s) for app '%s'", deleted, appName))
+	return nil
+}
+
 func runAppHistory(cmd *cobra.Command, args []string) error {
 	client := getKernelClient(cmd)
 	appName := args[0]

cmd/deploy.go

@@ -23,6 +23,14 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var deployDeleteCmd = &cobra.Command{
+	Use:   "delete <deployment_id>",
+	Short: "Delete a deployment",
+	Long:  "Stops a running deployment and marks it for deletion. If already stopped or failed, deletes immediately.",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runDeployDelete,
+}
+
 var deployLogsCmd = &cobra.Command{
 	Use:   "logs <deployment_id>",
 	Short: "Stream logs for a deployment",
@@ -65,6 +73,9 @@ func init() {
 	deployLogsCmd.Flags().BoolP("with-timestamps", "t", false, "Include timestamps in each log line")
 	deployCmd.AddCommand(deployLogsCmd)
 
+	deployDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+	deployCmd.AddCommand(deployDeleteCmd)
+
 	deployHistoryCmd.Flags().Int("limit", 20, "Max deployments to return (default 20)")
 	deployHistoryCmd.Flags().Int("per-page", 20, "Items per page (alias of --limit)")
 	deployHistoryCmd.Flags().Int("page", 1, "Page number (1-based)")
@@ -306,6 +317,33 @@ func quoteIfNeeded(s string) string {
 	return s
 }
 
+func runDeployDelete(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	deploymentID := args[0]
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+
+	if !skipConfirm {
+		msg := fmt.Sprintf("Are you sure you want to delete deployment '%s'? This cannot be undone.", deploymentID)
+		pterm.DefaultInteractiveConfirm.DefaultText = msg
+		ok, _ := pterm.DefaultInteractiveConfirm.Show()
+		if !ok {
+			pterm.Info.Println("Deletion cancelled")
+			return nil
+		}
+	}
+
+	if err := client.Deployments.Delete(cmd.Context(), deploymentID); err != nil {
+		if util.IsNotFound(err) {
+			pterm.Warning.Printf("Deployment '%s' not found\n", deploymentID)
+			return nil
+		}
+		return util.CleanedUpSdkError{Err: err}
+	}
+
+	pterm.Success.Printf("Deleted deployment %s\n", deploymentID)
+	return nil
+}
+
 func runDeployLogs(cmd *cobra.Command, args []string) error {
 	client := getKernelClient(cmd)
 

cmd/profiles.go

@@ -12,14 +12,16 @@ import (
 	"github.com/kernel/cli/pkg/util"
 	"github.com/kernel/kernel-go-sdk"
 	"github.com/kernel/kernel-go-sdk/option"
+	"github.com/kernel/kernel-go-sdk/packages/pagination"
 	"github.com/pterm/pterm"
+	"github.com/samber/lo"
 	"github.com/spf13/cobra"
 )
 
 // ProfilesService defines the subset of the Kernel SDK profile client that we use.
 type ProfilesService interface {
 	Get(ctx context.Context, idOrName string, opts ...option.RequestOption) (res *kernel.Profile, err error)
-	List(ctx context.Context, opts ...option.RequestOption) (res *[]kernel.Profile, err error)
+	List(ctx context.Context, query kernel.ProfileListParams, opts ...option.RequestOption) (res *pagination.OffsetPagination[kernel.Profile], err error)
 	Delete(ctx context.Context, idOrName string, opts ...option.RequestOption) (err error)
 	New(ctx context.Context, body kernel.ProfileNewParams, opts ...option.RequestOption) (res *kernel.Profile, err error)
 	Download(ctx context.Context, idOrName string, opts ...option.RequestOption) (res *http.Response, err error)
@@ -31,7 +33,10 @@ type ProfilesGetInput struct {
 }
 
 type ProfilesListInput struct {
-	Output string
+	Output  string
+	Page    int
+	PerPage int
+	Query   string
 }
 
 type ProfilesCreateInput struct {
@@ -60,28 +65,56 @@ func (p ProfilesCmd) List(ctx context.Context, in ProfilesListInput) error {
 		return fmt.Errorf("unsupported --output value: use 'json'")
 	}
 
+	page := in.Page
+	perPage := in.PerPage
+	if page <= 0 {
+		page = 1
+	}
+	if perPage <= 0 {
+		perPage = 20
+	}
+
 	if in.Output != "json" {
 		pterm.Info.Println("Fetching profiles...")
 	}
-	items, err := p.profiles.List(ctx)
+
+	params := kernel.ProfileListParams{}
+	if in.Query != "" {
+		params.Query = kernel.Opt(in.Query)
+	}
+	params.Limit = kernel.Opt(int64(perPage + 1))
+	params.Offset = kernel.Opt(int64((page - 1) * perPage))
+
+	result, err := p.profiles.List(ctx, params)
 	if err != nil {
 		return util.CleanedUpSdkError{Err: err}
 	}
 
+	var items []kernel.Profile
+	if result != nil {
+		items = result.Items
+	}
+
+	hasMore := len(items) > perPage
+	if hasMore {
+		items = items[:perPage]
+	}
+	itemsThisPage := len(items)
+
 	if in.Output == "json" {
-		if items == nil || len(*items) == 0 {
+		if len(items) == 0 {
 			fmt.Println("[]")
 			return nil
 		}
-		return util.PrintPrettyJSONSlice(*items)
+		return util.PrintPrettyJSONSlice(items)
 	}
 
-	if items == nil || len(*items) == 0 {
+	if len(items) == 0 {
 		pterm.Info.Println("No profiles found")
 		return nil
 	}
 	rows := pterm.TableData{{"Profile ID", "Name", "Created At", "Updated At", "Last Used At"}}
-	for _, prof := range *items {
+	for _, prof := range items {
 		name := prof.Name
 		if name == "" {
 			name = "-"
@@ -95,6 +128,17 @@ func (p ProfilesCmd) List(ctx context.Context, in ProfilesListInput) error {
 		})
 	}
 	PrintTableNoPad(rows, true)
+
+	pterm.Printf("\nPage: %d  Per-page: %d  Items this page: %d  Has more: %s\n", page, perPage, itemsThisPage, lo.Ternary(hasMore, "yes", "no"))
+	if hasMore {
+		nextPage := page + 1
+		nextCmd := fmt.Sprintf("kernel profile list --page %d --per-page %d", nextPage, perPage)
+		if in.Query != "" {
+			nextCmd += fmt.Sprintf(" --query \"%s\"", in.Query)
+		}
+		pterm.Printf("Next: %s\n", nextCmd)
+	}
+
 	return nil
 }
 
@@ -299,6 +343,9 @@ func init() {
 	profilesCmd.AddCommand(profilesDownloadCmd)
 
 	profilesListCmd.Flags().StringP("output", "o", "", "Output format: json for raw API response")
+	profilesListCmd.Flags().Int("per-page", 20, "Items per page (default 20)")
+	profilesListCmd.Flags().Int("page", 1, "Page number (1-based)")
+	profilesListCmd.Flags().String("query", "", "Search profiles by name or ID")
 	profilesGetCmd.Flags().StringP("output", "o", "", "Output format: json for raw API response")
 	profilesCreateCmd.Flags().StringP("output", "o", "", "Output format: json for raw API response")
 	profilesCreateCmd.Flags().String("name", "", "Optional unique profile name")
@@ -310,9 +357,18 @@ func init() {
 func runProfilesList(cmd *cobra.Command, args []string) error {
 	client := getKernelClient(cmd)
 	output, _ := cmd.Flags().GetString("output")
+	perPage, _ := cmd.Flags().GetInt("per-page")
+	page, _ := cmd.Flags().GetInt("page")
+	query, _ := cmd.Flags().GetString("query")
+
 	svc := client.Profiles
 	p := ProfilesCmd{profiles: &svc}
-	return p.List(cmd.Context(), ProfilesListInput{Output: output})
+	return p.List(cmd.Context(), ProfilesListInput{
+		Output:  output,
+		Page:    page,
+		PerPage: perPage,
+		Query:   query,
+	})
 }
 
 func runProfilesGet(cmd *cobra.Command, args []string) error {