chore: import upstream snapshot with attribution

apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts

@@ -0,0 +1,251 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  clearExecutionPointer,
+  executeWorkflowWithFullLogging,
+  getWorkflowEntries,
+  loadExecutionPointer,
+  MockSSEEventHandlerError,
+  MockSSEStreamInterruptedError,
+  saveExecutionPointer,
+  setActiveWorkflow,
+} = vi.hoisted(() => ({
+  clearExecutionPointer: vi.fn(),
+  executeWorkflowWithFullLogging: vi.fn(),
+  getWorkflowEntries: vi.fn(() => []),
+  loadExecutionPointer: vi.fn(),
+  MockSSEEventHandlerError: class SSEEventHandlerError extends Error {
+    executionId?: string
+
+    constructor(message: string, executionId?: string) {
+      super(message)
+      this.name = 'SSEEventHandlerError'
+      this.executionId = executionId
+    }
+  },
+  MockSSEStreamInterruptedError: class SSEStreamInterruptedError extends Error {
+    executionId?: string
+
+    constructor(message: string, executionId?: string) {
+      super(message)
+      this.name = 'SSEStreamInterruptedError'
+      this.executionId = executionId
+    }
+  },
+  saveExecutionPointer: vi.fn(),
+  setActiveWorkflow: vi.fn(),
+}))
+
+const setIsExecuting = vi.fn()
+const setActiveBlocks = vi.fn()
+const setCurrentExecutionId = vi.fn()
+const getCurrentExecutionId = vi.fn()
+const getWorkflowExecution = vi.fn(() => ({ isExecuting: false }))
+
+vi.mock('@/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils', () => ({
+  executeWorkflowWithFullLogging,
+}))
+
+vi.mock('@/stores/execution/store', () => ({
+  useExecutionStore: {
+    getState: () => ({
+      getCurrentExecutionId,
+      getWorkflowExecution,
+      setActiveBlocks,
+      setIsExecuting,
+      setCurrentExecutionId,
+    }),
+  },
+}))
+
+vi.mock('@/hooks/use-execution-stream', () => ({
+  SSEEventHandlerError: MockSSEEventHandlerError,
+  SSEStreamInterruptedError: MockSSEStreamInterruptedError,
+}))
+
+vi.mock('@/stores/workflows/registry/store', () => ({
+  useWorkflowRegistry: {
+    getState: () => ({
+      activeWorkflowId: 'wf-1',
+      setActiveWorkflow,
+    }),
+  },
+}))
+
+vi.mock('@/stores/terminal', () => ({
+  consolePersistence: {
+    executionStarted: vi.fn(),
+    executionEnded: vi.fn(),
+    persist: vi.fn(),
+  },
+  clearExecutionPointer,
+  loadExecutionPointer,
+  saveExecutionPointer,
+  useTerminalConsoleStore: {
+    getState: () => ({
+      getWorkflowEntries,
+    }),
+  },
+}))
+
+import {
+  bindRunToolToExecution,
+  cancelRunToolExecution,
+  executeRunToolOnClient,
+  reportManualRunToolStop,
+} from './run-tool-execution'
+
+describe('run tool execution cancellation', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    getCurrentExecutionId.mockReturnValue(null)
+    getWorkflowEntries.mockReturnValue([])
+    loadExecutionPointer.mockResolvedValue(null)
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true }))
+  })
+
+  it('passes an abort signal into executeWorkflowWithFullLogging and aborts it', async () => {
+    let capturedSignal: AbortSignal | undefined
+    executeWorkflowWithFullLogging.mockImplementationOnce(async (options: any) => {
+      capturedSignal = options.abortSignal
+      await new Promise((_, reject) => {
+        options.abortSignal.addEventListener(
+          'abort',
+          () => reject(new DOMException('Aborted', 'AbortError')),
+          { once: true }
+        )
+      })
+    })
+
+    executeRunToolOnClient('tool-1', 'run_workflow', { workflowId: 'wf-1' })
+    await Promise.resolve()
+
+    cancelRunToolExecution('wf-1')
+    await Promise.resolve()
+
+    expect(capturedSignal?.aborted).toBe(true)
+  })
+
+  it('can report a manual stop using the explicit toolCallId override', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal('fetch', fetchMock)
+
+    await reportManualRunToolStop('wf-1', 'tool-override')
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/copilot/confirm',
+      expect.objectContaining({
+        method: 'POST',
+        body: expect.stringContaining('"toolCallId":"tool-override"'),
+      })
+    )
+  })
+
+  it('prefers workflow_input, forwards triggerBlockId, and respects useDeployedState', async () => {
+    executeWorkflowWithFullLogging.mockResolvedValueOnce({
+      success: true,
+      output: { ok: true },
+      logs: [],
+    })
+
+    executeRunToolOnClient('tool-2', 'run_workflow', {
+      workflowId: 'wf-1',
+      workflow_input: { prompt: 'preferred' },
+      input: { prompt: 'fallback' },
+      triggerBlockId: 'trigger-1',
+      useDeployedState: true,
+    })
+
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(executeWorkflowWithFullLogging).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workflowId: 'wf-1',
+        workflowInput: { prompt: 'preferred' },
+        overrideTriggerType: 'copilot',
+        triggerBlockId: 'trigger-1',
+        useDraftState: false,
+      })
+    )
+  })
+
+  it('treats a tab-local execution pointer as handled in background', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal('fetch', fetchMock)
+    loadExecutionPointer.mockResolvedValueOnce({
+      workflowId: 'wf-1',
+      executionId: 'exec-existing',
+      lastEventId: 7,
+    })
+
+    await expect(bindRunToolToExecution('tool-3', 'wf-1')).resolves.toBe(true)
+
+    expect(setActiveWorkflow).not.toHaveBeenCalled()
+    expect(setIsExecuting).not.toHaveBeenCalled()
+    expect(setCurrentExecutionId).not.toHaveBeenCalled()
+    expect(saveExecutionPointer).not.toHaveBeenCalled()
+    expect(executeWorkflowWithFullLogging).not.toHaveBeenCalled()
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/copilot/confirm',
+      expect.objectContaining({
+        method: 'POST',
+        body: expect.stringContaining('"status":"background"'),
+      })
+    )
+  })
+
+  it('does not recover from shared console rows without a tab-local pointer', async () => {
+    loadExecutionPointer.mockResolvedValueOnce(null)
+    getWorkflowEntries.mockReturnValueOnce([
+      {
+        workflowId: 'wf-1',
+        executionId: 'exec-shared',
+        isRunning: true,
+        startedAt: new Date().toISOString(),
+      },
+    ])
+
+    await expect(bindRunToolToExecution('tool-4', 'wf-1')).resolves.toBe(false)
+
+    expect(setActiveWorkflow).not.toHaveBeenCalled()
+    expect(setIsExecuting).not.toHaveBeenCalled()
+    expect(setCurrentExecutionId).not.toHaveBeenCalled()
+    expect(saveExecutionPointer).not.toHaveBeenCalled()
+  })
+
+  it('reports local stream handler failures as background instead of workflow errors', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal('fetch', fetchMock)
+    getCurrentExecutionId.mockImplementation(
+      () => saveExecutionPointer.mock.calls[0]?.[0]?.executionId ?? null
+    )
+    executeWorkflowWithFullLogging.mockRejectedValueOnce(
+      new MockSSEEventHandlerError('handler failed', 'exec-1')
+    )
+
+    executeRunToolOnClient('tool-5', 'run_workflow', { workflowId: 'wf-1' })
+
+    await vi.waitFor(() => {
+      expect(fetchMock).toHaveBeenCalledWith(
+        '/api/copilot/confirm',
+        expect.objectContaining({
+          method: 'POST',
+          body: expect.stringContaining('"status":"background"'),
+        })
+      )
+    })
+    expect(clearExecutionPointer).not.toHaveBeenCalled()
+    expect(setIsExecuting).toHaveBeenCalledWith('wf-1', false)
+    expect(fetchMock).not.toHaveBeenCalledWith(
+      '/api/copilot/confirm',
+      expect.objectContaining({
+        body: expect.stringContaining('"status":"error"'),
+      })
+    )
+  })
+})