fix(workflows): redact run and export secrets

Author: TheodoreSpeaks

apps/sim/lib/workflows/executor/execution-status.test.ts

@@ -5,20 +5,17 @@ import { dbChainMockFns, queueTableRows, resetDbChainMock, schemaMock } from '@s
 import { and } from 'drizzle-orm'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockGetJob } = vi.hoisted(() => ({
+const { mockGetJob, mockMaterializeForDisplay } = vi.hoisted(() => ({
   mockGetJob: vi.fn(),
+  mockMaterializeForDisplay: vi.fn(),
 }))
 
 vi.mock('@/lib/core/async-jobs', () => ({
   getJobQueue: vi.fn().mockResolvedValue({ getJob: mockGetJob }),
 }))
 
-vi.mock('@/lib/logs/execution/functional-outputs', () => ({
-  collectFunctionalBlockOutputs: vi.fn().mockReturnValue(new Map()),
-}))
-
 vi.mock('@/lib/logs/execution/trace-store', () => ({
-  materializeExecutionData: vi.fn(),
+  materializeExecutionDataForDisplay: mockMaterializeForDisplay,
 }))
 
 vi.mock('@/lib/workflows/executor/paused-execution-metadata', () => ({
@@ -38,6 +35,54 @@ describe('getWorkflowExecutionStatus queue projection', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     resetDbChainMock()
+    mockMaterializeForDisplay.mockResolvedValue({})
+  })
+
+  it('selects run outputs only from the secret-safe display projection', async () => {
+    queueTableRows(schemaMock.workflowExecutionLogs, [
+      {
+        executionId: 'execution-1',
+        workflowId: 'workflow-1',
+        workspaceId: 'workspace-1',
+        status: 'completed',
+        level: 'info',
+        trigger: 'api',
+        startedAt: new Date('2026-08-05T12:00:00.000Z'),
+        endedAt: new Date('2026-08-05T12:00:01.000Z'),
+        totalDurationMs: 1000,
+        executionData: {
+          executionState: {
+            blockStates: { 'block-1': { output: { token: 'resolved-secret' } } },
+          },
+        },
+        costTotal: null,
+      },
+    ])
+    queueTableRows(schemaMock.resumeQueue, [])
+    queueTableRows(schemaMock.pausedExecutions, [])
+    mockMaterializeForDisplay.mockResolvedValueOnce({
+      finalOutput: { token: '[REDACTED]' },
+      traceSpans: [{ blockId: 'block-1', output: { token: '[REDACTED]' } }],
+    })
+    const status = await getWorkflowExecutionStatus({
+      ...input,
+      includeOutput: true,
+      selectedOutputs: ['block-1'],
+    })
+
+    expect(mockMaterializeForDisplay).toHaveBeenCalledWith(
+      expect.objectContaining({ executionState: expect.anything() }),
+      {
+        workspaceId: 'workspace-1',
+        workflowId: 'workflow-1',
+        executionId: 'execution-1',
+      }
+    )
+    expect(status).toMatchObject({
+      finalOutput: { token: '[REDACTED]' },
+      blockOutputs: { 'block-1': { token: '[REDACTED]' } },
+    })
+    expect(JSON.stringify(status)).not.toContain('resolved-secret')
   })
 
   it('projects a queued workflow job as an execution resource', async () => {

apps/sim/lib/workflows/executor/execution-status.ts

@@ -8,7 +8,7 @@ import {
   collectFunctionalBlockOutputs,
   type FunctionalExecutionDataSource,
 } from '@/lib/logs/execution/functional-outputs'
-import { materializeExecutionData } from '@/lib/logs/execution/trace-store'
+import { materializeExecutionDataForDisplay } from '@/lib/logs/execution/trace-store'
 import {
   RESUME_EXECUTION_JOB_ID_PREFIX,
   WORKFLOW_EXECUTION_JOB_ID_PREFIX,
@@ -259,9 +259,7 @@ export async function getWorkflowExecutionStatus(
 
   const cost = logRow.costTotal != null ? { total: Number(logRow.costTotal) } : null
 
-  // Heavy execution data may live in object storage; resolve the pointer
-  // before reading error / finalOutput / traceSpans (no-op for inline rows).
-  const executionData = (await materializeExecutionData(
+  const executionData = (await materializeExecutionDataForDisplay(
     logRow.executionData as Record<string, unknown> | null,
     {
       workspaceId: logRow.workspaceId,

apps/sim/lib/workflows/operations/export-workflow.test.ts

@@ -0,0 +1,91 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  loadNormalized: vi.fn(),
+}))
+
+vi.mock('@/lib/workflows/persistence/utils', () => ({
+  loadWorkflowFromNormalizedTables: mocks.loadNormalized,
+}))
+
+vi.mock('@/blocks/registry', () => ({
+  getBlock: (type: string) =>
+    type === 'agent'
+      ? {
+          name: 'Agent',
+          subBlocks: [{ id: 'tools', type: 'tool-input' }],
+          outputs: {},
+        }
+      : {
+          name: 'Slack',
+          subBlocks: [
+            { id: 'credential', type: 'oauth-input' },
+            { id: 'botToken', type: 'short-input', password: true },
+            { id: 'text', type: 'long-input' },
+          ],
+          outputs: {},
+        },
+}))
+
+import { buildWorkflowExportPayload } from '@/lib/workflows/operations/export-workflow'
+
+describe('buildWorkflowExportPayload', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.loadNormalized.mockResolvedValue({
+      blocks: {
+        agent: {
+          id: 'agent',
+          type: 'agent',
+          name: 'Agent',
+          position: { x: 0, y: 0 },
+          subBlocks: {
+            tools: {
+              id: 'tools',
+              type: 'tool-input',
+              value: [
+                {
+                  type: 'slack',
+                  toolId: 'slack_message',
+                  params: {
+                    credential: 'nested-credential-id',
+                    botToken: 'nested-xoxb-secret',
+                    text: 'ordinary message',
+                  },
+                },
+              ],
+            },
+          },
+          outputs: {},
+          enabled: true,
+        },
+      },
+      edges: [],
+      loops: {},
+      parallels: {},
+    })
+  })
+
+  it('redacts nested tool credentials from the public export payload', async () => {
+    const payload = await buildWorkflowExportPayload({
+      id: 'workflow-1',
+      name: 'Reports',
+      description: null,
+      workspaceId: 'workspace-1',
+      folderId: null,
+      variables: {},
+    })
+
+    const params = payload?.state.blocks.agent.subBlocks.tools.value[0].params
+    expect(params).toEqual({
+      credential: null,
+      botToken: null,
+      text: 'ordinary message',
+    })
+    expect(JSON.stringify(payload)).not.toContain('nested-credential-id')
+    expect(JSON.stringify(payload)).not.toContain('nested-xoxb-secret')
+  })
+})

apps/sim/lib/workflows/operations/export-workflow.ts

@@ -12,11 +12,13 @@ import { parseWorkflowVariables } from '@/lib/workflows/variables/parse'
  *
  * Unlike the admin export (`/api/v1/admin/workflows/[id]/export`), which emits
  * the raw state for backup/restore, this runs the payload through
- * `sanitizeForExport`, which nulls three classes of sub-block value:
+ * `sanitizeForExport`, which nulls five classes of sub-block value:
  * - `password: true` fields, unless the value is a whole `{{ENV_VAR}}`
  *   reference, which is preserved so the import resolves it in the target
  *   workspace;
  * - `oauth-input` credentials;
+ * - sensitive nested `tool-input` params and params without authoritative metadata;
+ * - opaque credential-bearing values such as arbitrary table cells;
  * - **workspace-scoped bindings** — selector fields and id-keyed fields that
  *   point at rows that do not exist in another workspace, cleared rather than
  *   carried across as dangling ids.

apps/sim/lib/workflows/sanitization/json-sanitizer.ts

@@ -662,6 +662,7 @@ export function sanitizeForExport(state: WorkflowState): ExportWorkflowState {
   // Use unified sanitization with env var preservation for export
   const sanitizedState = sanitizeWorkflowForSharing(fullState, {
     preserveEnvVars: true, // Keep {{ENV_VAR}} references in exported workflows
+    redactOpaqueCredentialInputs: true,
   }) as ExportWorkflowState['state']
 
   return {