chore: import upstream snapshot with attribution

apps/sim/app/api/tools/latex/route.ts

@@ -0,0 +1,269 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { truncate } from '@sim/utils/string'
+import { type NextRequest, NextResponse } from 'next/server'
+import { type LatexCompileBody, latexCompileContract } from '@/lib/api/contracts/tools/latex'
+import { getValidationErrorMessage, parseRequest, validationErrorResponse } from '@/lib/api/server'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import {
+  isPayloadSizeLimitError,
+  readResponseJsonWithLimit,
+  readResponseToBufferWithLimit,
+} from '@/lib/core/utils/stream-limits'
+import { getBaseUrl } from '@/lib/core/utils/urls'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+const logger = createLogger('LatexCompileAPI')
+
+const LATEX_COMPILE_URL = 'https://latex.ytotech.com/builds/sync'
+const DEFAULT_COMPILER = 'pdflatex'
+const MAX_PDF_BYTES = 25 * 1024 * 1024
+const MAX_ERROR_JSON_BYTES = 4 * 1024 * 1024
+const MAX_ERROR_MESSAGE_CHARS = 4000
+const MAX_ERROR_CODE_CHARS = 100
+/** Leaves headroom within `maxDuration` to store the PDF after compilation. */
+const COMPILE_TIMEOUT_MS = 50_000
+
+export const dynamic = 'force-dynamic'
+export const maxDuration = 60
+
+interface StoredPdfResponse {
+  pdfFile?: unknown
+  pdfUrl: string
+  fileName: string
+  contentType: string
+  compiler: string
+}
+
+export const POST = withRouteHandler(async (request: NextRequest) => {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request, { requireWorkflowId: false })
+    if (!authResult.success || !authResult.userId) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const parsed = await parseRequest(
+      latexCompileContract,
+      request,
+      {},
+      {
+        validationErrorResponse: (error) => {
+          logger.warn(`[${requestId}] Invalid LaTeX compile request:`, error.issues)
+          return validationErrorResponse(
+            error,
+            getValidationErrorMessage(error, 'Invalid request data')
+          )
+        },
+      }
+    )
+    if (!parsed.success) return parsed.response
+
+    const body = parsed.data.body
+    const compiler = body.compiler || DEFAULT_COMPILER
+
+    logger.info(`[${requestId}] Compiling LaTeX document`, {
+      compiler,
+      contentLength: body.content.length,
+      resourceCount: body.resources?.length ?? 0,
+    })
+
+    let upstreamResponse: Response
+    try {
+      upstreamResponse = await fetch(LATEX_COMPILE_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          compiler,
+          resources: [{ main: true, content: body.content }, ...(body.resources ?? [])],
+        }),
+        signal: AbortSignal.timeout(COMPILE_TIMEOUT_MS),
+      })
+    } catch (error) {
+      // The timeout signal is the only abort source on this fetch, so an
+      // AbortError here is a timeout regardless of which name undici uses.
+      if (
+        error instanceof DOMException &&
+        (error.name === 'TimeoutError' || error.name === 'AbortError')
+      ) {
+        logger.error(`[${requestId}] LaTeX compile service timed out`, {
+          timeoutMs: COMPILE_TIMEOUT_MS,
+        })
+        return NextResponse.json({ error: 'LaTeX compile service timed out' }, { status: 504 })
+      }
+      throw error
+    }
+
+    const upstreamContentType = upstreamResponse.headers.get('content-type') || ''
+    if (!upstreamResponse.ok || !upstreamContentType.includes('application/pdf')) {
+      return await buildCompileErrorResponse(upstreamResponse, requestId)
+    }
+
+    const pdfBuffer = await readResponseToBufferWithLimit(upstreamResponse, {
+      maxBytes: MAX_PDF_BYTES,
+      label: 'compiled PDF',
+    })
+    if (pdfBuffer.length === 0) {
+      logger.error(`[${requestId}] LaTeX compile service returned an empty PDF`)
+      return NextResponse.json(
+        { error: 'LaTeX compile service returned an empty PDF' },
+        { status: 502 }
+      )
+    }
+
+    const storedPdf = await storeCompiledPdf(pdfBuffer, body, compiler, authResult.userId)
+
+    logger.info(`[${requestId}] LaTeX compilation completed`, {
+      compiler,
+      fileName: storedPdf.fileName,
+      size: pdfBuffer.length,
+    })
+
+    return NextResponse.json(storedPdf)
+  } catch (error) {
+    logger.error(`[${requestId}] LaTeX compile route error:`, error)
+    return NextResponse.json(
+      { error: getErrorMessage(error, 'LaTeX compilation failed') },
+      { status: isPayloadSizeLimitError(error) ? 413 : 500 }
+    )
+  }
+})
+
+/**
+ * Builds the output PDF filename: strips any directory components and
+ * normalizes to a single `.pdf` extension.
+ */
+function buildPdfFileName(fileName: string | undefined): string {
+  const base = (fileName || 'document').split(/[/\\]/).pop()?.trim() || 'document'
+  const withoutExtension = base.toLowerCase().endsWith('.pdf') ? base.slice(0, -4) : base
+  return `${withoutExtension || 'document'}.pdf`
+}
+
+/**
+ * Extracts TeX error lines (lines starting with `!`, each with two lines of
+ * context) from the compiler log files returned by the compile service.
+ */
+function extractCompilationErrors(logFiles: unknown): string | undefined {
+  if (typeof logFiles !== 'object' || logFiles === null) return undefined
+
+  const snippets: string[] = []
+  for (const log of Object.values(logFiles)) {
+    if (typeof log !== 'string') continue
+    const lines = log.split('\n')
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith('!')) {
+        snippets.push(lines.slice(i, i + 3).join('\n'))
+      }
+    }
+  }
+
+  if (snippets.length === 0) return undefined
+  return truncate([...new Set(snippets)].join('\n\n'), MAX_ERROR_MESSAGE_CHARS)
+}
+
+/**
+ * Maps a failed compile-service response to a JSON error response: 422 with
+ * extracted TeX errors for compilation failures, 502 for anything unexpected.
+ */
+async function buildCompileErrorResponse(
+  upstreamResponse: Response,
+  requestId: string
+): Promise<NextResponse> {
+  const errorBody = await readResponseJsonWithLimit(upstreamResponse, {
+    maxBytes: MAX_ERROR_JSON_BYTES,
+    label: 'LaTeX compile error response',
+  }).catch(() => undefined)
+
+  const errorRecord =
+    typeof errorBody === 'object' && errorBody !== null
+      ? (errorBody as Record<string, unknown>)
+      : undefined
+  const errorCode =
+    typeof errorRecord?.error === 'string'
+      ? truncate(errorRecord.error, MAX_ERROR_CODE_CHARS)
+      : undefined
+  const compilationErrors = extractCompilationErrors(errorRecord?.log_files)
+  const details = compilationErrors ? `:\n${compilationErrors}` : ''
+
+  const isCompilationFailure =
+    upstreamResponse.status >= 400 &&
+    upstreamResponse.status < 500 &&
+    Boolean(errorCode || compilationErrors)
+
+  if (isCompilationFailure) {
+    logger.warn(`[${requestId}] LaTeX compilation failed`, {
+      status: upstreamResponse.status,
+      errorCode,
+    })
+    return NextResponse.json(
+      { error: `LaTeX compilation failed (${errorCode || upstreamResponse.status})${details}` },
+      { status: 422 }
+    )
+  }
+
+  logger.error(`[${requestId}] LaTeX compile service error`, {
+    status: upstreamResponse.status,
+    errorCode,
+  })
+  return NextResponse.json(
+    { error: `LaTeX compile service error: ${upstreamResponse.status}${details}` },
+    { status: 502 }
+  )
+}
+
+/**
+ * Stores the compiled PDF as an execution file when execution context is
+ * available, falling back to general storage otherwise.
+ */
+async function storeCompiledPdf(
+  pdfBuffer: Buffer,
+  body: LatexCompileBody,
+  compiler: string,
+  userId: string
+): Promise<StoredPdfResponse> {
+  const fileName = buildPdfFileName(body.fileName)
+  const executionContext =
+    body.workspaceId && body.workflowId && body.executionId
+      ? {
+          workspaceId: body.workspaceId,
+          workflowId: body.workflowId,
+          executionId: body.executionId,
+        }
+      : null
+
+  if (executionContext) {
+    const { uploadExecutionFile } = await import('@/lib/uploads/contexts/execution')
+    const pdfFile = await uploadExecutionFile(
+      executionContext,
+      pdfBuffer,
+      fileName,
+      'application/pdf',
+      userId
+    )
+
+    return {
+      pdfFile,
+      pdfUrl: pdfFile.url,
+      fileName,
+      contentType: 'application/pdf',
+      compiler,
+    }
+  }
+
+  const { StorageService } = await import('@/lib/uploads')
+  const fileInfo = await StorageService.uploadFile({
+    file: pdfBuffer,
+    fileName,
+    contentType: 'application/pdf',
+    context: 'copilot',
+  })
+
+  return {
+    pdfUrl: `${getBaseUrl()}${fileInfo.path}`,
+    fileName,
+    contentType: 'application/pdf',
+    compiler,
+  }
+}