Swift 4.0 Cocoa应用中使用XeTeX渲染LaTeX的方案探讨

Great question—let’s break down your situation and walk through practical, production-ready fixes for your Cocoa app. You’re building a Swift 4.0 app that needs XeTeX for LaTeX rendering (to support custom TTF fonts), ran into sandbox restrictions when calling XeTeX directly, and want to avoid forcing users to install TeX Live manually. Here’s what you can do:

1. Fix Sandbox Permissions Without Disabling Entirely #

Turning off the sandbox is a quick fix but bad for security and App Store compliance. Instead, adjust your entitlements and code to work within sandbox rules:

• Enable Critical Sandbox Entitlements:
  In Xcode’s Capabilities tab (under App Sandbox):

  • Tick Outgoing Connections (Client) (lets your app execute external binaries and resolve paths)
  • Add file access exceptions: Under "File Access", enable Read/Write for "User Selected Files" (if users import LaTeX files) and your app’s document directory (e.g., "Downloads Folder" or "App Data Container")

• Avoid Hardcoded XeTeX Paths:
  /Library/TeX/texbin/xetex isn’t reliable for all TeX Live installations. Use kpsewhich (a built-in TeX utility) to dynamically locate XeTeX:

  func findXeTeXPath() -> String? {
      let task = Process()
      task.launchPath = "/usr/bin/kpsewhich"
      task.arguments = ["xetex"]
      
      let pipe = Pipe()
      task.standardOutput = pipe
      
      do {
          try task.run()
          task.waitUntilExit()
          
          let data = pipe.fileHandleForReading.readDataToEndOfFile()
          return String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines)
      } catch {
          print("Failed to locate XeTeX: \(error)")
          return nil
      }
  }
  

• Call XeTeX Directly (Skip the Bash Script):
  Ditching the shell script reduces sandbox friction and simplifies debugging. Here’s updated ViewController code:

  let texFileName = "TemplateMODIFIED.tex"
  let pdfFileName = "TemplateMODIFIED.pdf"
  
  if let dir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first,
     let xetexPath = findXeTeXPath() {
      
      let texFileURL = dir.appendingPathComponent(texFileName)
      let pdfFileURL = dir.appendingPathComponent(pdfFileName)
      
      let task = Process()
      task.launchPath = xetexPath
      // Configure XeTeX to output to your document directory
      task.arguments = ["-output-directory", dir.path, texFileURL.path]
      
      // Capture output for debugging
      let outputPipe = Pipe()
      let errorPipe = Pipe()
      task.standardOutput = outputPipe
      task.standardError = errorPipe
      
      do {
          try task.run()
          task.waitUntilExit()
          
          if FileManager.default.fileExists(atPath: pdfFileURL.path) {
              NSWorkspace.shared.open(pdfFileURL)
          } else {
              let errorData = errorPipe.fileHandleForReading.readDataToEndOfFile()
              let errorString = String(data: errorData, encoding: .utf8) ?? "Unknown error"
              print("XeTeX failed: \(errorString)")
          }
      } catch {
          print("Failed to launch XeTeX: \(error)")
      }
  } else {
      print("XeTeX not found—prompt user to install TeX Live/MacTeX")
  }
  

2. Eliminate User Dependency on XeTeX #

If you want your app to work out of the box without requiring users to install TeX Live, try these options:

• Package a Minimal TeX Live Subset:
  Bundle a trimmed-down TeX Live installation into your app’s Contents/Resources folder. Use tlmgr (TeX Live’s package manager) to install only essential components: xetex, latex, fontspec, and core font support. Then update your code to reference the bundled XeTeX (e.g., Bundle.main.path(forResource: "xetex", ofType: nil, inDirectory: "texbin")). Note: This adds ~100-200MB to your app size, but TeX Live is open-source so redistribution is allowed.

• Use an Embedded Rendering Library:
  Look for Objective-C/Swift bindings to XeTeX’s core library (libtexpdf). While this requires more low-level work, it lets you render LaTeX directly in your app without calling external binaries. Frameworks like LaTeXKit (check open-source repos) also offer higher-level rendering—just confirm they support XeTeX’s custom font features.

3. Cloud Rendering Workaround #

If you still prefer cloud rendering, consider self-hosting a lightweight XeTeX service (using Python/Go instead of Node.js) that your app can call via HTTP. Serverless functions (e.g., AWS Lambda with TeX Live installed) are a low-maintenance option, and this avoids sandbox issues entirely.

内容的提问来源于stack exchange，提问作者Merwin