fix(security): close ReDoS, zip-bomb, SSRF and redaction gaps found by audit

A dependency re-audit asked "does this library actually deliver the guarantee
the calling code assumes" rather than "is it popular". These are the results.

Security:
- Copilot VFS glob() handed a caller-controlled pattern to micromatch, whose
  picomatch backend compiles `*` into a backtracking regex. A 25-char pattern
  took 41s; 29 chars exceeded 180s. Matching now runs on RE2, mirroring the
  grep() sibling in the same file that already did this. micromatch.makeRe()
  emits lookaheads RE2 cannot express, so picomatch's dot-assertions are
  translated into character exclusions; a differential test covers 519,688
  pattern/path pairs against micromatch with no mismatches. Patterns that
  still carry an assertion fail closed rather than falling back.
- doc-parser was the only OOXML-adjacent parser without the zip-bomb guard.
  officeparser sniffs content rather than extension, so a docx renamed .doc
  reached an unguarded unzip and could OOM the shared server. Genuine OLE2
  .doc files are unaffected. Same guard added to the copilot style reader.
- json-yaml-chunker called yaml.load with no alias-expansion cap. js-yaml has
  no maxAliasCount, so this is routed through assertYamlWithinLimits like the
  file parser already was.
- Video tools and falai fetched provider-supplied URLs raw, including one that
  replayed an Authorization header to a polled status_url. Those URLs are now
  origin-pinned and revalidated on every poll. Cross-origin redirects drop
  credential headers by default, keyed on registrable domain rather than exact
  origin so same-site subdomain hops and http->https upgrades keep working.
- Redaction key patterns were fully anchored, so openai_api_key, x-api-key,
  set-cookie, secretAccessKey and session_id were logged in the clear. The
  matcher now tokenizes keys, with exemptions so token-usage fields such as
  promptTokens stay readable.
- drawtext escaping did not match ffmpeg's quoting grammar; a quote in agent
  supplied text escaped into filter options. Text is passed via textfile= so
  it never enters the filter string.
- Loop conditions interpolated a resolved value into a JS string by hand.

Supply chain:
- Vendor free-email-domains' data. Its postinstall fetched a CDN CSV and
  overwrote the shipped list, so the lockfile hash covered the tarball but not
  the data actually used. It is inert under Bun today only because the package
  is outside trustedDependencies.
- Document why xlsx is pinned to the SheetJS CDN: the npm copy is frozen at
  0.18.5 with two unfixed CVEs, and a URL dependency is invisible to audit
  tooling, so upgrades have to be tracked by hand.

Dependencies:
- @daytonaio/sdk is deprecated in favour of @daytona/sdk (same API).
- The @react-email/components 0.x line is deprecated; 1.0.12 needs no source
  changes here since no template uses <Tailwind> and render() already moved.
- Load the pptx preview lazily so echarts leaves the Home, Files and share
  page bundles.
- Drop autoprefixer (absent from the PostCSS config, so it never ran) and
  tailwind-merge (no importers; @sim/emcn declares its own).

Author: Waleed Latif

apps/sim/app/api/tools/onedrive/upload/route.ts

@@ -1,6 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { type NextRequest, NextResponse } from 'next/server'
+/** Pinned to the SheetJS CDN, not npm — see the note in `lib/file-parsers/xlsx-parser.ts`. */
 import * as XLSX from 'xlsx'
 import { onedriveUploadContract } from '@/lib/api/contracts/tools/microsoft'
 import { parseRequest } from '@/lib/api/server'

apps/sim/app/api/tools/video/route.test.ts

@@ -0,0 +1,136 @@
+/**
+ * @vitest-environment node
+ */
+import {
+  createMockRequest,
+  hybridAuthMockFns,
+  inputValidationMock,
+  inputValidationMockFns,
+} from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { MAX_FAL_QUEUE_JSON_BYTES } from '@/lib/media/falai'
+
+const { mockUploadFile } = vi.hoisted(() => ({
+  mockUploadFile: vi.fn(),
+}))
+
+vi.mock('@/lib/core/security/input-validation.server', () => inputValidationMock)
+vi.mock('@/lib/core/execution-limits', () => ({ getMaxExecutionTimeout: () => 30_000 }))
+vi.mock('@sim/utils/helpers', () => ({ sleep: () => Promise.resolve() }))
+vi.mock('@/app/api/files/authorization', () => ({
+  assertToolFileAccess: vi.fn().mockResolvedValue(null),
+}))
+vi.mock('@/lib/uploads', () => ({
+  StorageService: { uploadFile: mockUploadFile },
+}))
+vi.mock('@/lib/core/utils/urls', () => ({ getBaseUrl: () => 'https://sim.test' }))
+
+import { POST } from '@/app/api/tools/video/route'
+
+const { mockValidateUrlWithDNS, mockSecureFetchWithPinnedIP } = inputValidationMockFns
+
+function jsonResponse(payload: unknown) {
+  const text = JSON.stringify(payload)
+  return {
+    ok: true,
+    status: 200,
+    headers: { get: () => null },
+    body: null,
+    text: async () => text,
+    arrayBuffer: async () => new ArrayBuffer(0),
+  }
+}
+
+function videoResponse() {
+  return {
+    ok: true,
+    status: 200,
+    headers: {
+      get: (name: string) => {
+        if (name === 'content-type') return 'video/mp4'
+        return name === 'content-length' ? '8' : null
+      },
+    },
+    body: null,
+    text: async () => '',
+    arrayBuffer: async () => new ArrayBuffer(8),
+  }
+}
+
+const baseBody = {
+  provider: 'falai',
+  apiKey: 'fal-key',
+  model: 'kling-v3-pro',
+  prompt: 'a cat riding a bike',
+}
+
+describe('POST /api/tools/video (Fal.ai queue)', () => {
+  const fetchMock = vi.fn()
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.stubGlobal('fetch', fetchMock)
+    hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValue({
+      success: true,
+      userId: 'user-1',
+      authType: 'internal_jwt',
+    })
+    mockValidateUrlWithDNS.mockResolvedValue({ isValid: true, resolvedIP: '8.8.8.8' })
+    mockUploadFile.mockResolvedValue({ path: '/api/files/serve/video.mp4' })
+  })
+
+  it('normalizes the echoed /response URL and bounds queue reads with the shared Fal cap', async () => {
+    fetchMock.mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          request_id: 'req-1',
+          status_url: 'https://queue.fal.run/fal-ai/kling-video/requests/req-1/status',
+          response_url: 'https://queue.fal.run/fal-ai/kling-video/requests/req-1/response',
+        }),
+        { status: 200 }
+      )
+    )
+    mockSecureFetchWithPinnedIP
+      .mockResolvedValueOnce(jsonResponse({ status: 'COMPLETED' }))
+      .mockResolvedValueOnce(jsonResponse({ video: { url: 'https://cdn.fal.media/a.mp4' } }))
+      .mockResolvedValueOnce(videoResponse())
+
+    const response = await POST(createMockRequest('POST', baseBody))
+    expect(response.status).toBe(200)
+
+    const [statusCall, resultCall, downloadCall] = mockSecureFetchWithPinnedIP.mock.calls
+    expect(statusCall[0]).toBe('https://queue.fal.run/fal-ai/kling-video/requests/req-1/status')
+    // `/response` is not a GET route on queue.fal.run — it must be stripped.
+    expect(resultCall[0]).toBe('https://queue.fal.run/fal-ai/kling-video/requests/req-1')
+    expect(downloadCall[0]).toBe('https://cdn.fal.media/a.mp4')
+
+    expect(statusCall[2].maxResponseBytes).toBe(MAX_FAL_QUEUE_JSON_BYTES)
+    expect(resultCall[2].maxResponseBytes).toBe(MAX_FAL_QUEUE_JSON_BYTES)
+  })
+
+  it('falls back to the constructed multi-segment queue URL when the candidate is off-origin', async () => {
+    fetchMock.mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          request_id: 'req-2',
+          status_url: 'https://evil.example.net/steal',
+          response_url: 'https://evil.example.net/steal',
+        }),
+        { status: 200 }
+      )
+    )
+    mockSecureFetchWithPinnedIP
+      .mockResolvedValueOnce(jsonResponse({ status: 'COMPLETED' }))
+      .mockResolvedValueOnce(jsonResponse({ video: { url: 'https://cdn.fal.media/a.mp4' } }))
+      .mockResolvedValueOnce(videoResponse())
+
+    const response = await POST(createMockRequest('POST', baseBody))
+    expect(response.status).toBe(200)
+
+    // `fal-ai/kling-video/v3/pro/text-to-video` polls under the app id only.
+    expect(mockSecureFetchWithPinnedIP.mock.calls.slice(0, 2).map(([url]) => url)).toEqual([
+      'https://queue.fal.run/fal-ai/kling-video/requests/req-2/status',
+      'https://queue.fal.run/fal-ai/kling-video/requests/req-2',
+    ])
+  })
+})