From ba4b30ead97daa1172bdefd00d75d82cb5ece5c8 Mon Sep 17 00:00:00 2001 From: Divide-By-0 Date: Mon, 28 Sep 2026 17:40:02 -0700 Subject: [PATCH] Validate CodeCogs PNG responses and avoid low-resolution fallbacks --- Common/Code.ts | 51 +++++++--- Slides/Code.ts | 6 +- Workspace/Docs.ts | 2 +- tests/codecogs-validation.test.js | 118 +++++++++++++++++++++++ tests/fixtures/codecogs/README.md | 15 +++ tests/fixtures/codecogs/invalid-dpi.json | 1 + tests/fixtures/codecogs/valid.json | 1 + tests/helpers/render-matrix.js | 9 +- tests/retired-renderers.test.js | 2 +- types/common-types/index.d.ts | 2 +- 10 files changed, 188 insertions(+), 19 deletions(-) create mode 100644 tests/codecogs-validation.test.js create mode 100644 tests/fixtures/codecogs/README.md create mode 100644 tests/fixtures/codecogs/invalid-dpi.json create mode 100644 tests/fixtures/codecogs/valid.json diff --git a/Common/Code.ts b/Common/Code.ts index a1c8a15..bd8a575 100644 --- a/Common/Code.ts +++ b/Common/Code.ts @@ -59,7 +59,7 @@ interface LegacyRenderArgs { } interface RenderEquationResult { - resp: GoogleAppsScript.URL_Fetch.HTTPResponse | null; + resp: Pick | null; renderer: Renderer | null; rendererType: string; worked: number; @@ -299,7 +299,11 @@ function getRendererOrder() { for (let worked = 1; worked <= capableRenderers; ++worked) { // REASON: retired services are still listed in getRenderer so old equations de-render, // but attempting them here only costs two doomed fetches and a sleep per equation. - if (isRetiredRendererFamily(getRenderer(worked)[5])) continue; + const renderer = getRenderer(worked); + if (isRetiredRendererFamily(renderer[5])) continue; + // REASON: GIF ignores high DPI and staging is retired. Keeping these entries + // for de-rendering must not let a fallback silently shrink a 900-DPI equation. + if (renderer[5] === "Codecogs" && !renderer[1].includes("/png.latex?")) continue; defaultOrder.push(worked); } @@ -590,7 +594,7 @@ function renderEquation( ); let equation = ""; let renderer: Renderer | null = null; - let resp: GoogleAppsScript.URL_Fetch.HTTPResponse | null = null; + let resp: Pick | null = null; let failure = 1; let rendererType = ""; let deltaTime: number; @@ -598,7 +602,7 @@ function renderEquation( let failedCodecogs = 0; let failedTexrendr = 0; - let failedResp: GoogleAppsScript.URL_Fetch.HTTPResponse | null = null; + let failedResp: Pick | null = null; let authorizationError = false; // if only failed codecogs, probably weird evening bug from 10/15/19 // if failed codecogs and texrendr, probably shitty equation and the codecogs error is more descriptive so show it @@ -654,15 +658,16 @@ function renderEquation( throw new Error("Equation URL too long for " + rendererType + " (" + renderer[1].length + " chars > 8000)"); } - const _createFileInCache = UrlFetchApp.fetch(renderer[2] + renderer[6] + equation); - // simulates putting text into text renderer => creates link for cached image which is accessed later - // needed for codecogs to generate equation properly, need to figure out which other renderers need this. to test, use align* equations. - - reportDeltaTime(458, " fetching w eqn len " + equation.length + " with renderer " + rendererType); - if (rendererType == "Codecogs" || rendererType == "Sciweavers") { - Utilities.sleep(50); // sleep 50ms to let codecogs put the equation in its cache + if (rendererType === "Codecogs") { + resp = fetchValidatedCodecogsImage(renderer[1]); + } else { + const _createFileInCache = UrlFetchApp.fetch(renderer[2] + renderer[6] + equation); + // NOTE: Retain the legacy cache warmup for other services. CodeCogs JSON + // returns the rendered PNG itself, so it needs neither editor fetch nor sleep. + reportDeltaTime(458, " fetching w eqn len " + equation.length + " with renderer " + rendererType); + if (rendererType === "Sciweavers") Utilities.sleep(50); + resp = UrlFetchApp.fetch(renderer[1]); } - resp = UrlFetchApp.fetch(renderer[1]); // REASON: removed `debugLog(resp, resp.getBlob(), ...)` here — dumping the HTTPResponse and Blob objects // printed ~25 lines of `{ method: [Function], ... }` per equation and was the single largest Cloud Logging // cost. The meaningful part (the hash prefix) is already logged below; re-add only if truly needed. @@ -750,6 +755,28 @@ function renderEquation( } } +// REASON: CodeCogs can return HTTP 200 PNGs containing literal unknown commands +// (including our dpi directive). Byte-prefix error-image signatures cannot detect +// those. Validate the structured response and insert exactly its decoded PNG. +function fetchValidatedCodecogsImage(imageUrl: string): Pick { + const response = UrlFetchApp.fetch(imageUrl.replace("/png.latex?", "/png.json?")); + const latex = JSON.parse(response.getContentText()).latex; + if (!latex || latex.valid !== true || latex.type !== "png" || + !Array.isArray(latex.errors) || latex.errors.length !== 0 || + typeof latex.equation !== "string" || /\\dpi(?:\b|[0-9])/i.test(latex.equation) || + typeof latex.base64 !== "string" || !latex.base64) { + throw new Error("CodeCogs returned an invalid or unvalidated equation"); + } + const bytes = Utilities.base64Decode(latex.base64); + const signature = [137, 80, 78, 71, 13, 10, 26, 10]; + // Apps Script Byte[] values can be signed. + if (bytes.length <= signature.length || signature.some((value, i) => (bytes[i] & 255) !== value)) { + throw new Error("CodeCogs returned invalid PNG data"); + } + const blob = Utilities.newBlob(bytes, "image/png", "equation.png"); + return { getBlob: () => blob }; +} + function isUrlFetchAuthorizationError(err: unknown) { const message = String(err || ""); return message.indexOf("You do not have permission to call UrlFetchApp.fetch") !== -1 || diff --git a/Slides/Code.ts b/Slides/Code.ts index 73a17ec..d06e2d3 100644 --- a/Slides/Code.ts +++ b/Slides/Code.ts @@ -1120,7 +1120,7 @@ function placeImage(slideNum: number, textElement: PageElement, text: GoogleApps return [renderOptions.defaultSize, 1]; } - const { renderer, rendererType, worked, authorizationError } = Common.renderEquation(equationOriginal, renderOptions); + const { resp, renderer, rendererType, worked, authorizationError } = Common.renderEquation(equationOriginal, renderOptions); // REASON: -100001 marks an auth-permission failure so callers (clientRenderFailed) can // surface a "reinstall and grant external_request" message instead of treating it as a // generic renderer-down error. -100000 stays the generic-failure sentinel. @@ -1165,7 +1165,9 @@ function placeImage(slideNum: number, textElement: PageElement, text: GoogleApps scale *= size; - var image = body.insertImage(renderer[1]); + // REASON: Insert the validated bytes; a second URL fetch can return different + // artwork and bypass Common's CodeCogs response validation. + var image = body.insertImage(resp.getBlob()); resize(image, scale, textHorizontalAlignment, textVerticalAlignment, bounds); diff --git a/Workspace/Docs.ts b/Workspace/Docs.ts index dbb2a40..e8a1723 100644 --- a/Workspace/Docs.ts +++ b/Workspace/Docs.ts @@ -244,7 +244,7 @@ function placeImage(startElement: GoogleAppsScript.Document.RangeElement, start: throw new Error("Could not insert image at childindex!"); } -function repairImage(paragraph: GoogleAppsScript.Document.Paragraph, childIndex: number, size: number, defaultSize: number, renderer: AutoLatexCommon.Renderer, delim: AutoLatexCommon.Delimiter, textCopy: GoogleAppsScript.Document.Text, resp: GoogleAppsScript.URL_Fetch.HTTPResponse, rendererType: string, equation: string, equationOriginal: string): [number, null] { +function repairImage(paragraph: GoogleAppsScript.Document.Paragraph, childIndex: number, size: number, defaultSize: number, renderer: AutoLatexCommon.Renderer, delim: AutoLatexCommon.Delimiter, textCopy: GoogleAppsScript.Document.Text, resp: Pick, rendererType: string, equation: string, equationOriginal: string): [number, null] { let attemptsToSetImageUrl = 3; Common.reportDeltaTime(552); // 3 seconds!! inserting an inline image takes time while (attemptsToSetImageUrl > 0) { diff --git a/tests/codecogs-validation.test.js b/tests/codecogs-validation.test.js new file mode 100644 index 0000000..e6bf6cd --- /dev/null +++ b/tests/codecogs-validation.test.js @@ -0,0 +1,118 @@ +const assert = require('node:assert/strict'); +const test = require('node:test'); +const { commonHarness } = require('./helpers/render-matrix'); +const valid = require('./fixtures/codecogs/valid.json'); +const invalid = require('./fixtures/codecogs/invalid-dpi.json'); + +// Real CodeCogs responses captured 2026-09-29 for generic x+1, with +// \\dpi{900} (valid) and \\dpi900 (unknown command). The latter reproduces +// the visible symptom, not the historical upstream trigger for a valid prefix. +function render(payload, failFirst = false) { + const { common } = commonHarness(); + const urls = []; + common.Utilities.base64Decode = value => Array.from(Buffer.from(value, 'base64')); + common.Utilities.newBlob = (bytes, type) => ({ + getDataAsString: () => Buffer.from(bytes).toString('latin1'), + getContentType: () => type, + getBytes: () => bytes, + }); + common.UrlFetchApp.fetch = url => { + urls.push(url); + if (failFirst && urls.length === 1) throw new Error('first endpoint unavailable'); + return { + getContentText: () => JSON.stringify(payload), + getBlob: () => common.Utilities.newBlob(Buffer.from(payload?.latex?.base64 || invalid.latex.base64, 'base64'), 'image/png'), + }; + }; + const delim = common.getDelimiters('$$'); + const result = common.renderEquation('x%2B1', { + ...common.getDefaultRenderOptions(delim), allowedServerFamilies: ['Codecogs'], + }); + return { common, urls, result }; +} + +test('HTTP 200 error artwork must not become a successful equation', () => { + const { common, result } = render(invalid); + assert.ok(result.worked > common.capableRenderers, 'unknown dpi command must fail rendering'); +}); + +test('malformed or unvalidated CodeCogs responses fail closed', () => { + for (const payload of [{}, { latex: { ...valid.latex, valid: undefined } }, + { latex: { ...valid.latex, errors: ['render error'] } }, + { latex: { ...valid.latex, base64: 'bm90IGEgcG5n' } }, + { latex: { ...valid.latex, equation: String.raw`\dpi{900}x+1` } }]) { + const { common, result } = render(payload); + assert.ok(result.worked > common.capableRenderers); + } +}); + +test('validated PNG is returned unchanged and dpi stays out of round-trip source', () => { + const { result } = render(valid); + assert.equal(result.rendererType, 'Codecogs'); + assert.deepEqual(Buffer.from(result.resp.getBlob().getBytes()), Buffer.from(valid.latex.base64, 'base64')); + assert.equal(result.resp.getBlob().getContentType(), 'image/png'); + assert.equal(result.equation.includes('dpi'), false); + assert.equal(result.renderer[2].includes('dpi'), false); +}); + +test('fallback never silently drops PNG quality or calls retired staging', () => { + const { urls } = render(valid, true); + assert.ok(urls.length > 1, 'exercise fallback'); + assert.ok(urls.every(url => !url.includes('gif.') && !url.includes('easygenerator'))); + assert.ok(urls.every(url => url.includes('/png.json?'))); +}); + +test('invalid CodeCogs artwork preserves Docs and Sheets source', () => { + const { loadDocsCode } = require('./helpers/docs-scan'); + const { loadSheetsCode } = require('./helpers/sheets-harness'); + const source = '$$x+1$$'; + const { common } = render(invalid); + const fetch = common.UrlFetchApp.fetch; + common.UrlFetchApp.fetch = url => { + if (!url.includes('codecogs.com')) throw new Error('other renderer unavailable'); + return fetch(url); + }; + const doc = loadDocsCode([source], common.getDelimiters('$$'), common); + doc.context.placeImage = () => assert.fail('invalid artwork must not be inserted'); + doc.context.replaceEquations('smart', '$$', 'codecogs'); + assert.equal(doc.paragraphs[0].textElement.getText(), source); + const sheet = loadSheetsCode([[source]], common); + const result = sheet.context.replaceEquations('smart', '$$', 'codecogs'); + assert.equal(result.successCount, 0); + assert.equal(sheet.sheet.getImages().length, 0); + assert.equal(sheet.rows()[0][0], source); +}); + +test('Slides inserts validated bytes and preserves source on validation failure', () => { + const vm = require('node:vm'); + const { compileScript } = require('./helpers/compile-script'); + for (const payload of [valid, invalid]) { + const { common } = render(payload); + let source = '$$x+1$$', inserted, title; + const body = { insertImage(blob) { inserted = blob; return { setTitle(value) { title = value; } }; } }; + const text = { + getRange: () => text, getLength: () => source.length, asRenderedString: () => source, + getParagraphs: () => [{ getRange: () => ({ getParagraphStyle: () => ({ getParagraphAlignment: () => 'START' }) }) }], + clear() { source = ''; }, + }; + const context = vm.createContext({ Common: common, console: { log() {} }, + IntegratedApp: { getBody: () => [body], newlineCharacter: '\n' }, + SlidesApp: { ShapeType: { TEXT_BOX: 'TEXT_BOX' }, getActivePresentation: () => ({ getSlides: () => [body] }) }, + }); + vm.runInContext(compileScript(require('node:path').join(__dirname, '../Slides/Code.ts')), context); + context.getBounds = () => ({ width: 500, height: 100 }); + context.resize = () => {}; + const result = context.placeImage(0, { getContentAlignment: () => 'TOP', getShapeType: () => 'RECTANGLE' }, text, + { ...common.getDefaultRenderOptions(common.getDelimiters('$$')), size: 12, allowedServerFamilies: ['Codecogs'] }); + if (payload === invalid) { + assert.equal(result, -100000); + assert.equal(source, '$$x+1$$'); + assert.equal(inserted, undefined); + } else { + assert.equal(typeof inserted, 'object', 'insert blob, not an unvalidated URL refetch'); + assert.deepEqual(Buffer.from(inserted.getBytes()), Buffer.from(valid.latex.base64, 'base64')); + assert.equal(source, ''); + assert.equal(JSON.parse(title).origURL.includes('dpi'), false); + } + } +}); diff --git a/tests/fixtures/codecogs/README.md b/tests/fixtures/codecogs/README.md new file mode 100644 index 0000000..c98cc24 --- /dev/null +++ b/tests/fixtures/codecogs/README.md @@ -0,0 +1,15 @@ +These are real public CodeCogs responses captured on 2026-09-29: + +- `valid.json`: `https://latex.codecogs.com/png.json?%5Cdpi%7B900%7Dx%2B1` +- `invalid-dpi.json`: `https://latex.codecogs.com/png.json?%5Cdpi900x%2B1` + +Both return HTTP 200 with a PNG in `latex.base64`; the second reports +`valid: false` and `Unknown command: \\dpi`. Its PNG depicts the rejected command. +This reproduces the error-artwork acceptance defect. It does **not** reproduce +why a correctly braced DPI prefix was mishandled in the historical reports. +The PNG endpoint renders the correctly braced prefix normally at capture time. + +The regression suite runs the real Common renderer against these network-boundary +fixtures. It also checks Docs/Sheets source preservation and Slides' use of the +validated bytes. Host application APIs are mocked; actual Google insertion and +future third-party service behavior require deployment smoke testing. diff --git a/tests/fixtures/codecogs/invalid-dpi.json b/tests/fixtures/codecogs/invalid-dpi.json new file mode 100644 index 0000000..ea4b56b --- /dev/null +++ b/tests/fixtures/codecogs/invalid-dpi.json @@ -0,0 +1 @@ +{"latex": {"type": "png", "equation": "\\dpi900x+1", "valid": false, "base64": "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", "errors": ["Unknown command: \\dpi"]}} \ No newline at end of file diff --git a/tests/fixtures/codecogs/valid.json b/tests/fixtures/codecogs/valid.json new file mode 100644 index 0000000..3dab970 --- /dev/null +++ b/tests/fixtures/codecogs/valid.json @@ -0,0 +1 @@ +{"latex": {"type": "png", "equation": " x+1", "valid": true, "base64": "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", "errors": []}} \ No newline at end of file diff --git a/tests/helpers/render-matrix.js b/tests/helpers/render-matrix.js index 8b00c2d..2335826 100644 --- a/tests/helpers/render-matrix.js +++ b/tests/helpers/render-matrix.js @@ -28,12 +28,17 @@ function commonHarness() { PropertiesService: { getUserProperties: () => ({ setProperty: (k, v) => { prefs[k] = v; }, getProperty: k => prefs[k] || null, }) }, - Utilities: { sleep() {} }, + Utilities: { sleep() {}, + base64Decode: value => Array.from(Buffer.from(value, 'base64')), + newBlob: (bytes, type) => ({ getDataAsString: () => Buffer.from(bytes).toString('latin1'), + getBytes: () => bytes, getContentType: () => type }), + }, // Only the network boundary is doubled. Renderer choice, encoding, styling, // URL construction, response validation and fallback are production Common. UrlFetchApp: { fetch(url) { urls.push(url); - return { getBlob: () => ({ getDataAsString: () => 'valid image fixture' }) }; + return { getContentText: () => JSON.stringify(require('../fixtures/codecogs/valid.json')), + getBlob: () => ({ getDataAsString: () => 'valid image fixture' }) }; } }, }); vm.runInContext(commonSource, common, { filename: 'Common.matrix.js' }); diff --git a/tests/retired-renderers.test.js b/tests/retired-renderers.test.js index 2cdfcbe..cf1ac35 100644 --- a/tests/retired-renderers.test.js +++ b/tests/retired-renderers.test.js @@ -31,7 +31,7 @@ test('retired renderer families are excluded from the render order', () => { } // NOTE: Array.from, because these arrays are built inside the vm realm and deepStrictEqual // compares prototypes - a bare deepEqual against a host-realm literal fails on identical data. - assert.deepEqual(Array.from(order), [1, 2, 3, 4, 6], 'Codecogs and Texrendr entries only'); + assert.deepEqual(Array.from(order), [1, 4, 6], 'Codecogs and Texrendr entries only'); assert.deepEqual(Array.from(common.retiredRendererFamilies), ['Sciweavers', 'Sciweavers_old']); }); diff --git a/types/common-types/index.d.ts b/types/common-types/index.d.ts index 20e92a6..8d6b6e7 100644 --- a/types/common-types/index.d.ts +++ b/types/common-types/index.d.ts @@ -191,7 +191,7 @@ declare namespace AutoLatexCommon { rendererType: string; - resp: GoogleAppsScript.URL_Fetch.HTTPResponse | null; + resp: Pick | null; worked: number;