Bento, the office suite that fits in a file
TypeScript mit-licenseofficeoffice-365office-suiteoffice-toolsoffice365open-sourcepowerpointself-hostedsingle-page-appslidesslideshareslideshowslideshow-galleryslideshow-makerslideshows
// SPDX-License-Identifier: MIT
// Copyright (c) 2026 The Bento authors
//
// bento convert, driven as a user drives it: a child process, real files, the
// real built slides shell, exit codes and stderr.
//
// Offline by construction — every import here passes --shell, so nothing is
// fetched. The signed-channel path is the delivery rig's (deliver.ts), which
// drives the real verifySigned with a throwaway key. What this rig owns is the
// command line: usage and refusals, the import, the export and the round trip,
// the notes fix end to end, and that a converted file OPENS — booted in headless Chrome through
// scripts/bento-check.mjs, the same harness CI already trusts.
//
// Like the bento-check rig: without Chrome or a built shell it SKIPS locally,
// and in CI a skip is a failure.
import { spawnSync } from 'node:child_process'
import fs from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import { fileURLToPath } from 'node:url'
import { readZip } from '../../kernel/src/convert/zip.ts'
import { fxMinimal } from './_fixtures.ts'
const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '../..')
const cli = path.join(root, 'convert/cli.mjs')
const shell = path.join(root, 'slides/dist-single/Bento_Slides.bento.html')
const inCI = !!process.env.CI || !!process.env.GITHUB_ACTIONS
let failures = 0
let checks = 0
function ok(cond: boolean, msg: string) {
checks++
if (!cond) { failures++; console.log(` FAIL ${msg}`) }
else console.log(` ok ${msg}`)
}
if (!fs.existsSync(shell)) {
const why = `no built shell at ${shell} (cd slides && npm run build:single)`
if (inCI) { console.log(` FAIL ${why} — cannot skip in CI`); process.exit(1) }
console.log(` ⚠ SKIPPED — ${why}`)
process.exit(0)
}
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'convert-cli-rig-'))
const run = (args: string[]) => {
const r = spawnSync(process.execPath, [cli, ...args], { encoding: 'utf8', timeout: 120_000 })
return { code: r.status, out: r.stdout, err: r.stderr }
}
const BLOCK = '<script type="application/bento+json" id="bento-doc">'
const CLOSE = '</' + 'script>'
const docOf = (html: string) => {
const s = html.indexOf(BLOCK) + BLOCK.length
return JSON.parse(html.slice(s, html.indexOf(CLOSE, s)))
}
const deckWith = (doc: unknown) => {
const html = fs.readFileSync(shell, 'utf8')
const s = html.indexOf(BLOCK) + BLOCK.length
return html.slice(0, s) + JSON.stringify(doc).replace(/</g, '\\u003c') + html.slice(html.indexOf(CLOSE, s))
}
console.log('usage')
{
const r = run([])
ok(r.code === 2 && /usage:/.test(r.err), 'no arguments → exit 2 and the usage')
ok(run(['x.pptx', '--offline']).code === 2, '--offline without --shell → exit 2 (checked before touching the disk)')
ok(run(['x.bento.html']).code === 2, 'a .bento.html without --to pptx → exit 2 (export is asked for, never guessed)')
ok(run(['x.bento.html', '--to', 'docx']).code === 2, '--to docx → exit 2')
ok(run(['x.pptx', '--to', 'pptx']).code === 2, '--to pptx on a .pptx → exit 2')
ok(run(['x.pptx', '--frobnicate']).code === 2, 'an unknown option → exit 2')
ok(run(['missing.pptx', '--shell', shell]).code === 1, 'a missing input → exit 1')
const h = run(['--help'])
ok(h.code === 0 && /usage:/.test(h.out), '--help → exit 0, usage on STDOUT')
ok(run(['convert', '--help']).code === 0, 'a leading `convert` is accepted, for a future `bento` dispatcher')
}
console.log('import')
const pptx = path.join(tmp, 'rig.pptx')
fs.writeFileSync(pptx, await fxMinimal())
const imported = path.join(tmp, 'rig.bento.html')
{
const r = run([pptx, '--shell', shell, '-o', imported])
ok(r.code === 0 && fs.existsSync(imported), `a .pptx imports into the real shell (exit ${r.code})`)
ok(r.out === '', 'stdout stays clean — the report goes to stderr')
ok(/fidelity:/.test(r.err) && /NOT verified against the release channel/.test(r.err),
'stderr carries the report, and says plainly that a --shell was not channel-verified')
const doc = docOf(fs.readFileSync(imported, 'utf8'))
ok(doc.format === 'bento/slides' && doc.title === 'Rig Deck', 'the file carries the converted document')
const gate = spawnSync(process.execPath, [path.join(root, 'scripts/shell-gate.mjs'), imported], { encoding: 'utf8' })
ok(gate.status === 0, 'the output passes the splice-contract gate every release runs')
}
console.log('export, and the round trip')
{
const out = path.join(tmp, 'back.pptx')
const r = run([imported, '--to', 'pptx', '-o', out])
ok(r.code === 0 && fs.existsSync(out), `the imported deck exports back to .pptx (exit ${r.code})`)
const parts = await readZip(new Uint8Array(fs.readFileSync(out)))
ok(parts.has('ppt/presentation.xml') && parts.has('[Content_Types].xml'), 'the .pptx is a real package')
// The notes fix, end to end through the CLI: a deck with speaker notes must
// carry notesStyle in its notes master and a notes-master theme of its own.
const base = docOf(fs.readFileSync(imported, 'utf8'))
base.slides[0].notes = 'A speaker note.'
const noted = path.join(tmp, 'noted.bento.html')
fs.writeFileSync(noted, deckWith(base))
const nr = run([noted, '--to', 'pptx', '-o', path.join(tmp, 'noted.pptx')])
const np = await readZip(new Uint8Array(fs.readFileSync(path.join(tmp, 'noted.pptx'))))
const nm = new TextDecoder().decode(np.get('ppt/notesMasters/notesMaster1.xml') ?? new Uint8Array())
const nmRels = new TextDecoder().decode(np.get('ppt/notesMasters/_rels/notesMaster1.xml.rels') ?? new Uint8Array())
ok(nr.code === 0 && /<p:notesStyle>/.test(nm), 'a deck with notes exports a notes master carrying p:notesStyle')
ok(np.has('ppt/theme/theme2.xml') && /theme2\.xml/.test(nmRels),
'and the notes master owns its own theme part (theme2.xml), not a share of the slide master’s')
}
console.log('the report, and document JSON in')
{
// export the imported deck once more, asking for the report as data
const rj = path.join(tmp, 'report.json')
const r = run([imported, '--to', 'pptx', '-o', path.join(tmp, 'again.pptx'), '--report', rj])
let rep: { entries?: unknown[]; counts?: unknown } = {}
try { rep = JSON.parse(fs.readFileSync(rj, 'utf8')) } catch { /* reported below */ }
ok(r.code === 0 && Array.isArray(rep.entries) && !!rep.counts, '--report writes the full fidelity report as JSON')
// a deck with an omitted state names "the whole deck"; per-slide losses name slides
const base = docOf(fs.readFileSync(imported, 'utf8'))
base.slides[0].transition = 'morph'
const json = path.join(tmp, 'doc.json')
fs.writeFileSync(json, JSON.stringify(base))
const j = run([json, '--to', 'pptx', '-o', path.join(tmp, 'from-json.pptx')])
ok(j.code === 0 && fs.existsSync(path.join(tmp, 'from-json.pptx')), `document JSON exports like a .bento.html (exit ${j.code})`)
ok(/morph-not-exported \(slide 1\)/.test(j.err), 'each report line names the slides it happened on')
}
console.log('interactive states: on by default, --no-states leaves them out')
{
const base = docOf(fs.readFileSync(imported, 'utf8'))
base.slides.push({ ...base.slides[0], id: 'st', stateOf: base.slides[0].id, notes: 'state' })
const f = path.join(tmp, 'states.bento.html')
fs.writeFileSync(f, deckWith(base))
const count = async (p: string) => [...(await readZip(new Uint8Array(fs.readFileSync(p)))).keys()].filter((k) => /^ppt\/slides\/slide\d+\.xml$/.test(k)).length
const def = run([f, '--to', 'pptx', '-o', path.join(tmp, 'default.pptx')])
const off = run([f, '--to', 'pptx', '--no-states', '-o', path.join(tmp, 'no-states.pptx')])
const alias = run([f, '--to', 'pptx', '--states', '-o', path.join(tmp, 'alias.pptx')])
const a = await count(path.join(tmp, 'no-states.pptx')), b = await count(path.join(tmp, 'default.pptx'))
ok(def.code === 0 && b === a + 1 && /states-as-hidden-slides/.test(def.err) && !/state-slides-omitted/.test(def.err),
`by default the state comes along as a hidden slide, and the report says so (${b} slides)`)
ok(off.code === 0 && /state-slides-omitted/.test(off.err) && !/states-as-hidden-slides/.test(off.err),
`--no-states leaves it out, and the report says so (${a} slides)`)
ok(alias.code === 0 && await count(path.join(tmp, 'alias.pptx')) === b, '--states is still accepted (a no-op now), so existing scripts keep working')
}
console.log('export refusals, each saying what to do')
{
const refuse = (name: string, doc: unknown, want: RegExp, msg: string) => {
const f = path.join(tmp, name)
fs.writeFileSync(f, deckWith(doc))
const r = run([f, '--to', 'pptx', '-o', path.join(tmp, name + '.pptx')])
ok(r.code === 1 && want.test(r.err) && !fs.existsSync(path.join(tmp, name + '.pptx')), msg)
}
refuse('enc.bento.html', { format: 'bento/enc', v: 1, it: 1, salt: '', iv: '', data: '' },
/password/, 'an encrypted deck is refused, pointing at "save a copy without a password"')
refuse('compact.bento.html', { format: 'bento/slides', compact: true, slides: [] },
/compact/, 'a raw compact document is refused, pointing at opening and saving it once')
refuse('spaces.bento.html', { format: 'bento/spaces', pages: [] },
/only bento\/slides/, 'a non-slides file is refused')
const fresh = run([shell, '--to', 'pptx', '-o', path.join(tmp, 'fresh.pptx')])
ok(fresh.code === 1 && /empty/.test(fresh.err), 'a fresh shell (empty #bento-doc) is refused, not exported as nothing')
}
console.log('it opens')
{
const CHROME = [process.env.BENTO_CHROME, '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
'/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium', '/usr/bin/chromium-browser',
].find((p): p is string => !!p && fs.existsSync(p))
?? (spawnSync('which', ['google-chrome']).status === 0 ? 'google-chrome' : undefined)
if (!CHROME) {
if (inCI) ok(false, 'no Chrome — the "it opens" check cannot skip in CI')
else console.log(' ⚠ SKIPPED — no Chrome found (set BENTO_CHROME)')
} else {
// The converted DOCUMENT, booted in the real shell through bento-check's
// JSON input — not the spliced .bento.html. Measured 2026-09-26: on a
// loaded machine bento-check's .bento.html input path runs to its 90s
// ceiling for ANY file (the bare shell reports at 90042ms; a tiny
// hand-written deck never reports), while the same document as JSON boots
// in 738ms. That is bento-check's defect, filed for ops, and not a reason
// to weaken this check. The spliced FILE is covered separately and fully
// above: the splice-contract gate, and an exact read-back of the block.
const json = path.join(tmp, 'imported.json')
fs.writeFileSync(json, JSON.stringify(docOf(fs.readFileSync(imported, 'utf8'))))
const r = spawnSync(process.execPath, [path.join(root, 'scripts/bento-check.mjs'), json, '--shell', shell, '--json', '--fail-on', 'error'],
{ encoding: 'utf8', timeout: 180_000, env: { ...process.env, BENTO_CHROME: CHROME } })
let report: { ok?: boolean; slides?: number } | null = null
try { report = JSON.parse(r.stdout) } catch { /* reported below */ }
ok(r.status === 0 && report?.ok === true && report.slides === 1,
`the converted document boots in the real shell in headless Chrome, no errors (exit ${r.status}, slides ${report?.slides})`)
}
}
fs.rmSync(tmp, { recursive: true, force: true })
console.log(`\n${checks - failures}/${checks} checks passed`)
if (failures) process.exit(1)