CtrlK
BlogDocsLog inGet started
Tessl Logo
PluginPublic

adobe/stardust

Redesign an existing website to make it better. Built on top of impeccable.

Quality

88%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Low

Low-risk findings worth noting

Overview
Quality
Evals
Security
Files

media-reconcile.test.mjsskills/rollout/scripts/test/

#!/usr/bin/env node
// skills/rollout/scripts/test/media-reconcile.test.mjs — the media-reconcile.mjs contract: a URL on
// the site's content host (content|admin.da.live) is `hosted` — never fetched anonymously, verified
// offline against the media ledger (exact, query-stripped and re-encoded forms; missing from an
// existing ledger fails the gate, no ledger makes it `unresolved` with reason + NOTE and exit 1 —
// an unverified content-host image never passes — a ledger that will not load exits 2) — while
// optimize / keep / rewrite / omit and --apply behave as before. Anonymous fetches go to a local
// HTTP server; nothing reaches the network.
// Run: node --test <this file>   (or node <this file>).
import assert from 'node:assert/strict';
import { spawn } from 'node:child_process';
import {
  mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync,
} from 'node:fs';
import { createServer } from 'node:http';
import { tmpdir } from 'node:os';
import { dirname, join } from 'node:path';
import { after, test } from 'node:test';
import { fileURLToPath } from 'node:url';

const HERE = dirname(fileURLToPath(import.meta.url));
const SCRIPT = join(HERE, '..', 'media-reconcile.mjs');
// realpath: the script prints process.cwd()-based paths, which are already resolved.
const BASE = realpathSync(mkdtempSync(join(tmpdir(), 'media-reconcile-test-')));

// Every anonymous GET the script makes lands here (200 for /ok.jpg, 404 otherwise) and is
// recorded in `seen` — a hosted URL must never show up, and must never leave for the network.
const seen = [];
const server = createServer((req, res) => {
  seen.push(req.url);
  if (req.url === '/ok.jpg') { res.writeHead(200, { 'content-type': 'image/jpeg' }); res.end('jpg'); }
  else { res.writeHead(404); res.end(); }
});
await new Promise((ready) => server.listen(0, '127.0.0.1', ready));
const HOST = `127.0.0.1:${server.address().port}`;
const EXT = `http://${HOST}`;
after(() => {
  server.closeAllConnections(); server.close(); rmSync(BASE, { recursive: true, force: true });
});

// The script fetches asynchronously, so it must run asynchronously too — spawnSync would block
// the event loop this server answers on.
const run = (args, cwd) => new Promise((done) => {
  const p = spawn(process.execPath, [SCRIPT, ...args], { cwd });
  let out = ''; let err = '';
  p.stdout.on('data', (d) => { out += d; }); p.stderr.on('data', (d) => { err += d; });
  p.on('close', (code) => done({ code, out, err }));
});
const jsonOf = (r) => JSON.parse(r.out);
const rowsOf = (r) => Object.fromEntries(jsonOf(r).results.map((x) => [x.url, x]));
const project = () => mkdtempSync(join(BASE, 'p-'));
const img = (src) => `<img src="${src}" alt="">`;
const page = (dir, body, name = 'page.html') => {
  const p = join(dir, name); writeFileSync(p, `<main>\n${body.join('\n')}\n</main>\n`); return p;
};

// A media ledger as the deploy step writes it: keyed by DA path, contentUrl with each path
// segment encodeURIComponent()ed, status 'uploaded' on success.
const SITE = 'site.example.org';
const CDN = 'https://content.da.live/acme/site/media/home';
const rec = (name, extra = {}) => ({
  status: 'uploaded', file: `media/home/${name}`, size: 3, sha256: 'abc', contentType: 'image/jpeg',
  source: null, contentUrl: `${CDN}/${name}`, httpStatus: 201, ts: '2026-01-01T00:00:00.000Z', ...extra,
});
const LEDGER = {
  'media/home/hero.jpg': rec('hero.jpg'),
  'media/home/team photo.jpg': rec('team%20photo.jpg'),
  'media/home/café.jpg': rec('café.jpg'), // a decoded contentUrl (another tool's ledger)
  'media/home/failed.jpg': rec('failed.jpg', { status: 'failed', error: 'PUT 500' }),
};
const writeLedger = (dir, rel, data) => {
  const p = join(dir, rel); mkdirSync(dirname(p), { recursive: true });
  writeFileSync(p, typeof data === 'string' ? data : JSON.stringify(data, null, 2)); return p;
};

test('hosted URLs in the ledger (exact, ?width=750, srcset with &, decoded/encoded segments) pass offline', async () => {
  const dir = project(); seen.length = 0;
  const ledger = writeLedger(dir, 'ledger.json', LEDGER);
  const hosted = [`${CDN}/hero.jpg`, `${CDN}/hero.jpg?width=750`, `${CDN}/team photo.jpg`, `${CDN}/caf%C3%A9.jpg`];
  const file = page(dir, [
    img(`https://${SITE}/media_1.png`), ...hosted.map(img), img(`${EXT}/ok.jpg`),
    `<picture><source srcset="${CDN}/hero.jpg?width=2000&format=webply 2000w">${img(`${CDN}/hero.jpg`)}</picture>`,
  ]);
  const r = await run(['--file', file, '--deploy-host', SITE, '--media-ledger', ledger, '--json'], dir);
  assert.equal(r.code, 0, r.err + r.out);
  const j = jsonOf(r);
  assert.deepEqual(j.counts, { optimize: 1, hosted: 5, keep: 1 });
  assert.equal(j.mediaLedger, ledger);
  for (const row of j.results.filter((x) => x.decision === 'hosted')) {
    assert.equal(row.status, null, `${row.url} was never fetched`); assert.equal(row.ledger, 'uploaded', row.url);
    assert.equal(row.host, 'content.da.live'); assert.equal(row.suggested, null);
  }
  assert.equal(rowsOf(r)[`https://${SITE}/media_1.png`].ledger, null, 'non-hosted rows carry ledger: null');
  assert.deepEqual(seen, ['/ok.jpg'], 'the server saw only the external URL');
  assert.equal(r.err, '', 'no NOTE when a ledger was loaded');
});

test('a hosted URL absent from an existing ledger (or not uploaded) fails the gate with a marker; --apply leaves it', async () => {
  const dir = project(); seen.length = 0;
  const ledger = writeLedger(dir, 'ledger.json', LEDGER);
  const body = [img(`${CDN}/hero.jpg`), img(`${CDN}/orphan.jpg`), img(`${CDN}/failed.jpg?width=750`)];
  const file = page(dir, body); const before = readFileSync(file, 'utf8');
  const text = await run(['--file', file, '--deploy-host', SITE, '--media-ledger', ledger], dir);
  assert.equal(text.code, 1, text.out);
  assert.match(text.out, /^ {2}✓ hosted {3}https:\/\/content\.da\.live\/acme\/site\/media\/home\/hero\.jpg$/m, text.out);
  assert.match(text.out, /^ {2}✗ hosted {3}\S+\/orphan\.jpg \(not in ledger\)$/m, text.out);
  assert.match(text.out, /^ {2}✗ hosted {3}\S+\/failed\.jpg\?width=750 \(not in ledger\)$/m, text.out);
  assert.match(text.out, /^3 hosted$/m, 'the summary counts hosted');
  const rows = rowsOf(await run(['--file', file, '--deploy-host', SITE, '--media-ledger', ledger, '--json'], dir));
  assert.equal(rows[`${CDN}/hero.jpg`].ledger, 'uploaded');
  assert.equal(rows[`${CDN}/orphan.jpg`].ledger, 'missing');
  assert.equal(rows[`${CDN}/failed.jpg?width=750`].ledger, 'missing', 'a failed upload is not an upload');
  const applied = await run(['--file', file, '--media-ledger', ledger, '--apply'], dir);
  assert.equal(applied.code, 1); assert.equal(readFileSync(file, 'utf8'), before, '--apply never touches hosted');
  assert.deepEqual(seen, [], 'nothing was fetched');
});

test('no ledger file and no flag: a content-host URL is unresolved (reason: no media ledger), exit 1, one stderr NOTE naming the auto path; never fetched', async () => {
  const dir = project(); seen.length = 0;
  const file = page(dir, [img(`${CDN}/hero.jpg`), img(`https://${SITE}/media_1.png`)]); const before = readFileSync(file, 'utf8');
  const r = await run(['--file', 'page.html', '--deploy-host', SITE, '--json'], dir);
  assert.equal(r.code, 1, r.err + r.out);
  const j = jsonOf(r);
  assert.equal(j.mediaLedger, null);
  assert.deepEqual(j.counts, { optimize: 1, unresolved: 1 }, 'no `hosted` without a ledger');
  const row = rowsOf(r)[`${CDN}/hero.jpg`];
  assert.equal(row.decision, 'unresolved'); assert.equal(row.ledger, 'no-ledger'); assert.equal(row.status, null, 'never fetched anonymously');
  assert.equal(row.reason, 'no media ledger — pass --media-ledger <file>');
  assert.equal(rowsOf(r)[`https://${SITE}/media_1.png`].reason, undefined, 'only the unverified row carries a reason');
  const auto = join(dir, 'stardust', 'deploy', 'media-ledger.json');
  assert.equal(r.err.trim(), `media-reconcile: no media ledger at ${auto} — 1 content-host URL(s) unverified → unresolved (pass --media-ledger <file>)`);
  assert.deepEqual(seen, []);
  const text = await run(['--file', 'page.html', '--deploy-host', SITE, '--apply'], dir);
  assert.equal(text.code, 1, text.out);
  assert.match(text.out, /^ {2}\? manual {3}\S+\/hero\.jpg \(no media ledger — pass --media-ledger <file>\)$/m, text.out);
  assert.match(text.out, /^1 unresolved · 1 optimize$/m, text.out);
  assert.equal(readFileSync(file, 'utf8'), before, '--apply never deletes an unresolved image');
  page(dir, [img(`https://${SITE}/a.png`)], 'page2.html');
  const quiet = await run(['--file', 'page2.html', '--deploy-host', SITE], dir);
  assert.equal(quiet.code, 0); assert.equal(quiet.err, '', 'no NOTE when the page has no content-host URL');
});

test('the same content-host URL: no ledger → unresolved exit 1; ledger listing it → hosted exit 0; ledger missing it → fails exit 1', async () => {
  const dir = project(); seen.length = 0;
  const file = page(dir, [img(`${CDN}/hero.jpg`)]);
  const none = await run(['--file', file, '--json'], dir);
  assert.equal(none.code, 1); assert.equal(rowsOf(none)[`${CDN}/hero.jpg`].decision, 'unresolved');
  const listed = writeLedger(dir, 'listed.json', { 'media/home/hero.jpg': rec('hero.jpg') });
  const ok = await run(['--file', file, '--media-ledger', listed, '--json'], dir);
  assert.equal(ok.code, 0, ok.err + ok.out); assert.deepEqual(jsonOf(ok).counts, { hosted: 1 });
  assert.equal(rowsOf(ok)[`${CDN}/hero.jpg`].ledger, 'uploaded'); assert.equal(ok.err, '');
  const other = writeLedger(dir, 'other.json', { 'media/home/other.jpg': rec('other.jpg') });
  const missing = await run(['--file', file, '--media-ledger', other, '--json'], dir);
  assert.equal(missing.code, 1); assert.deepEqual(jsonOf(missing).counts, { hosted: 1 });
  assert.equal(rowsOf(missing)[`${CDN}/hero.jpg`].ledger, 'missing');
  assert.deepEqual(seen, [], 'the content host was never fetched in any of the three runs');
});

test('the ledger is auto-detected at <cwd>/stardust/deploy/media-ledger.json without the flag', async () => {
  const dir = project(); seen.length = 0;
  const auto = writeLedger(dir, join('stardust', 'deploy', 'media-ledger.json'), LEDGER);
  page(dir, [img(`${CDN}/hero.jpg`), img(`${CDN}/orphan.jpg`)]);
  const r = await run(['--file', 'page.html', '--deploy-host', SITE, '--json'], dir);
  assert.equal(r.code, 1, r.out);
  assert.equal(jsonOf(r).mediaLedger, auto);
  assert.equal(rowsOf(r)[`${CDN}/hero.jpg`].ledger, 'uploaded');
  assert.equal(rowsOf(r)[`${CDN}/orphan.jpg`].ledger, 'missing');
  assert.equal(r.err, '', 'no NOTE when the auto-detected ledger loads');
});

test('an explicit --media-ledger that is missing, invalid or dangling exits 2 with one stderr line; nothing written', async () => {
  const dir = project(); seen.length = 0;
  const file = page(dir, [img(`${CDN}/hero.jpg`), img(`${EXT}/gone.jpg`)]); const before = readFileSync(file, 'utf8');
  const missing = await run(['--file', file, '--media-ledger', join(dir, 'nope.json'), '--apply'], dir);
  assert.equal(missing.code, 2); assert.equal(missing.out, '');
  assert.equal(missing.err.trim().split('\n').length, 1, missing.err);
  assert.match(missing.err, /media-reconcile: media ledger \S+\/nope\.json: not found/);
  const bad = writeLedger(dir, 'bad.json', '{ not json');
  const invalid = await run(['--file', file, '--media-ledger', bad, '--apply'], dir);
  assert.equal(invalid.code, 2); assert.equal(invalid.out, '');
  assert.equal(invalid.err.trim().split('\n').length, 1, invalid.err);
  assert.match(invalid.err, /media-reconcile: media ledger \S+\/bad\.json: /);
  const dangling = await run(['--file', file, '--media-ledger'], dir);
  assert.equal(dangling.code, 2); assert.match(dangling.err, /--media-ledger needs <file>/);
  assert.equal(readFileSync(file, 'utf8'), before, 'the page is untouched');
  assert.deepEqual(seen, [], 'exit 2 happens before any fetch');
  assert.deepEqual(readdirSync(dir).sort(), ['bad.json', 'page.html']);
});

test('an auto-detected ledger that will not parse also exits 2 — a corrupt ledger is a defect, not a pass', async () => {
  const dir = project();
  writeLedger(dir, join('stardust', 'deploy', 'media-ledger.json'), '[oops');
  page(dir, [img(`${CDN}/hero.jpg`)]);
  const r = await run(['--file', 'page.html', '--json'], dir);
  assert.equal(r.code, 2); assert.equal(r.out, '');
  assert.match(r.err, /media-reconcile: media ledger \S+\/media-ledger\.json: /);
});

test('ledger shapes: an entries wrapper or a bare array are read too; only status uploaded counts', async () => {
  const dir = project();
  const file = page(dir, [img(`${CDN}/hero.jpg`), img(`${CDN}/failed.jpg`)]);
  const shapes = [{ entries: [rec('hero.jpg'), rec('failed.jpg', { status: 'failed' })] }, [rec('hero.jpg')]];
  for (const shape of shapes) {
    const ledger = writeLedger(dir, 'ledger.json', shape);
    const rows = rowsOf(await run(['--file', file, '--media-ledger', ledger, '--json'], dir));
    assert.equal(rows[`${CDN}/hero.jpg`].ledger, 'uploaded'); assert.equal(rows[`${CDN}/failed.jpg`].ledger, 'missing');
  }
});

test('regression + --apply: optimize / keep [200] / rewrite / omit [404] as before; omit removed, hosted intact', async () => {
  const dir = project(); seen.length = 0;
  const ledger = writeLedger(dir, 'ledger.json', LEDGER);
  const hostedImg = img(`${CDN}/hero.jpg?width=750`); const sameImg = img(`https://${SITE}/media_1.png`);
  const file = page(dir, [sameImg, img(`${EXT}/ok.jpg`), img(`${EXT}/gone.jpg`), img(`${EXT}/moved.jpg`), hostedImg]);
  const r = await run(['--file', file, '--deploy-host', SITE, '--media-ledger', ledger, '--apply',
    '--host-rewrite', `${HOST}/moved=${HOST}/ok`], dir);
  assert.equal(r.code, 1, r.out);
  assert.match(r.out, /^media-reconcile \S+\/page\.html \(APPLIED\)$/m);
  assert.match(r.out, /^ {2}✓ optimize https:\/\/site\.example\.org\/media_1\.png$/m, r.out);
  assert.match(r.out, /^ {2}✓ keep {5}\[200\] http:\/\/127\.0\.0\.1:\d+\/ok\.jpg$/m, r.out);
  assert.match(r.out, /^ {2}✗ omit {5}\[404\] http:\/\/127\.0\.0\.1:\d+\/gone\.jpg$/m, r.out);
  assert.match(r.out, /^ {2}→ rewrite {2}\[200\] http:\/\/127\.0\.0\.1:\d+\/moved\.jpg\n +→ http:\/\/127\.0\.0\.1:\d+\/ok\.jpg$/m, r.out);
  assert.match(r.out, /^ {2}✓ hosted {3}https:\/\/content\.da\.live\/\S+\/hero\.jpg\?width=750$/m, r.out);
  assert.match(r.out, /^1 optimize · 1 keep · 1 omit · 1 rewrite · 1 hosted$/m, r.out);
  const doc = readFileSync(file, 'utf8');
  assert.ok(!doc.includes('gone.jpg'), 'the omitted <img> is gone');
  assert.ok(!doc.includes('moved.jpg') && doc.split('/ok.jpg').length === 3, 'the rewrite landed');
  assert.ok(doc.includes(hostedImg), 'the hosted <img> is byte-identical');
  assert.ok(doc.includes(sameImg), 'the same-origin <img> is untouched');
  assert.deepEqual(seen.sort(), ['/gone.jpg', '/moved.jpg', '/ok.jpg', '/ok.jpg'], 'three external URLs + the repaired one');
});

test('--help: exit 0, usage names hosted, --media-ledger and the exit rule; nothing written in an empty cwd', async () => {
  const dir = project();
  const r = await run(['--help'], dir);
  assert.equal(r.code, 0, r.err); assert.equal(r.err, '');
  assert.match(r.out, /Usage:/); assert.match(r.out, /^\s*hosted\s+— on the site's content host/m);
  assert.match(r.out, /--media-ledger <file>/);
  assert.match(r.out, /exit 1 on omit, unresolved\s+\(a content-host URL with no ledger to verify it included\), or a hosted URL missing from\s+the ledger/);
  assert.match(r.out, /none → every content-host URL is\s+`unresolved`/);
  assert.deepEqual(readdirSync(dir), []);
});

skills

README.md

tile.json