chore: import upstream snapshot with attribution

apps/sim/lib/copilot/tools/server/files/doc-recalc.ts

@@ -0,0 +1,122 @@
+import { createLogger } from '@sim/logger'
+import { executeInE2B } from '@/lib/execution/e2b'
+import { CodeLanguage } from '@/lib/execution/languages'
+import { compileDoc, DocCompileUserError } from './doc-compile'
+
+const logger = createLogger('CopilotDocRecalc')
+
+const RECALC_TIMEOUT_MS = 150_000
+const MAX_REPORTED_ERRORS = 50
+
+export interface XlsxCellError {
+  sheet: string
+  cell: string
+  error: string
+}
+
+export interface XlsxRecalcResult {
+  ok: boolean
+  errors: XlsxCellError[]
+}
+
+/**
+ * Scans an .xlsx workbook for spilled error values (#REF!/#DIV/0!/etc.) — the
+ * spreadsheet equivalent of the visual QA loop.
+ *
+ * Precondition: the binary must already be recalculated (cached values present).
+ * compileDoc bakes a LibreOffice recalc into every xlsx artifact, so the input
+ * here always has cached values — meaning we can read them with openpyxl
+ * (data_only) directly and skip a second LibreOffice cold-start. Throws on
+ * sandbox/infra failure.
+ */
+export async function recalcXlsx(args: {
+  binary: Buffer
+  workspaceId: string
+}): Promise<XlsxRecalcResult> {
+  const script = `
+import json, openpyxl
+
+ERR = {"#REF!", "#DIV/0!", "#VALUE!", "#NAME?", "#N/A", "#NULL!", "#NUM!"}
+
+# Input is already recalculated by compileDoc, so cached values are present.
+wb = openpyxl.load_workbook("/home/user/input.xlsx", data_only=True)
+errors = []
+for ws in wb.worksheets:
+    for row in ws.iter_rows():
+        for c in row:
+            if isinstance(c.value, str) and c.value.strip() in ERR:
+                errors.append({"sheet": ws.title, "cell": c.coordinate, "error": c.value.strip()})
+
+print("__SIM_RESULT__=" + json.dumps({"ok": len(errors) == 0, "errors": errors[:${MAX_REPORTED_ERRORS}]}))
+`.trim()
+
+  const result = await executeInE2B({
+    code: script,
+    language: CodeLanguage.Python,
+    timeoutMs: RECALC_TIMEOUT_MS,
+    sandboxKind: 'doc',
+    sandboxFiles: [
+      {
+        path: '/home/user/input.xlsx',
+        content: args.binary.toString('base64'),
+        encoding: 'base64',
+      },
+    ],
+  })
+
+  if (result.error) {
+    throw new Error(`Spreadsheet recalc failed: ${result.error}`)
+  }
+  const payload = result.result as XlsxRecalcResult | null
+  if (!payload || typeof payload.ok !== 'boolean') {
+    logger.warn('Recalc returned no structured result', { workspaceId: args.workspaceId })
+    return { ok: true, errors: [] }
+  }
+  return { ok: payload.ok, errors: Array.isArray(payload.errors) ? payload.errors : [] }
+}
+
+/** Single-line summary of the first few formula errors, for the compiled-check result. */
+export function formatXlsxErrors(errors: XlsxCellError[]): string {
+  return `${errors.length} formula error(s): ${errors
+    .slice(0, 5)
+    .map((e) => `${e.sheet}!${e.cell}=${e.error}`)
+    .join(', ')}`
+}
+
+export interface CompiledCheckResult {
+  ok: boolean
+  error?: string
+  errors?: XlsxCellError[]
+}
+
+/**
+ * Compiles a generated doc (and, for xlsx, recalc-scans its formulas) to verify
+ * it builds — the shared body behind the /compiled-check route and the VFS
+ * compiled-check read. Returns { ok: false } only for a DocCompileUserError (the
+ * agent's script is wrong); infra failures (E2B/S3) rethrow so callers surface a
+ * 5xx instead of telling the agent to fix its script.
+ */
+export async function runE2BCompiledCheck(args: {
+  source: string
+  fileName: string
+  workspaceId: string
+  ext: string
+}): Promise<CompiledCheckResult> {
+  try {
+    const compiled = await compileDoc({
+      source: args.source,
+      fileName: args.fileName,
+      workspaceId: args.workspaceId,
+    })
+    if (args.ext === 'xlsx') {
+      const recalc = await recalcXlsx({ binary: compiled.buffer, workspaceId: args.workspaceId })
+      return recalc.ok
+        ? { ok: true }
+        : { ok: false, error: formatXlsxErrors(recalc.errors), errors: recalc.errors }
+    }
+    return { ok: true }
+  } catch (err) {
+    if (err instanceof DocCompileUserError) return { ok: false, error: err.message }
+    throw err
+  }
+}