### Full Code

```js
import * as actions from "monaco-editor/esm/vs/platform/actions/common/actions";

let menus = actions.MenuRegistry._menuItems
let contextMenuEntry = [...menus].find(entry => entry[0]._debugName == "EditorContext")
let contextMenuLinks = contextMenuEntry[1]

let removableIds = ["editor.action.clipboardCopyAction", "editor.action.clipboardPasteAction"]

let removeById = (list, ids) => {
  let node = list._first
  do {
    let shouldRemove = ids.includes(node.element?.command?.id)
    if (shouldRemove) { list._remove(node) }
  } while ((node = node.next))
}

removeById(contextMenuLinks, removableIds)
```

### Walkthrough

You can access the available menu functions from `MenuRegistry` inside [`actions.js`][1]:

```js
import * as actions from "monaco-editor/esm/vs/platform/actions/common/actions"
let menus = actions.MenuRegistry._menuItems
```

This will provide a list of all menu types:  i.e.  
`["MenubarEditMenu", "CommandPalette", "EditorContext", ...]`

To access and modify the context menu specifically, we can find it in the menu map:

```js
let contextMenuEntry = [...menus].find(entry => entry[0]._debugName == "EditorContext")
let contextMenuLinks = contextMenuEntry[1]
```

The menu items are of type [`LinkedList`][2], where each `node` contains an `element` and a reference to the `prev` and `next` node, but it comes with some utility methods that make it easier to reason about.

So if you want to list all commands, you can do this:

```js
let allCommandIds = [...contextMenuLinks].map(el => el.command?.id)
```

Using that, identify the list of commands you want to pluck out ahead of time - in our case:

```js
let removableIds = [
  "editor.action.clipboardCopyAction",
  "editor.action.clipboardPasteAction",
]
```

Next we need to identify and remove the nodes with those ids.  The iterator returns the [<code>node.<b>element</b></code>][3], but the [`_remove()`][4] function takes in the entire node, so we'll have to iterate a little different than before.  Here's a function that loops through all nodes and removes each if 


We'll then get all the nodes we want to remove:

```js
let removeById = (list, ids) => {
  let node = list._first;
  do {
    let shouldRemove = ids.includes(node.element?.command?.id)
    if (shouldRemove) { list._remove(node) }
  } while ((node = node.next))
}
```

And then call like this:

```
removeById(contextMenuLinks, removableIds)
```

### Demo

[![Screenshot Example][5]][5]

### Further Reading

* [Remove 'context menu' items (not CSS) #1567][6]
* [How can I customize context menu? I want to delete 'Go to definition' #1280][7]
* [How to hide the “Command Palette” item from the list of actions in Monaco Editor][8]
* [How do I remove options from the contextmenu for monaco-editor?][9]


  [1]: https://github.com/microsoft/vscode/blob/1.52.1/src/vs/platform/actions/common/actions.ts
  [2]: https://github.com/microsoft/vscode/blob/1.52.1/src/vs/base/common/linkedList.ts
  [3]: https://github.com/microsoft/vscode/blob/1.52.1/src/vs/base/common/linkedList.ts#L130
  [4]: https://github.com/microsoft/vscode/blob/1.52.1/src/vs/base/common/linkedList.ts#L100
  [5]: https://i.stack.imgur.com/s791e.png
  [6]: https://github.com/microsoft/monaco-editor/issues/1567
  [7]: https://github.com/microsoft/monaco-editor/issues/1280
  [8]: https://stackoverflow.com/q/52597274/1366033
  [9]: https://stackoverflow.com/q/62659865/1366033

I am using monaco-editor, i see that cut and copy is added in the context menu in later versions. i want to remove these two options from context menu. Please let me know how can i achieve it?

Disable Cut and Copy in context menu in Monaco editor

My personal impression is that actions are kinda evolved commands. Commands have been introduced first and later it was recognized that more functionality was needed (e.g. context menu integration), so `Action` was created. For compatibility reasons `Command` could not be removed by then, so both still exist today.

In a monaco [editor instance][1], you can call [`addAction`][2] or[`addCommand`][3]

Both provide the ability to execute a function based on key events

The online playground offers examples of how to [add a command][4] or how to [add an action][5] to an editor instance.


**Example of an Action**

```js
editor.addAction({
	id: 'my-unique-id',
	label: 'My Label!!!',
	keybindings: [monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter],
	run: function() { alert('action called') }
});
```


**Example of a Command**

```js
editor.addCommand(
  monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter,
  function() { alert('called command') }
)
```



The documentation describes the type definitions, properties, and methods.

However, it's lacking when it comes to providing the context of when to use each, where they show up within the editor, and what each provides.

What's the difference between actions and commands?

[1]: https://microsoft.github.io/monaco-editor/api/interfaces/monaco.editor.istandalonecodeeditor.html
[2]: https://microsoft.github.io/monaco-editor/api/interfaces/monaco.editor.istandalonecodeeditor.html#addaction
[3]: https://microsoft.github.io/monaco-editor/api/interfaces/monaco.editor.istandalonecodeeditor.html#addcommand
[4]: https://microsoft.github.io/monaco-editor/playground.html#interacting-with-the-editor-adding-a-command-to-an-editor-instance
[5]: https://microsoft.github.io/monaco-editor/playground.html#interacting-with-the-editor-adding-an-action-to-an-editor-instance

