add terminal right click menu

Author: icecrasher321

apps/desktop/src/main/window.test.ts

@@ -22,6 +22,12 @@ describe('resolvePermission', () => {
     expect(resolvePermission('clipboard-sanitized-write', '', APP)).toBe(false)
   })
 
+  it('allows clipboard reads from the trusted origin only, so terminal Paste works', () => {
+    expect(resolvePermission('clipboard-read', APP, APP)).toBe(true)
+    expect(resolvePermission('clipboard-read', 'https://evil.example', APP)).toBe(false)
+    expect(resolvePermission('clipboard-read', '', APP)).toBe(false)
+  })
+
   it('default-denies everything else, including media and unknown future permissions', () => {
     for (const permission of [
       'media',

apps/desktop/src/main/window.ts

@@ -51,9 +51,15 @@ export function createSecureWebPreferences(
 }
 
 /**
- * The permission matrix: sanitized clipboard writes for the trusted app
- * origin, default-deny for everything else including unknown future
- * permissions (media/camera/microphone stay denied).
+ * The permission matrix: clipboard access for the trusted app origin,
+ * default-deny for everything else including unknown future permissions
+ * (media/camera/microphone stay denied).
+ *
+ * Clipboard reads are what the terminal's Paste action runs on — xterm has no
+ * native paste target to fall back to, so a denied read is a Paste that fails.
+ * The grant is scoped to the app's own origin, which already reaches far more
+ * sensitive surfaces through the preload bridge, so it widens nothing that a
+ * compromise of that origin would not already own.
  */
 export function resolvePermission(
   permission: string,
@@ -63,7 +69,7 @@ export function resolvePermission(
   if (!requestingOrigin || requestingOrigin !== appOrigin) {
     return false
   }
-  return permission === 'clipboard-sanitized-write'
+  return permission === 'clipboard-sanitized-write' || permission === 'clipboard-read'
 }
 
 function originOf(raw: string): string {

apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/terminal-session/terminal-context-menu.tsx

@@ -0,0 +1,118 @@
+'use client'
+
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+} from '@sim/emcn'
+import { Clipboard, Duplicate, Plus, SelectAll, Settings, Trash, X } from '@sim/emcn/icons'
+
+interface TerminalContextMenuProps {
+  isOpen: boolean
+  position: { x: number; y: number }
+  menuRef: React.RefObject<HTMLDivElement | null>
+  onClose: () => void
+  /** Whether the terminal currently has a selection, gating Copy. */
+  hasSelection: boolean
+  onCopy: () => void
+  onPaste: () => void
+  onSelectAll: () => void
+  onClear: () => void
+  onNewTab: () => void
+  onOpenSettings: () => void
+  /** Closes this terminal. Absent when it is the only one left. */
+  onCloseTerminal?: () => void
+}
+
+/**
+ * Right-click menu for the terminal surface.
+ *
+ * xterm.js renders into a canvas and drives input through an offscreen
+ * textarea, so the shell's native editable menu (Cut/Copy/Paste/Select All)
+ * targets that empty textarea and does nothing useful. These actions go
+ * through xterm's own selection and the PTY instead, which is what makes them
+ * work — and Cut is absent because a terminal's scrollback cannot be cut from.
+ *
+ * Every action is scoped to the terminal that was right-clicked rather than
+ * "the active one", so the menu stays correct no matter which terminal owns
+ * focus. Positioning mirrors the sidebar's context menu: a zero-size trigger
+ * pinned at the cursor, so the platform's dropdown owns the popover behaviour
+ * (focus, dismissal, collision handling) rather than a hand-rolled one.
+ */
+export function TerminalContextMenu({
+  isOpen,
+  position,
+  menuRef,
+  onClose,
+  hasSelection,
+  onCopy,
+  onPaste,
+  onSelectAll,
+  onClear,
+  onNewTab,
+  onOpenSettings,
+  onCloseTerminal,
+}: TerminalContextMenuProps) {
+  const run = (action: () => void) => () => {
+    action()
+    onClose()
+  }
+
+  return (
+    <DropdownMenu open={isOpen} onOpenChange={(open) => !open && onClose()} modal={false}>
+      <DropdownMenuTrigger asChild>
+        <div
+          style={{
+            position: 'fixed',
+            left: `${position.x}px`,
+            top: `${position.y}px`,
+            width: '1px',
+            height: '1px',
+            pointerEvents: 'none',
+          }}
+        />
+      </DropdownMenuTrigger>
+      <DropdownMenuContent ref={menuRef} align='start' side='bottom' sideOffset={4}>
+        <DropdownMenuItem disabled={!hasSelection} onSelect={run(onCopy)}>
+          <Duplicate />
+          Copy
+        </DropdownMenuItem>
+        <DropdownMenuItem onSelect={run(onPaste)}>
+          <Clipboard />
+          Paste
+        </DropdownMenuItem>
+        <DropdownMenuItem onSelect={run(onSelectAll)}>
+          <SelectAll />
+          Select all
+        </DropdownMenuItem>
+        <DropdownMenuItem onSelect={run(onClear)}>
+          <Trash />
+          Clear
+        </DropdownMenuItem>
+
+        <DropdownMenuSeparator />
+
+        <DropdownMenuItem onSelect={run(onNewTab)}>
+          <Plus />
+          New tab
+        </DropdownMenuItem>
+        <DropdownMenuItem onSelect={run(onOpenSettings)}>
+          <Settings />
+          Terminal settings
+        </DropdownMenuItem>
+
+        {onCloseTerminal && (
+          <>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem onSelect={run(onCloseTerminal)}>
+              <X />
+              Close terminal
+            </DropdownMenuItem>
+          </>
+        )}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  )
+}

apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/terminal-session/terminal-session.tsx

@@ -8,7 +8,7 @@ import {
   useRef,
   useState,
 } from 'react'
-import { cn, TabStrip, type TabStripItem } from '@sim/emcn'
+import { cn, TabStrip, type TabStripItem, toast } from '@sim/emcn'
 import { Loader, TerminalWindow } from '@sim/emcn/icons'
 import { createLogger } from '@sim/logger'
 import { FitAddon } from '@xterm/addon-fit'
@@ -31,8 +31,10 @@ import {
   writeToTerminal,
 } from '@/lib/terminal/transport'
 import { useMothershipResources } from '@/app/workspace/[workspaceId]/home/components/mothership-resources-context'
+import { TerminalContextMenu } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/terminal-session/terminal-context-menu'
 import { ContextMenu } from '@/app/workspace/[workspaceId]/w/components/sidebar/components/workflow-list/components/context-menu/context-menu'
 import { useContextMenu } from '@/app/workspace/[workspaceId]/w/components/sidebar/hooks'
+import { useSettingsNavigation } from '@/hooks/use-settings-navigation'
 import { useCopilotTerminalStore } from '@/stores/copilot-terminal/store'
 
 const logger = createLogger('TerminalSession')
@@ -132,7 +134,16 @@ function attachWebglRenderer(terminal: Terminal): void {
  * visible, and only it is measured — `fit()` against a hidden element reads a
  * zero-sized box and would resize the PTY to nonsense.
  */
-function TerminalView({ terminalId, active }: { terminalId: string; active: boolean }) {
+function TerminalView({
+  terminalId,
+  active,
+  canClose,
+}: {
+  terminalId: string
+  active: boolean
+  canClose: boolean
+}) {
+  const { navigateToSettings } = useSettingsNavigation()
   const { resolvedTheme } = useTheme()
   const hostRef = useRef<HTMLDivElement>(null)
   const terminalRef = useRef<Terminal | null>(null)
@@ -264,13 +275,99 @@ function TerminalView({ terminalId, active }: { terminalId: string; active: bool
     return () => cancelAnimationFrame(frame)
   }, [active])
 
+  const {
+    isOpen: isMenuOpen,
+    position: menuPosition,
+    menuRef,
+    handleContextMenu,
+    closeMenu,
+  } = useContextMenu()
+  // Read at open time so Copy reflects the selection the click landed on.
+  const [hasSelection, setHasSelection] = useState(false)
+
+  const openMenu = useCallback(
+    (event: React.MouseEvent) => {
+      setHasSelection(Boolean(terminalRef.current?.hasSelection()))
+      // Suppresses Electron's native editable-field menu, which would
+      // otherwise target xterm's offscreen input textarea.
+      handleContextMenu(event)
+    },
+    [handleContextMenu]
+  )
+
+  const copySelection = useCallback(() => {
+    const selection = terminalRef.current?.getSelection()
+    if (selection) void navigator.clipboard.writeText(selection)
+  }, [])
+
+  const pasteClipboard = useCallback(() => {
+    void navigator.clipboard
+      .readText()
+      .then((text) => {
+        if (!text) return
+        // Straight to the PTY: the shell echoes it, exactly like a real paste.
+        writeToTerminal(terminalId, text)
+        terminalRef.current?.focus()
+      })
+      .catch(() => {
+        // Reading the clipboard needs a permission the shell grants to its own
+        // origin; an older shell that predates that grant denies it. Keyboard
+        // paste is a native paste event and keeps working either way.
+        toast.error('Could not read the clipboard. Press ⌘V to paste.')
+      })
+  }, [terminalId])
+
+  const selectAll = useCallback(() => {
+    terminalRef.current?.selectAll()
+  }, [])
+
+  const clearScreen = useCallback(() => {
+    terminalRef.current?.clear()
+    terminalRef.current?.focus()
+  }, [])
+
+  const newTab = useCallback(() => {
+    void openTerminal()
+  }, [])
+
+  const openTerminalSettings = useCallback(() => {
+    navigateToSettings({ section: 'terminal' })
+  }, [navigateToSettings])
+
+  // Scoped to the terminal that was right-clicked, not the active one.
+  const closeThisTerminal = useCallback(() => {
+    void closeTerminal(terminalId)
+  }, [terminalId])
+
   // An inactive tab is `display: none`, not merely invisible. xterm watches its
   // element with an IntersectionObserver and pauses rendering once it stops
   // intersecting — which `visibility: hidden` never does, since it still
   // occupies its box. Left that way, every background terminal keeps painting
   // output nobody is looking at, out of the active terminal's frame budget.
   // xterm re-measures and does a full refresh when the element comes back.
-  return <div ref={hostRef} className={cn('absolute inset-0 px-2 py-1', !active && 'hidden')} />
+  return (
+    <>
+      <div
+        ref={hostRef}
+        onContextMenu={openMenu}
+        className={cn('absolute inset-0 px-2 py-1', !active && 'hidden')}
+      />
+      <TerminalContextMenu
+        isOpen={isMenuOpen}
+        position={menuPosition}
+        menuRef={menuRef}
+        onClose={closeMenu}
+        hasSelection={hasSelection}
+        onCopy={copySelection}
+        onPaste={pasteClipboard}
+        onSelectAll={selectAll}
+        onClear={clearScreen}
+        onNewTab={newTab}
+        onOpenSettings={openTerminalSettings}
+        {...(canClose ? { onCloseTerminal: closeThisTerminal } : {})}
+      />
+    </>
+  )
 }
 
 /**
@@ -396,6 +493,7 @@ export function TerminalSession() {
             key={tab.terminalId}
             terminalId={tab.terminalId}
             active={tab.terminalId === activeTerminalId}
+            canClose={tabs.length > 1}
           />
         ))}
         {startError && (

apps/sim/lib/data-drains/sources/copilot-chats.ts

@@ -34,6 +34,7 @@ const chatColumns = {
   config: copilotChats.config,
   resources: copilotChats.resources,
   lastSeenAt: copilotChats.lastSeenAt,
+  autoAllowedTools: copilotChats.autoAllowedTools,
   pinned: copilotChats.pinned,
   createdAt: copilotChats.createdAt,
   updatedAt: copilotChats.updatedAt,