feat(tui): add bucket and object deletion with confirmation

This change implements the ability to delete GCS buckets, objects, and directories (prefixes) directly from the TUI. A confirmation dialog has been added to prevent accidental deletions, especially for directories where the deletion is performed recursively.

Summary of changes:
- Added DeleteBucket, DeleteObject, and DeletePrefix to GCS client
- Added viewDeleteConfirm state and confirmation view in TUI
- Implemented 'x' keybinding for deletion in buckets and objects views
- Added unit tests for GCS client deletion methods
- Added integration tests for TUI deletion workflow

Author: Idan Attias

internal/gcs/client.go

@@ -539,6 +539,41 @@ func (c *Client) ListBucketsPage(ctx context.Context, projectID string, pageToke
 	return buckets, nextToken, nil
 }
 
+// DeleteBucket deletes a GCS bucket.
+func (c *Client) DeleteBucket(ctx context.Context, bucketName string) error {
+	if err := c.storageClient.Bucket(bucketName).Delete(ctx); err != nil {
+		return fmt.Errorf("failed to delete bucket %q: %w", bucketName, err)
+	}
+	return nil
+}
+
+// DeleteObject deletes a specific GCS object.
+func (c *Client) DeleteObject(ctx context.Context, bucketName, objectName string) error {
+	if err := c.storageClient.Bucket(bucketName).Object(objectName).Delete(ctx); err != nil {
+		return fmt.Errorf("failed to delete object %q in %q: %w", objectName, bucketName, err)
+	}
+	return nil
+}
+
+// DeletePrefix deletes all objects under a prefix.
+func (c *Client) DeletePrefix(ctx context.Context, bucketName, prefix string) error {
+	it := c.storageClient.Bucket(bucketName).Objects(ctx, &storage.Query{Prefix: prefix})
+	for {
+		attrs, err := it.Next()
+		if errors.Is(err, iterator.Done) {
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("failed to list objects for prefix %q in %q: %w", prefix, bucketName, err)
+		}
+
+		if err := c.storageClient.Bucket(bucketName).Object(attrs.Name).Delete(ctx); err != nil {
+			return fmt.Errorf("failed to delete object %q in %q: %w", attrs.Name, bucketName, err)
+		}
+	}
+	return nil
+}
+
 // ListObjectsPage retrieves a specific page of object names and common prefixes (folders).
 func (c *Client) ListObjectsPage(ctx context.Context, bucketName, prefix, pageToken string, pageSize int) (*ObjectList, string, error) {
 	it := c.storageClient.Bucket(bucketName).Objects(ctx, &storage.Query{

internal/gcs/client_test.go

@@ -681,3 +681,72 @@ func TestClient_DownloadPrefixAsZip_ErrorsAndProgress(t *testing.T) {
 		assert.Equal(t, currentProgress, totalProgress)
 	})
 }
+
+func TestClient_DeleteBucket(t *testing.T) {
+	bucketName := "delete-bucket"
+	server, client := setupTestServer(t, []fakestorage.Object{})
+	server.CreateBucketWithOpts(fakestorage.CreateBucketOpts{Name: bucketName})
+
+	t.Run("Success", func(t *testing.T) {
+		err := client.DeleteBucket(context.Background(), bucketName)
+		assert.NilError(t, err)
+
+		_, err = client.GetBucketMetadata(context.Background(), bucketName)
+		assert.Assert(t, err != nil)
+	})
+
+	t.Run("Non-existent bucket", func(t *testing.T) {
+		err := client.DeleteBucket(context.Background(), "no-bucket")
+		assert.Assert(t, err != nil)
+	})
+}
+
+func TestClient_DeleteObject(t *testing.T) {
+	bucketName := "obj-delete-bucket"
+	objectName := "delete-me.txt"
+	_, client := setupTestServer(t, []fakestorage.Object{
+		{ObjectAttrs: fakestorage.ObjectAttrs{BucketName: bucketName, Name: objectName}},
+	})
+
+	t.Run("Success", func(t *testing.T) {
+		err := client.DeleteObject(context.Background(), bucketName, objectName)
+		assert.NilError(t, err)
+
+		_, err = client.GetObjectMetadata(context.Background(), bucketName, objectName)
+		assert.Assert(t, err != nil)
+	})
+
+	t.Run("Non-existent object", func(t *testing.T) {
+		err := client.DeleteObject(context.Background(), bucketName, "no-obj")
+		assert.Assert(t, err != nil)
+	})
+}
+
+func TestClient_DeletePrefix(t *testing.T) {
+	bucketName := "prefix-delete-bucket"
+	objects := []fakestorage.Object{
+		{ObjectAttrs: fakestorage.ObjectAttrs{BucketName: bucketName, Name: "folder/file1.txt"}},
+		{ObjectAttrs: fakestorage.ObjectAttrs{BucketName: bucketName, Name: "folder/sub/file2.txt"}},
+		{ObjectAttrs: fakestorage.ObjectAttrs{BucketName: bucketName, Name: "other.txt"}},
+	}
+	server, client := setupTestServer(t, objects)
+
+	t.Run("Success", func(t *testing.T) {
+		err := client.DeletePrefix(context.Background(), bucketName, "folder/")
+		assert.NilError(t, err)
+
+		// folder objects should be gone
+		it := server.Client().Bucket(bucketName).Objects(context.Background(), nil)
+		count := 0
+		for {
+			attrs, err := it.Next()
+			if errors.Is(err, iterator.Done) {
+				break
+			}
+			assert.NilError(t, err)
+			assert.Assert(t, attrs.Name == "other.txt")
+			count++
+		}
+		assert.Equal(t, count, 1)
+	})
+}

internal/testutil/testutil.go

@@ -79,7 +79,7 @@ func CreateConfigFile(t *testing.T, projects []string, downloadDir string) strin
 }
 
 // SetupTestApp initializes the full TUI application using a fake GCS server.
-func SetupTestApp(t *testing.T, initialObjects []fakestorage.Object, port uint16, projectIDs []string, downloadDir string) *teatest.TestModel {
+func SetupTestApp(t *testing.T, initialObjects []fakestorage.Object, port uint16, projectIDs []string, downloadDir string) (*teatest.TestModel, *fakestorage.Server) {
 	t.Helper()
 
 	// Ensure tests produce deterministic colored output regardless of environment
@@ -112,7 +112,7 @@ func SetupTestApp(t *testing.T, initialObjects []fakestorage.Object, port uint16
 		tm.WaitFinished(t, teatest.WithFinalTimeout(time.Second))
 	})
 
-	return tm
+	return tm, server
 }
 
 // CreateMockTar creates a tar archive in memory with the given files map (name -> content).

internal/tui/commands.go

@@ -254,6 +254,27 @@ func (m *Model) createObject(bucketName, objectName string) tea.Cmd {
 	}
 }
 
+func (m *Model) deleteBucket(bucketName string) tea.Cmd {
+	return func() tea.Msg {
+		err := m.client.DeleteBucket(context.Background(), bucketName)
+		return DeleteMsg{Name: bucketName, Err: err}
+	}
+}
+
+func (m *Model) deleteObject(bucketName, objectName string) tea.Cmd {
+	return func() tea.Msg {
+		err := m.client.DeleteObject(context.Background(), bucketName, objectName)
+		return DeleteMsg{Name: objectName, Err: err}
+	}
+}
+
+func (m *Model) deletePrefix(bucketName, prefix string) tea.Cmd {
+	return func() tea.Msg {
+		err := m.client.DeletePrefix(context.Background(), bucketName, prefix)
+		return DeleteMsg{Name: prefix, Err: err}
+	}
+}
+
 func (m *Model) startDownloadTaskDirectly(task downloadTask) (*Model, tea.Cmd) {
 	jobNum := task.jobNum
 	m.activeDownloads++

internal/tui/keys.go

@@ -23,6 +23,7 @@ type keyMap struct {
 	Refresh      key.Binding
 	Search       key.Binding
 	Create       key.Binding
+	Delete       key.Binding
 	Esc          key.Binding
 	Help         key.Binding
 	Messages     key.Binding
@@ -49,6 +50,7 @@ func (k keyMap) OrderedHelp() []key.Binding {
 		k.Open,
 		k.Edit,
 		k.Create,
+		k.Delete,
 		k.Search,
 		k.Refresh,
 		k.Esc,
@@ -70,10 +72,10 @@ func (k keyMap) OrderedHelp() []key.Binding {
 // FullHelp returns keybindings for the expanded help view.
 func (k keyMap) FullHelp() [][]key.Binding {
 	return [][]key.Binding{
-		{k.Up, k.Down, k.Left, k.Right, k.Home},                                       // Navigation
-		{k.Top, k.Bottom, k.PageUp, k.PageDown, k.HalfPageUp, k.HalfPageDown},         // Pagination
-		{k.Select, k.Download, k.Copy, k.Open, k.Edit, k.Create, k.Refresh, k.Search}, // Actions
-		{k.Esc, k.Info, k.Versions, k.Messages, k.Help, k.Quit},                       // App
+		{k.Up, k.Down, k.Left, k.Right, k.Home},                                                 // Navigation
+		{k.Top, k.Bottom, k.PageUp, k.PageDown, k.HalfPageUp, k.HalfPageDown},                   // Pagination
+		{k.Select, k.Download, k.Copy, k.Open, k.Edit, k.Create, k.Delete, k.Refresh, k.Search}, // Actions
+		{k.Esc, k.Info, k.Versions, k.Messages, k.Help, k.Quit},                                 // App
 	}
 }
 
@@ -150,6 +152,10 @@ var keys = keyMap{
 		key.WithKeys("n"),
 		key.WithHelp("n", "new"),
 	),
+	Delete: key.NewBinding(
+		key.WithKeys("x"),
+		key.WithHelp("x", "delete"),
+	),
 	Search: key.NewBinding(
 		key.WithKeys("/"),
 		key.WithHelp("/", "filter"),

internal/tui/model.go

@@ -19,6 +19,7 @@ const (
 	viewBuckets viewState = iota
 	viewObjects
 	viewDownloadConfirm
+	viewDeleteConfirm
 )
 
 type downloadTask struct {
@@ -77,6 +78,12 @@ type Model struct {
 	downloadQueue           []downloadTask
 	jobProgress             map[int]*JobProgress
 
+	// Deletion State
+	pendingDeleteBucket   string
+	pendingDeleteObject   string
+	pendingDeletePrefix   string
+	pendingDeleteIsBucket bool
+
 	// Buckets View
 	projects             []gcs.ProjectBuckets
 	collapsedProjects    map[string]struct{}

internal/tui/model_test.go

@@ -130,6 +130,18 @@ func (m *mockGCSClient) UploadObject(_ context.Context, bucket, object, src stri
 	return nil
 }
 
+func (m *mockGCSClient) DeleteBucket(_ context.Context, _ string) error {
+	return nil
+}
+
+func (m *mockGCSClient) DeleteObject(_ context.Context, _, _ string) error {
+	return nil
+}
+
+func (m *mockGCSClient) DeletePrefix(_ context.Context, _, _ string) error {
+	return nil
+}
+
 func (m *mockGCSClient) DownloadPrefixAsZip(_ context.Context, _, _, _ string, _ gcs.ProgressFunc) error {
 	return nil
 }

internal/tui/types.go

@@ -40,6 +40,12 @@ type GCSClient interface {
 	NewReader(ctx context.Context, bucketName, objectName string) (io.ReadCloser, error)
 	// NewReaderAt returns an io.ReaderAt for an object.
 	NewReaderAt(ctx context.Context, bucketName, objectName string) io.ReaderAt
+	// DeleteBucket deletes a GCS bucket.
+	DeleteBucket(ctx context.Context, bucketName string) error
+	// DeleteObject deletes a specific GCS object.
+	DeleteObject(ctx context.Context, bucketName, objectName string) error
+	// DeletePrefix deletes all objects under a prefix.
+	DeletePrefix(ctx context.Context, bucketName, prefix string) error
 	// ListObjectVersions retrieves all versions of a specific object.
 	ListObjectVersions(ctx context.Context, bucketName, objectName string) ([]gcs.ObjectMetadata, error)
 	// IsVersioningEnabled checks if versioning is enabled for a specific bucket.
@@ -154,6 +160,12 @@ type CreateMsg struct {
 	Err  error
 }
 
+// DeleteMsg is sent when a deletion operation completes.
+type DeleteMsg struct {
+	Name string
+	Err  error
+}
+
 // ClearStatusMsg is sent to clear the status bar.
 type ClearStatusMsg struct {
 	ID string

internal/tui/update.go

@@ -50,6 +50,8 @@ func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		return m.handleObjectVersionsMsg(msg)
 	case CreateMsg:
 		return m.handleCreateMsg(msg)
+	case DeleteMsg:
+		return m.handleDeleteMsg(msg)
 	case DebouncePreviewMsg:
 		if msg.CursorVersion == m.cursorVersion {
 			return m, msg.FetchCmd
@@ -652,6 +654,10 @@ func (m *Model) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		return m.handleDownloadConfirmKey(msg)
 	}
 
+	if m.state == viewDeleteConfirm {
+		return m.handleDeleteConfirmKey(msg)
+	}
+
 	switch {
 	case key.Matches(msg, keys.Help):
 		m.showHelp = true
@@ -702,6 +708,9 @@ func (m *Model) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	case key.Matches(msg, keys.Create):
 		return m.handleCreateKey()
 
+	case key.Matches(msg, keys.Delete):
+		return m.handleDeleteKey()
+
 	case key.Matches(msg, keys.Select):
 		return m.handleSelectKey()
 
@@ -1642,3 +1651,87 @@ func (m *Model) handleCreateMsg(msg CreateMsg) (tea.Model, tea.Cmd) {
 	nm, refreshCmd := m.handleRefreshKey(true)
 	return nm, tea.Batch(statusCmd, refreshCmd)
 }
+
+func (m *Model) handleDeleteKey() (tea.Model, tea.Cmd) {
+	switch m.state {
+	case viewBuckets:
+		filtered := m.filteredBuckets()
+		if m.cursor < 0 || m.cursor >= len(filtered) {
+			return m, nil
+		}
+		item := filtered[m.cursor]
+		if item.IsProject {
+			return m, nil // Cannot delete projects
+		}
+		m.pendingDeleteBucket = item.BucketName
+		m.pendingDeleteIsBucket = true
+		m.state = viewDeleteConfirm
+		return m, nil
+
+	case viewObjects:
+		if len(m.selected) > 1 {
+			return m, m.AddMessage(LevelError, "Multi-delete not supported yet", 0, "")
+		}
+
+		currentPrefixes, currentObjects, _ := m.filteredObjects()
+		if m.cursor < 0 || m.cursor >= len(currentPrefixes)+len(currentObjects) {
+			return m, nil
+		}
+
+		m.pendingDeleteBucket = m.currentBucket
+		m.pendingDeleteIsBucket = false
+		if m.cursor < len(currentPrefixes) {
+			m.pendingDeletePrefix = currentPrefixes[m.cursor].Name
+			m.pendingDeleteObject = ""
+		} else {
+			m.pendingDeleteObject = currentObjects[m.cursor-len(currentPrefixes)].Name
+			m.pendingDeletePrefix = ""
+		}
+		m.state = viewDeleteConfirm
+		return m, nil
+	}
+	return m, nil
+}
+
+func (m *Model) handleDeleteConfirmKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "y", "Y":
+		var cmd tea.Cmd
+		if m.pendingDeleteIsBucket {
+			cmd = m.deleteBucket(m.pendingDeleteBucket)
+		} else if m.pendingDeletePrefix != "" {
+			cmd = m.deletePrefix(m.pendingDeleteBucket, m.pendingDeletePrefix)
+		} else {
+			cmd = m.deleteObject(m.pendingDeleteBucket, m.pendingDeleteObject)
+		}
+		m.state = viewObjects
+		if m.pendingDeleteIsBucket {
+			m.state = viewBuckets
+		}
+		m.pendingDeleteBucket = ""
+		m.pendingDeleteObject = ""
+		m.pendingDeletePrefix = ""
+		return m, cmd
+	default:
+		if m.pendingDeleteIsBucket {
+			m.state = viewBuckets
+		} else {
+			m.state = viewObjects
+		}
+		m.pendingDeleteBucket = ""
+		m.pendingDeleteObject = ""
+		m.pendingDeletePrefix = ""
+		return m, nil
+	}
+}
+
+func (m *Model) handleDeleteMsg(msg DeleteMsg) (tea.Model, tea.Cmd) {
+	if msg.Err != nil {
+		statusCmd := m.AddMessage(LevelError, fmt.Sprintf("Deletion failed: %v", msg.Err), 0, "")
+		return m, statusCmd
+	}
+
+	statusCmd := m.AddMessage(LevelInfo, fmt.Sprintf("Deleted %s", msg.Name), 0, "")
+	nm, refreshCmd := m.handleRefreshKey(true)
+	return nm, tea.Batch(statusCmd, refreshCmd)
+}