Add "Move to workspace" commit context-menu item for Commit Cloud

Summary:
Right-clicking a draft commit in the smartlog now offers a "Move to workspace" submenu listing the user's other Commit Cloud workspaces. Picking one dispatches `sl cloud move -d <workspace> -r <hash>` via the standard operation queue, with no confirmation modal — same UX as Hide / Rebase.

The submenu only renders when commit cloud is enabled, the commit is a draft, the workspace's current name is known, and at least two workspaces exist (so there is somewhere to move to). The current workspace is excluded from the destination list.

`sl cloud move` already walks `dag.descendants(removenodes)` and pulls attached bookmarks along (`commitcloud/move.py`), so the new operation passes one `-r <hash>` argument and lets sl handle stack semantics. No multi-select branching, no separate "move stack" menu item, no bookmark toggle — the simplest possible first cut.

Two small supporting changes outside the new files:

- `CommitCloud.tsx` exports `cloudSyncStateAtom` so the context-menu builder in `Commit.tsx` can read workspace state synchronously, and a one-line `registerDisposable` triggers `fetchCommitCloudState` on every `repoInfo` connect so the menu item is available without first requiring the user to open the Download Commits dropdown (the only other consumer of this state).
- `isl-server/src/analytics/eventNames.ts` adds `CommitCloudMoveCommitsOperation` to the `TrackEventName` union.

Reviewed By: evangrayk

Differential Revision: D106259928

fbshipit-source-id: be42b44dfb70f024dd77dd4d87415628b070fa80

Author: mshamis-meta

addons/isl-server/src/analytics/eventNames.ts

@@ -43,6 +43,7 @@ export type TrackEventName =
   | 'CommitCloudSyncBackupStatusCommand'
   | 'CommitCloudChangeWorkspaceOperation'
   | 'CommitCloudCreateWorkspaceOperation'
+  | 'CommitCloudMoveCommitsOperation'
   | 'CommitCloudSyncOperation'
   | 'CreateEmptyInitialCommit'
   | 'ClickGotoTimeButton'

addons/isl/src/Commit.tsx

@@ -26,6 +26,7 @@ import {notEmpty, nullthrows} from 'shared/utils';
 import {AllBookmarksTruncated, Bookmark, Bookmarks, createBookmarkAtCommit} from './Bookmark';
 import {openBrowseUrlForHash, supportsBrowseUrlForHash} from './BrowseRepo';
 import css from './Commit.module.css';
+import {cloudSyncStateAtom} from './CommitCloud';
 import {hasUnsavedEditedCommitMessage} from './CommitInfoView/CommitInfoState';
 import {showComparison} from './ComparisonView/atoms';
 import {Row} from './ComponentUtils';
@@ -65,6 +66,7 @@ import {
 } from './jotaiUtils';
 import {CONFLICT_SIDE_LABELS} from './mergeConflicts/consts';
 import {getAmendToOperation, isAmendToAllowedForCommit} from './operationUtils';
+import {CommitCloudMoveCommitsOperation} from './operations/CommitCloudMoveCommitsOperation';
 import {GotoOperation} from './operations/GotoOperation';
 import {HideOperation} from './operations/HideOperation';
 import {RebaseOperation} from './operations/RebaseOperation';
@@ -479,6 +481,77 @@ export const Commit = memo(
           });
         }
       }
+      if (!isPublic && !actionsPrevented && !inConflicts) {
+        // Render "Move to workspace …" only when cloud is enabled, the
+        // current workspace is known, and at least one other workspace
+        // exists to target. `sl cloud move` itself follows descendants
+        // and bookmarks, so each per-destination submenu item dispatches
+        // exactly the hashes the user has selected — no separate
+        // stack-aware branching is needed beyond multi-select.
+        const cloudSyncState = readAtom(cloudSyncStateAtom);
+        const cloud = cloudSyncState?.value;
+        const currentWorkspace = cloud?.currentWorkspace;
+        const workspaceChoices = cloud?.workspaceChoices;
+        if (
+          cloud != null &&
+          cloud.isDisabled !== true &&
+          currentWorkspace != null &&
+          workspaceChoices != null &&
+          workspaceChoices.length >= 2
+        ) {
+          const destinations = workspaceChoices.filter(ws => ws !== currentWorkspace);
+          if (destinations.length > 0) {
+            // Multi-select: when the right-clicked commit is part of the
+            // current smartlog selection (>1 commits), the operation
+            // moves the whole selection in one `sl cloud move` invocation.
+            // Mirrors the sibling Hide flow above (`isHideMultiSelect`)
+            // so the two context-menu items behave consistently — without
+            // this, the user would right-click on one of N selected
+            // commits, see no visible cue that the menu only acts on
+            // that single commit, and silently lose the other N-1
+            // commits' moves (they'd stay in the source workspace).
+            //
+            // Filter to draft-phase only on the multi-select path. The
+            // outer `!isPublic` gate at the submenu level already
+            // protects the right-clicked commit; this filter extends
+            // the same guarantee to the rest of the selection. `sl
+            // cloud move` rejects public commits server-side, so
+            // dispatching them in a mixed batch would either fail the
+            // whole batch (no commits moved) or silently skip them
+            // (depending on the sl version) — both bad UX. Filtering
+            // client-side makes the behavior deterministic: only
+            // drafts get moved, public commits stay put.
+            const moveSelectedInfos = readAtom(selectedCommitInfos);
+            const isMoveMultiSelect =
+              moveSelectedInfos.length > 1 && moveSelectedInfos.some(c => c.hash === commit.hash);
+            // Use `latestSuccessorUnlessExplicitlyObsolete` instead of raw
+            // hashes so queued operations that mutate these commits before
+            // `cloud move` runs are followed to their successor — except
+            // when the user right-clicked a visibly-obsolete commit, in
+            // which case we lock the action to the exact hash they saw.
+            // Mirrors the sibling `HideOperation` callsite above.
+            const sourcesToMove = isMoveMultiSelect
+              ? moveSelectedInfos
+                  .filter(c => c.phase !== 'public')
+                  .map(c => latestSuccessorUnlessExplicitlyObsolete(c))
+              : [latestSuccessorUnlessExplicitlyObsolete(commit)];
+            items.push({
+              label: isMoveMultiSelect ? (
+                <T replace={{$count: sourcesToMove.length}}>Move $count Commits to workspace</T>
+              ) : (
+                <T>Move to workspace</T>
+              ),
+              type: 'submenu',
+              children: destinations.map(ws => ({
+                label: ws,
+                onClick: () => {
+                  runOperation(new CommitCloudMoveCommitsOperation(ws, sourcesToMove));
+                },
+              })),
+            });
+          }
+        }
+      }
       if (!actionsPrevented && !commit.isDot) {
         items.push({
           label: <T>Goto</T>,

addons/isl/src/CommitCloud.tsx

@@ -31,7 +31,7 @@ import {CommitPreview, dagWithPreviews, useMostRecentPendingOperation} from './p
 import {RelativeDate} from './relativeDate';
 import {repoRootAndCwd} from './repositoryData';
 import {CommitCloudBackupStatus} from './types';
-import {registerDisposable} from './utils';
+import {registerCleanup, registerDisposable} from './utils';
 
 import './CommitCloud.css';
 
@@ -50,7 +50,7 @@ export const commitCloudEnabledAtom = atom(async (get): Promise<boolean> => {
   return enabled;
 });
 
-const cloudSyncStateAtom = atom<Result<CommitCloudSyncState> | null>(null);
+export const cloudSyncStateAtom = atom<Result<CommitCloudSyncState> | null>(null);
 
 registerDisposable(
   cloudSyncStateAtom,
@@ -60,6 +60,19 @@ registerDisposable(
   import.meta.hot,
 );
 
+// Trigger an initial fetch on every repo connect (and reconnect, and cwd
+// change) so consumers outside the Download Commits dropdown — e.g. the
+// commit context-menu "Move to workspace" submenu — can read a populated
+// state without first requiring the user to open that dropdown.
+// `onSetup` fires exactly once per setup transition by design, matching
+// the precedent used elsewhere in this codebase for connect-time fetches
+// (serverAPIState.ts, CommitInfoState.tsx, codeReview/CodeReviewInfo.ts).
+registerCleanup(
+  cloudSyncStateAtom,
+  serverAPI.onSetup(() => serverAPI.postMessage({type: 'fetchCommitCloudState'})),
+  import.meta.hot,
+);
+
 const REFRESH_INTERVAL = 30 * 1000;
 
 export function CommitCloudInfo() {