chore: import upstream snapshot with attribution

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

@@ -0,0 +1,177 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { type NextRequest, NextResponse } from 'next/server'
+import { linqUploadAttachmentContract } from '@/lib/api/contracts/tools/communication/messaging'
+import { parseRequest } from '@/lib/api/server'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { processFilesToUserFiles, type RawFileInput } from '@/lib/uploads/utils/file-utils'
+import { downloadServableFileFromStorage } from '@/lib/uploads/utils/file-utils.server'
+import { docNotReadyResponse } from '@/lib/uploads/utils/servable-file-response'
+import { assertToolFileAccess } from '@/app/api/files/authorization'
+import { extractLinqError, LINQ_API_BASE, linqHeaders } from '@/tools/linq/utils'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('LinqUploadAttachmentAPI')
+
+/** Linq pre-upload caps attachments at 100MB. */
+const MAX_SIZE_BYTES = 100 * 1024 * 1024
+
+/**
+ * Upload a file to Linq as a reusable attachment.
+ *
+ * Linq uses a two-step pre-upload flow: register the attachment metadata to
+ * receive a presigned URL, then PUT the bytes to that URL with the exact
+ * headers Linq returns. The resulting `attachment_id` can be referenced when
+ * sending messages or voice memos.
+ */
+export const POST = withRouteHandler(async (request: NextRequest) => {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request, { requireWorkflowId: false })
+    if (!authResult.success || !authResult.userId) {
+      logger.warn(`[${requestId}] Unauthorized Linq upload attempt: ${authResult.error}`)
+      return NextResponse.json(
+        { success: false, error: authResult.error || 'Authentication required' },
+        { status: 401 }
+      )
+    }
+
+    const parsed = await parseRequest(linqUploadAttachmentContract, request, {})
+    if (!parsed.success) return parsed.response
+    const { apiKey, file, fileContent, filename, contentType } = parsed.data.body
+
+    let buffer: Buffer
+    let resolvedFilename = filename ?? ''
+    let resolvedContentType = contentType ?? ''
+
+    if (file) {
+      const userFiles = processFilesToUserFiles([file as RawFileInput], requestId, logger)
+      if (userFiles.length === 0) {
+        return NextResponse.json(
+          { success: false, error: 'No valid file provided' },
+          { status: 400 }
+        )
+      }
+      const userFile = userFiles[0]
+      const denied = await assertToolFileAccess(userFile.key, authResult.userId, requestId, logger)
+      if (denied) return denied
+      let resolvedContentTypeFromStorage: string
+      try {
+        const resolved = await downloadServableFileFromStorage(userFile, requestId, logger)
+        buffer = resolved.buffer
+        resolvedContentTypeFromStorage = resolved.contentType
+      } catch (error) {
+        const notReady = docNotReadyResponse(error)
+        if (notReady) return notReady
+        logger.error(`[${requestId}] Failed to download Linq attachment file:`, error)
+        return NextResponse.json(
+          { success: false, error: getErrorMessage(error, 'Unknown error occurred') },
+          { status: 500 }
+        )
+      }
+      if (!resolvedFilename) resolvedFilename = userFile.name
+      if (!resolvedContentType)
+        resolvedContentType =
+          resolvedContentTypeFromStorage || userFile.type || 'application/octet-stream'
+    } else if (fileContent) {
+      buffer = Buffer.from(fileContent, 'base64')
+      if (!resolvedFilename) resolvedFilename = 'file'
+      if (!resolvedContentType) resolvedContentType = 'application/octet-stream'
+    } else {
+      return NextResponse.json(
+        { success: false, error: 'A file is required to upload an attachment' },
+        { status: 400 }
+      )
+    }
+
+    const sizeBytes = buffer.length
+    if (sizeBytes === 0) {
+      return NextResponse.json({ success: false, error: 'File is empty' }, { status: 400 })
+    }
+    if (sizeBytes > MAX_SIZE_BYTES) {
+      return NextResponse.json(
+        {
+          success: false,
+          error: `File exceeds Linq's 100MB attachment limit (${(sizeBytes / (1024 * 1024)).toFixed(2)}MB)`,
+        },
+        { status: 400 }
+      )
+    }
+
+    logger.info(`[${requestId}] Registering Linq attachment`, {
+      filename: resolvedFilename,
+      contentType: resolvedContentType,
+      sizeBytes,
+    })
+
+    const registerResponse = await fetch(`${LINQ_API_BASE}/attachments`, {
+      method: 'POST',
+      headers: linqHeaders(apiKey),
+      body: JSON.stringify({
+        filename: resolvedFilename,
+        content_type: resolvedContentType,
+        size_bytes: sizeBytes,
+      }),
+    })
+    const registerData = await registerResponse.json().catch(() => null)
+    if (!registerResponse.ok) {
+      return NextResponse.json(
+        { success: false, error: extractLinqError(registerData, 'Failed to register attachment') },
+        { status: registerResponse.status }
+      )
+    }
+
+    const uploadUrl: string | undefined = registerData?.upload_url
+    const attachmentId: string | undefined = registerData?.attachment_id
+    if (!uploadUrl || !attachmentId) {
+      return NextResponse.json(
+        { success: false, error: 'Linq did not return an upload URL or attachment ID' },
+        { status: 502 }
+      )
+    }
+
+    const requiredHeaders: Record<string, string> = registerData?.required_headers ?? {
+      'Content-Type': resolvedContentType,
+      'Content-Length': String(sizeBytes),
+    }
+    const uploadMethod: string = registerData?.http_method ?? 'PUT'
+
+    logger.info(`[${requestId}] Uploading ${sizeBytes} bytes to presigned URL`)
+    const uploadResponse = await fetch(uploadUrl, {
+      method: uploadMethod,
+      headers: requiredHeaders,
+      body: new Uint8Array(buffer),
+    })
+    if (!uploadResponse.ok) {
+      const uploadError = await uploadResponse.text().catch(() => '')
+      logger.error(`[${requestId}] Presigned upload failed: ${uploadResponse.status}`, uploadError)
+      return NextResponse.json(
+        { success: false, error: `Failed to upload file bytes to Linq (${uploadResponse.status})` },
+        { status: 502 }
+      )
+    }
+
+    logger.info(`[${requestId}] Attachment uploaded`, { attachmentId })
+    return NextResponse.json({
+      success: true,
+      output: {
+        attachmentId,
+        downloadUrl: registerData?.download_url ?? null,
+        filename: resolvedFilename,
+        contentType: resolvedContentType,
+        sizeBytes,
+        status: 'complete',
+      },
+    })
+  } catch (error) {
+    logger.error(`[${requestId}] Error uploading Linq attachment:`, error)
+    return NextResponse.json(
+      { success: false, error: getErrorMessage(error, 'Unknown error occurred') },
+      { status: 500 }
+    )
+  }
+})