playrig 0.0.0-stage → 0.1.0

package/lib/common.js

@@ -0,0 +1,132 @@
+'use strict';
+// Shared by the After Effects and Premiere Pro clients: argument parsing, inbox roots, result files, edition lookup.
+// Node >= 18, no dependencies.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+const BOOL_FLAGS = new Set(['no-undo', 'json', 'no-snap', 'save-preview', 'full', 'yes', 'replace', 'all', 'dry-run', 'no-open', 'check', 'global', 'force', 'help', 'version']);
+
+// The two editions. `ext` is the job file extension the panel watches for.
+const APPS = {
+  ae: { id: 'ae', name: 'After Effects', product: 'Playrig for After Effects', ext: '.jsx', legacyDir: 'AE Bridge', legacyEnv: 'AE_BRIDGE_ROOT' },
+  pr: { id: 'pr', name: 'Premiere Pro', product: 'Playrig for Premiere Pro', ext: '.js', legacyDir: 'Premiere Bridge', legacyEnv: 'PREMIERE_BRIDGE_ROOT' },
+};
+
+const USAGE = `Playrig: let a coding agent control After Effects and Premiere Pro.
+
+Usage:
+  playrig <ae|pr> run <job> [--id <id>] [--action <id>] [--desc "<what it does>"] [--snap "<comp or sequence>@t1,t2,..."]...
+                        [--inspect "<comp>:<depth>" | "<sequence>"] [--timeout 120] [--no-undo] [--json] [--root <dir>]
+                        (After Effects jobs are .jsx, Premiere Pro jobs are .js)
+  playrig <ae|pr> snap "<comp or sequence>@t1,t2,..." [more specs]   export frames without running a job script
+  playrig <ae|pr> inspect "<comp>:<depth>" | "<sequence>"             report the structure of a comp or sequence
+  playrig status <id> [--app ae|pr]       result (or running/queued state) of a job
+  playrig tail [--app ae|pr] [--all | --project <name>] [--limit 10]   latest jobs of the project of the most recent job
+  playrig <ae|pr> scratch start | status | clean --yes   safe experimenting: remove only what was added since start
+  playrig ae lib list|show|run|index|check|new ...       the motion-recipe library (After Effects)
+  playrig install <ae|pr|skills|all> [--dry-run]         install a panel / the agent skills
+  playrig update [ae|pr|cli] [--check]                    check for (and install) newer versions
+  playrig where                                           show where the editions, library and inboxes are
+
+Short alias: prg (same as playrig).
+Every job has one action: declare it with --action or a first-lines header in the job file:
+  // @action layer.add
+  // Added three null layers for the camera rig
+
+Job inbox: --root, else $PLAYRIG_ROOT/<ae|pr>, else ~/Documents/Playrig/<ae|pr>
+           (an existing ~/Documents/AE Bridge or ~/Documents/Premiere Bridge is still used until the new folder exists).
+Old commands (aeb ...) still work and print a deprecation notice.`;
+
+function die(msg, code = 2) {
+  console.error(msg);
+  process.exit(code);
+}
+
+function parseArgs(argv) {
+  const pos = [];
+  const flags = { snap: [], param: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith('--')) { pos.push(a); continue; }
+    const key = a.slice(2);
+    if (BOOL_FLAGS.has(key)) { flags[key] = true; continue; }
+    if (i + 1 >= argv.length) die(`Missing value for --${key}\n\n${USAGE}`);
+    const val = argv[++i];
+    if (key === 'snap') flags.snap.push(val);
+    else if (key === 'param') flags.param.push(val);
+    else flags[key] = val;
+  }
+  return { pos, flags };
+}
+
+const docs = () => path.join(os.homedir(), 'Documents');
+
+// <Documents>/Playrig/<app>; the pre-rename folder is kept while it is the only one with an inbox, so upgrades keep working.
+function defaultRoot(app) {
+  const fresh = path.join(docs(), 'Playrig', app.id);
+  const legacy = path.join(docs(), app.legacyDir);
+  if (!fs.existsSync(path.join(fresh, 'inbox')) && fs.existsSync(path.join(legacy, 'inbox'))) return legacy;
+  return fresh;
+}
+
+function rootDir(app, flags) {
+  if (flags.root) return path.resolve(flags.root);
+  if (process.env.PLAYRIG_ROOT) return path.resolve(process.env.PLAYRIG_ROOT, app.id);
+  if (process.env[app.legacyEnv]) return path.resolve(process.env[app.legacyEnv]);
+  return defaultRoot(app);
+}
+
+function writeAtomic(file, data) {
+  const tmp = file + '.tmp';
+  fs.writeFileSync(tmp, data);
+  fs.renameSync(tmp, file);
+}
+
+function defaultId(jobPath) {
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, '0');
+  const stamp = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+  const name = path.basename(jobPath, path.extname(jobPath)).replace(/[^A-Za-z0-9_-]+/g, '-');
+  return `${stamp}-${name}`.slice(0, 64);
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function readResult(root, id) {
+  const f = path.join(root, 'out', id, 'result.json');
+  if (!fs.existsSync(f)) return null;
+  return JSON.parse(fs.readFileSync(f, 'utf8'));
+}
+
+// ------------------------------------------------------------------ editions
+// An edition lives in <cli>/editions/<id> in the published npm package, or in the sibling package folder in the monorepo.
+const CLI_DIR = path.join(__dirname, '..');
+function editionDir(id) {
+  const marker = id === 'ae' ? 'panel' : 'plugin';
+  for (const d of [path.join(CLI_DIR, 'editions', id), path.join(CLI_DIR, '..', id)]) {
+    if (fs.existsSync(path.join(d, marker))) return d;
+  }
+  return null;
+}
+function skillsDirs() {
+  const out = [];
+  for (const d of [path.join(CLI_DIR, 'skills'), ...['ae', 'pr'].map((id) => { const e = editionDir(id); return e && path.join(e, 'skills'); })]) {
+    if (d && fs.existsSync(d)) out.push(d);
+  }
+  return out;
+}
+
+// Recipe library: --lib, $PLAYRIG_LIBRARY (or $AE_LIBRARY), the user's ~/Documents/Playrig/library, then a library inside the
+// edition folder (only the source repo has one: no recipes are shipped). Falls back to the user folder so messages can name it.
+const userLibrary = () => path.join(docs(), 'Playrig', 'library');
+function libraryDir(flags = {}) {
+  const hasRecipes = (d) => d && fs.existsSync(path.join(d, 'recipes'));
+  const ed = editionDir('ae');
+  const candidates = [flags.lib, process.env.PLAYRIG_LIBRARY, process.env.AE_LIBRARY, userLibrary(), ed && path.join(ed, 'library')].filter(Boolean).map((d) => path.resolve(d));
+  return candidates.find(hasRecipes) || path.resolve(flags.lib || process.env.PLAYRIG_LIBRARY || process.env.AE_LIBRARY || userLibrary());
+}
+
+module.exports = { libraryDir, userLibrary, ID_RE, BOOL_FLAGS, APPS, USAGE, die, parseArgs, rootDir, defaultRoot, writeAtomic, defaultId, sleep, readResult, editionDir, skillsDirs, CLI_DIR };

package/lib/install.js

@@ -0,0 +1,148 @@
+'use strict';
+// playrig install <ae|pr|skills|all> and playrig where.
+// Each edition installs on its own: someone with only Premiere Pro never needs the After Effects panel, and the reverse.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+const C = require('./common');
+const P = require('./payload');
+const { APPS, die } = C;
+
+const AE_PANEL = 'Playrig.jsx';
+const AE_LIB = 'Playrig lib';
+const PR_PACKAGE = 'Playrig (PR)';
+const SKIP_COPY = /(^|[\\/])(\.venv|__pycache__|\.DS_Store)([\\/]|$)/;
+
+// ------------------------------------------------------------------ where
+function where(pos) {
+  const ae = C.editionDir('ae'), pr = C.editionDir('pr');
+  const items = {
+    ae: ae, pr: pr,
+    library: fs.existsSync(path.join(C.libraryDir(), 'recipes')) ? C.libraryDir() : null,
+    skills: C.skillsDirs().join(path.delimiter) || null,
+    'inbox:ae': C.rootDir(APPS.ae, {}), 'inbox:pr': C.rootDir(APPS.pr, {}),
+  };
+  if (pos[0]) {
+    if (!(pos[0] in items)) die(`playrig where [${Object.keys(items).join('|')}]`);
+    if (!items[pos[0]]) die(`${pos[0]}: not found`, 1);
+    console.log(items[pos[0]]);
+    return;
+  }
+  for (const [k, v] of Object.entries(items)) console.log(`${k.padEnd(10)} ${v || '(not found)'}`);
+}
+
+// ------------------------------------------------------------------ After Effects
+function aePanelFolders() {
+  const out = [];
+  const bases = process.platform === 'win32'
+    ? [path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Adobe')]
+    : process.platform === 'darwin' ? ['/Applications'] : [];
+  for (const base of bases) {
+    if (!fs.existsSync(base)) continue;
+    for (const d of fs.readdirSync(base)) {
+      if (!/^Adobe After Effects/.test(d)) continue;
+      const rel = process.platform === 'win32' ? path.join('Support Files', 'Scripts', 'ScriptUI Panels') : path.join('Scripts', 'ScriptUI Panels');
+      const dir = path.join(base, d, rel);
+      if (fs.existsSync(dir)) out.push(dir);
+    }
+  }
+  return out;
+}
+
+function installAE(flags) {
+  const ed = C.editionDir('ae');
+  if (!ed) die('The After Effects edition was not found next to this CLI.', 1);
+  const targets = flags.to ? [path.resolve(flags.to)] : aePanelFolders();
+  if (!targets.length) {
+    console.log('After Effects: no installation found. Pass --to "<ScriptUI Panels folder>" to install into a specific folder.');
+    return false;
+  }
+  // The stub (Playrig.jsx) goes into ScriptUI Panels and loads the payload (Playrig lib/) beside it, or a newer verified one that
+  // the panel's updater installs in the user's data folder. The payload is staged in the temp folder so the sudo hint below can read it.
+  const stage = path.join(os.tmpdir(), 'playrig-ae-stage');
+  const { version } = P.aePayload(path.join(stage, AE_LIB));
+  fs.copyFileSync(path.join(ed, 'panel', AE_PANEL), path.join(stage, AE_PANEL));
+  let ok = true;
+  for (const dir of targets) {
+    const panelDest = path.join(dir, AE_PANEL), libDest = path.join(dir, AE_LIB);
+    console.log(`After Effects: ${flags['dry-run'] ? 'would install' : 'installing'} Playrig ${version} into ${dir}`);
+    if (flags['dry-run']) continue;
+    try {
+      fs.rmSync(libDest, { recursive: true, force: true });
+      fs.cpSync(path.join(stage, AE_LIB), libDest, { recursive: true });
+      fs.copyFileSync(path.join(stage, AE_PANEL), panelDest);
+    } catch (e) {
+      ok = false;
+      if (e.code === 'EACCES' || e.code === 'EPERM') {
+        console.log(`  Not allowed to write there. Run it with admin rights instead:\n    sudo rm -rf "${libDest}" && sudo cp -R "${path.join(stage, AE_LIB)}" "${libDest}" && sudo cp "${path.join(stage, AE_PANEL)}" "${dir}/"`);
+      } else console.log(`  Failed: ${e.message}`);
+    }
+    const old = ['AE Bridge.jsx', 'AE Bridge lib', 'Playrig (AE).jsx', 'Playrig (AE) lib'].filter((n) => fs.existsSync(path.join(dir, n)));
+    if (old.length) console.log(`  Note: an older panel is still there (${old.join(', ')}). Delete it so After Effects shows one panel.`);
+  }
+  if (ok && !flags['dry-run']) fs.rmSync(stage, { recursive: true, force: true });
+  if (!flags['dry-run'] && ok) console.log('Restart After Effects, open Window > Playrig, and press Start.\nTurn on Preferences > Scripting & Expressions > "Allow Scripts to Write Files and Access Network" once.\nAfter this, updates install from the panel (Settings > About > Check for Updates) without admin rights.');
+  return ok;
+}
+
+// ------------------------------------------------------------------ Premiere Pro
+// Premiere panels are UXP plugins. We package the plugin as a .ccx (a zip) and hand it to the system, which opens the Creative Cloud
+// installer. For development, load plugin/manifest.json in the Adobe UXP Developer Tool instead.
+function installPR(flags) {
+  const ed = C.editionDir('pr');
+  if (!ed) die('The Premiere Pro edition was not found next to this CLI.', 1);
+  const outDir = path.join(os.homedir(), 'Documents', 'Playrig');
+  const ccx = path.join(outDir, `${PR_PACKAGE}.ccx`);
+  console.log(`Premiere Pro: ${flags['dry-run'] ? 'would build' : 'building'} ${ccx}`);
+  if (flags['dry-run']) return true;
+  try { P.prPackage(ccx); } catch (e) { console.log(`  ${e.message}`); return false; }
+  console.log(`  Built ${ccx}`);
+  if (!flags['no-open']) {
+    const opener = process.platform === 'darwin' ? ['open', [ccx]] : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', ccx]] : null;
+    if (opener) { cp.spawnSync(opener[0], opener[1], { stdio: 'ignore' }); console.log('  Opened it with the Creative Cloud installer. Confirm the install there.'); }
+  }
+  console.log([
+    'If the installer refuses an unsigned plugin (or you are developing), load it instead:',
+    '  Adobe UXP Developer Tool > Add Plugin > ' + path.join(ed, 'plugin', 'manifest.json') + ' > Load',
+    'Then in Premiere Pro: Window > Extensions > Playrig, and press Start. Premiere asks once for file access.',
+  ].join('\n'));
+  return true;
+}
+
+// ------------------------------------------------------------------ Skills (Claude Code)
+function installSkills(flags) {
+  const dirs = C.skillsDirs();
+  if (!dirs.length) die('No skills found next to this CLI.', 1);
+  const dest = flags.global ? path.join(os.homedir(), '.claude', 'skills') : path.join(process.cwd(), '.claude', 'skills');
+  console.log(`Skills: ${flags['dry-run'] ? 'would install' : 'installing'} into ${dest}`);
+  for (const d of dirs) {
+    for (const name of fs.readdirSync(d)) {
+      const from = path.join(d, name);
+      if (!fs.statSync(from).isDirectory() || !fs.existsSync(path.join(from, 'SKILL.md'))) continue;
+      console.log(`  ${name}`);
+      if (flags['dry-run']) continue;
+      fs.mkdirSync(dest, { recursive: true });
+      fs.rmSync(path.join(dest, name), { recursive: true, force: true });
+      fs.cpSync(from, path.join(dest, name), { recursive: true, filter: (f) => !SKIP_COPY.test(f) });
+    }
+  }
+  console.log('The agent guide (AGENTS.md) is not a skill: put it, or a CLAUDE.md that points to it, in your project folder.');
+  return true;
+}
+
+function install(pos, flags) {
+  const what = pos[0];
+  if (what === 'ae') return installAE(flags);
+  if (what === 'pr') return installPR(flags);
+  if (what === 'skills') return installSkills(flags);
+  if (what === 'all') {
+    const results = [C.editionDir('ae') && installAE(flags), C.editionDir('pr') && installPR(flags), installSkills(flags)];
+    if (results.includes(false)) process.exitCode = 1;
+    return;
+  }
+  die('Usage: playrig install <ae|pr|skills|all> [--dry-run] [--no-open] [--to <ScriptUI Panels folder>] [--global]', 2);
+}
+
+module.exports = { install, where };

package/lib/main.js

@@ -0,0 +1,107 @@
+'use strict';
+// playrig <ae|pr> <command> ...   one CLI for both editions. The per-app code is in ae.js and pr.js.
+
+const fs = require('fs');
+const path = require('path');
+const C = require('./common');
+const { APPS, USAGE, die, parseArgs } = C;
+
+const APP_IDS = Object.keys(APPS);
+const VERSION = require('../package.json').version;
+
+function loadApp(id) { return require(id === 'ae' ? './ae' : './pr'); }
+
+function newestResult(root) {
+  const out = path.join(root, 'out');
+  if (!fs.existsSync(out)) return 0;
+  let t = 0;
+  for (const d of fs.readdirSync(out)) {
+    try { t = Math.max(t, fs.statSync(path.join(out, d, 'result.json')).mtimeMs); } catch (e) { /* no result yet */ }
+  }
+  return t;
+}
+
+// Which edition does a job id belong to? Looks in both inboxes (ids are timestamped, so a clash is unlikely).
+function locate(id, flags) {
+  return APP_IDS.filter((a) => {
+    const app = APPS[a], root = C.rootDir(app, flags);
+    return fs.existsSync(path.join(root, 'out', id, 'result.json')) || fs.existsSync(path.join(root, 'running', id + app.ext)) || fs.existsSync(path.join(root, 'inbox', id + app.ext));
+  });
+}
+
+function appFromFlag(flags) {
+  if (flags.app === undefined) return null;
+  if (!APPS[flags.app]) die(`--app must be ae or pr (got "${flags.app}")`);
+  return flags.app;
+}
+
+async function main(argv) {
+  const [first, ...rest] = argv;
+  if (!first || first === 'help' || first === '--help' || first === '-h') { console.log(USAGE); return; }
+  if (first === '--version' || first === '-v' || first === 'version') { console.log(`playrig ${VERSION}`); return; }
+
+  // playrig ae|pr <command> ...
+  if (APPS[first]) {
+    const [sub, ...args] = rest;
+    if (!sub) die(USAGE);
+    const { pos, flags } = parseArgs(args);
+    return loadApp(first).main(sub, pos, flags);
+  }
+
+  const { pos, flags } = parseArgs(rest);
+
+  if (first === 'install') return require('./install').install(pos, flags);
+  if (first === 'where') return require('./install').where(pos);
+  if (first === 'update') return require('./update').update(pos, flags);
+
+  // Commands without an app: status and tail find it, run infers it from the file extension.
+  if (first === 'status') {
+    const id = pos[0];
+    if (!id || !C.ID_RE.test(id)) die(`Missing or bad <id>\n\n${USAGE}`);
+    let app = appFromFlag(flags);
+    if (!app) {
+      const hits = flags.root ? [] : locate(id, flags);
+      if (flags.root) die('With --root, say which app: playrig ae status <id> --root ... (or --app ae|pr)');
+      if (hits.length > 1) die(`Job "${id}" exists for both After Effects and Premiere Pro. Add --app ae or --app pr.`);
+      app = hits[0] || null;
+      if (!app) die(`Unknown job "${id}" (looked in both inboxes). Use --app ae|pr or --root if your inbox is elsewhere.`, 1);
+    }
+    return loadApp(app).main('status', pos, flags);
+  }
+
+  if (first === 'tail') {
+    const app = appFromFlag(flags);
+    if (app) return loadApp(app).main('tail', pos, flags);
+    if (flags.root) die('With --root, say which app: --app ae|pr');
+    const times = APP_IDS.map((a) => ({ a, t: newestResult(C.rootDir(APPS[a], flags)) })).filter((x) => x.t > 0).sort((x, y) => y.t - x.t);
+    if (!times.length) { console.log('No results yet in either inbox.'); return; }
+    // --all lists every project of every edition that has results; otherwise the edition with the latest job.
+    const shown = flags.all ? times : times.slice(0, 1);
+    for (const x of shown) { console.log(`== ${APPS[x.a].product}`); await loadApp(x.a).main('tail', pos, flags); }
+    return;
+  }
+
+  if (first === 'run') {
+    let app = appFromFlag(flags);
+    if (!app && pos[0]) {
+      const ext = path.extname(pos[0]).toLowerCase();
+      app = ext === '.jsx' || ext === '.jsxbin' ? 'ae' : ext === '.js' || ext === '.mjs' ? 'pr' : null;
+    }
+    if (!app) die('Say which app: playrig ae run <job.jsx> or playrig pr run <job.js>');
+    return loadApp(app).main('run', pos, flags);
+  }
+
+  return die(`Unknown command "${first}"\n\n${USAGE}`);
+}
+
+// Entry for the deprecated `aeb` clients that still sit at <edition>/client/aeb.js: print one line, then forward.
+function legacy(app, argv) {
+  console.error(`aeb is deprecated: use \`playrig ${app} ${argv[0] || '<command>'}\` (forwarding)`);
+  return run([app, ...argv]);
+}
+
+function run(argv) {
+  return main(argv).catch((e) => die(`playrig: ${e.message}`));
+}
+
+module.exports = { main, run, legacy };

package/lib/payload.js

@@ -0,0 +1,60 @@
+'use strict';
+// Builds what gets installed or released for each edition. Shared by `playrig install`, `playrig update` and scripts/release.js.
+//   AE payload: a flat folder (core.jsx, the lib files, icons/png, version.json). The small stub panel in After Effects' ScriptUI
+//               Panels folder loads it, either the copy installed beside the stub or a newer verified copy in the user's data folder.
+//   PR package: the UXP plugin as a .ccx (a zip), without the developer-only dev.js.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+const C = require('./common');
+
+// Bump when the stub's contract with core.jsx changes; a payload that needs a newer stub is not installed by an older one.
+const STUB_API = 1;
+const SKIP = /(^|[\\/])(\.venv|__pycache__|\.DS_Store)([\\/]|$)/;
+
+// LICENSE sits at the repo root in the monorepo and in the CLI package when published.
+const licenseFile = () => [path.join(C.CLI_DIR, '..', '..', 'LICENSE'), path.join(C.CLI_DIR, 'LICENSE')].find((f) => fs.existsSync(f));
+const readJSON = (f) => JSON.parse(fs.readFileSync(f, 'utf8'));
+const editionVersion = (id) => readJSON(path.join(C.editionDir(id), 'package.json')).version;
+
+function aePayload(dest, versionOverride) {
+  const ed = C.editionDir('ae');
+  if (!ed) throw new Error('The After Effects edition was not found next to this CLI.');
+  const version = versionOverride || editionVersion('ae');
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.mkdirSync(dest, { recursive: true });
+  fs.copyFileSync(path.join(ed, 'panel', 'core.jsx'), path.join(dest, 'core.jsx'));
+  const keep = (src) => !SKIP.test(src) && !/dev\.jsxinc$/.test(src) && !/make-png\.js$/.test(src) && !/icons[\\/][^\\/]+\.(svg|md)$/.test(src);
+  fs.cpSync(path.join(ed, 'lib'), dest, { recursive: true, filter: keep });
+  if (licenseFile()) fs.copyFileSync(licenseFile(), path.join(dest, 'LICENSE.txt'));
+  fs.writeFileSync(path.join(dest, 'version.json'), JSON.stringify({ version, stubApi: STUB_API }, null, 2) + '\n');
+  return { version, dir: dest };
+}
+
+// Zips the *contents* of a folder into `outFile`.
+function zipFolder(dir, outFile) {
+  fs.rmSync(outFile, { force: true });
+  const r = process.platform === 'win32'
+    ? cp.spawnSync('powershell', ['-NoProfile', '-Command', `Compress-Archive -Path "${dir}\\*" -DestinationPath "${outFile}.zip" -Force; Move-Item -Force "${outFile}.zip" "${outFile}"`], { encoding: 'utf8' })
+    : cp.spawnSync('zip', ['-qr', outFile, '.'], { cwd: dir, encoding: 'utf8' });
+  if (r.status !== 0) throw new Error(`could not create ${outFile} (${(r.stderr || r.error || '').toString().trim() || 'zip not available'})`);
+}
+
+function prPackage(outFile) {
+  const ed = C.editionDir('pr');
+  if (!ed) throw new Error('The Premiere Pro edition was not found next to this CLI.');
+  const stage = fs.mkdtempSync(path.join(os.tmpdir(), 'playrig-pr-'));
+  try {
+    fs.cpSync(path.join(ed, 'plugin'), stage, { recursive: true, filter: (f) => !SKIP.test(f) && !/[\\/]dev\.js$/.test(f) && !/icons[\\/]README\.md$/.test(f) });
+    // dev.js is developer-only (see packages/pr/DEV_ONLY.md): leave it and its <script> line out of the package.
+    if (licenseFile()) fs.copyFileSync(licenseFile(), path.join(stage, 'LICENSE.txt'));
+    const html = path.join(stage, 'index.html');
+    fs.writeFileSync(html, fs.readFileSync(html, 'utf8').split('\n').filter((l) => !/src="dev\.js"/.test(l)).join('\n'));
+    fs.mkdirSync(path.dirname(outFile), { recursive: true });
+    zipFolder(stage, outFile);
+  } finally { fs.rmSync(stage, { recursive: true, force: true }); }
+  return { version: readJSON(path.join(ed, 'plugin', 'manifest.json')).version, file: outFile };
+}
+
+module.exports = { STUB_API, aePayload, prPackage, zipFolder, editionVersion, readJSON };