@underpostnet/cyberia 3.3.73 → 3.3.76

package/test/unit/package.test.js

@@ -14,6 +14,7 @@ import {
   deployPackagePathFactory,
   productDevDependenciesFactory,
   productPackageOptionsFactory,
+  publishedProductPackageJson,
   stagePackageArchive,
   syncDeployPackages,
 } from '../../src/server/build/package.js';
@@ -38,7 +39,7 @@ describe('generated product package dependencies', () => {
         },
         productDependencies: {
           'runtime-shared': '3.0.0',
-          underpost: '^3.3.0',
+          nodemailer: '^10.0.0',
         },
         productDevDependencies: {
           'product-dev-only': '4.0.0',
@@ -72,7 +73,7 @@ describe('generated product package dependencies', () => {
       },
       catalog: { description: 'Cyberia CLI', keywords: ['cyberia'] },
       confName: 'dd-cyberia',
-      customDependencies: { underpost: '^3.3.0' },
+      customDependencies: { nodemailer: '^10.0.0' },
       customScripts: { build: 'node bin client' },
       customBin: { cyberia: 'bin/index.js' },
     });
@@ -82,7 +83,7 @@ describe('generated product package dependencies', () => {
       description: 'Cyberia CLI',
       keywords: ['cyberia'],
       bin: { cyberia: 'bin/index.js' },
-      dependencies: { underpost: '^3.3.0' },
+      dependencies: { nodemailer: '^10.0.0' },
       devDependencies: { express: '5.2.1', vitest: '4.1.11' },
       scripts: { test: 'node bin test', build: 'node bin client' },
     });
@@ -265,25 +266,78 @@ describe('generated deploy package manifests', () => {
 });
 
 describe('product manifest overrides read the catalog', () => {
-  it('carries the published engine CLI alongside the catalog pins', () => {
-    expect(
-      productPackageOptionsFactory({
-        catalog: {
-          packageDependencies: { ethers: '~6.16.0' },
-          packageBin: { cyberia: 'bin/index.js' },
-          packageScripts: { 'docker:up': 'node bin docker-compose --up' },
-        },
-        underpostVersion: 'v3.3.0',
-      }),
-    ).to.deep.equal({
-      customDependencies: { underpost: '^3.3.0', ethers: '~6.16.0' },
+  it('carries the engine runtime dependencies alongside the catalog pins', () => {
+    // Regression: the product depended on the published `underpost` package instead, which
+    // installed a second engine whose nested `nodemailer` `src/` could not resolve, while the
+    // hoistable copy survived only as a dev entry a production install omits.
+    const options = productPackageOptionsFactory({
+      catalog: {
+        packageDependencies: { ethers: '~6.16.0' },
+        packageBin: { cyberia: 'bin/index.js' },
+        packageScripts: { 'docker:up': 'node bin docker-compose --up' },
+      },
+      engineDependencies: { express: '^5.2.1', nodemailer: '^10.0.0' },
+    });
+
+    expect(options).to.deep.equal({
+      customDependencies: { express: '^5.2.1', nodemailer: '^10.0.0', ethers: '~6.16.0' },
       customScripts: { 'docker:up': 'node bin docker-compose --up' },
       customBin: { cyberia: 'bin/index.js' },
     });
+    expect(options.customDependencies).to.not.have.property('underpost');
+  });
+
+  it('lets a catalog pin override the engine version of the same dependency', () => {
+    expect(
+      productPackageOptionsFactory({
+        catalog: { packageDependencies: { sharp: '^0.35.3' } },
+        engineDependencies: { sharp: '^0.34.0' },
+      }).customDependencies,
+    ).to.deep.equal({ sharp: '^0.35.3' });
   });
 
   it('leaves the base template manifest alone for a catalog that declares no package', () => {
-    expect(productPackageOptionsFactory({ catalog: {}, underpostVersion: 'v3.3.0' })).to.deep.equal({});
+    expect(productPackageOptionsFactory({ catalog: {}, engineDependencies: { express: '^5.2.1' } })).to.deep.equal({});
+  });
+});
+
+describe('the manifest a product publishes to npm', () => {
+  it('trades the engine runtime set for the published CLI and the catalog pins', () => {
+    const published = publishedProductPackageJson({
+      packageJson: {
+        name: 'cyberia',
+        version: '3.3.73',
+        dependencies: { express: '^5.2.1', nodemailer: '^10.0.0', sharp: '^0.35.3' },
+        devDependencies: { vitest: '5.0.0' },
+      },
+      catalog: { packageDependencies: { sharp: '^0.35.3', ethers: '~6.16.0' } },
+    });
+
+    expect(published.dependencies).to.deep.equal({ underpost: '^3.3.73', sharp: '^0.35.3', ethers: '~6.16.0' });
+    expect(published.devDependencies).to.deep.equal({
+      express: '^5.2.1',
+      nodemailer: '^10.0.0',
+      vitest: '5.0.0',
+    });
+    expect(published.name).to.equal('cyberia');
+  });
+
+  it('pins the engine CLI at the version it is given, tag stripped', () => {
+    expect(
+      publishedProductPackageJson({ packageJson: { version: '3.3.73' }, underpostVersion: 'v4.0.0' }).dependencies,
+    ).to.deep.equal({ underpost: '^4.0.0' });
+  });
+
+  it('refuses a manifest it cannot pin the engine CLI from', () => {
+    expect(() => publishedProductPackageJson()).to.throw('packageJson');
+    expect(() => publishedProductPackageJson({ packageJson: { name: 'cyberia' } })).to.throw('version');
+  });
+
+  it('leaves the repository manifest as the checkout installs from', () => {
+    const packageJson = { version: '1.0.0', dependencies: { express: '^5.2.1' } };
+    publishedProductPackageJson({ packageJson });
+
+    expect(packageJson).to.deep.equal({ version: '1.0.0', dependencies: { express: '^5.2.1' } });
   });
 });
 

package/test/unit/prepare-host.test.js

@@ -81,7 +81,12 @@ describe('a node installs the deploy own package manifest', () => {
     try {
       const emitted = run(`install_deploy_dependencies ${root} dd-absent`).trim().split('\n');
       expect(emitted[0]).to.equal(`Install dependencies :: sudo -n -- /bin/bash -lc cd ${root} && npm install`);
-      expect(emitted[1]).to.include(`Link underpost CLI :: sudo -n -- /bin/bash -lc cd ${root} && npm link --force`);
+      // The link is a symlink onto the checkout's entrypoint, and a restored checkout can leave
+      // that file without its executable mode, so the link step restores it before linking.
+      expect(emitted[1]).to.include(
+        `Link underpost CLI :: sudo -n -- /bin/bash -lc cd ${root} && chmod +x ./bin/index.js && npm link --force`,
+      );
+      expect(emitted[1]).to.include('test -x ./bin/index.js');
     } finally {
       fs.removeSync(root);
     }
@@ -297,3 +302,81 @@ describe('prepare_host brings a node up in an order it can recover from', () =>
     expect(emitted.at(-1)).to.include('node bin host load');
   });
 });
+
+const cyberiaDeployScript = path.join(deployRoot, 'dd-cyberia/sync-deploy.sh');
+
+describe.skipIf(!fs.existsSync(cyberiaDeployScript))('a pod lands its private configuration at engine-private', () => {
+  const source = fs.existsSync(cyberiaDeployScript) ? fs.readFileSync(cyberiaDeployScript, 'utf8') : '';
+
+  it('names the pod conf repository once and derives the directory the clone lands in', () => {
+    expect(source).to.match(/^POD_SRC_PRIVATE_REPO="\$\{POD_SRC_PRIVATE_REPO:-[^"]+\}"$/m);
+    expect(source).to.include('underpost clone ${POD_SRC_PRIVATE_REPO}');
+    expect(source).to.include('POD_SRC_PRIVATE_DIR="${POD_SRC_PRIVATE_REPO##*/}"');
+    expect(source).to.include('sudo mv ./${POD_SRC_PRIVATE_DIR} ./engine-private');
+  });
+
+  it('clears the destination first, so the checkout replaces engine-private instead of nesting in it', () => {
+    const cleared = source.indexOf('sudo rm -rf ./engine-private');
+    const moved = source.indexOf('sudo mv ./${POD_SRC_PRIVATE_DIR} ./engine-private');
+    expect(cleared).to.be.greaterThan(-1);
+    expect(cleared).to.be.lessThan(moved);
+  });
+});
+
+// Every script under deploy/ is the same shape on purpose: one entry point, one constants block,
+// and no value repeated across files. A second shape is how the drift starts, so it is asserted
+// here rather than left to review.
+describe.skipIf(!shipsDeployIds)('every deploy script is written to one shape', () => {
+  const libDirectory = path.join(deployRoot, 'lib');
+  const scripts = fs
+    .readdirSync(deployRoot)
+    .filter((entry) => fs.statSync(path.join(deployRoot, entry)).isDirectory() && entry !== 'lib')
+    .flatMap((directory) =>
+      fs
+        .readdirSync(path.join(deployRoot, directory))
+        .filter((file) => file.endsWith('.sh'))
+        .map((file) => ({
+          id: `${directory}/${file}`,
+          source: fs.readFileSync(path.join(deployRoot, directory, file), 'utf8'),
+        })),
+    );
+  const libraries = fs
+    .readdirSync(libDirectory)
+    .filter((file) => file.endsWith('.sh'))
+    .map((file) => ({ id: `lib/${file}`, source: fs.readFileSync(path.join(libDirectory, file), 'utf8') }));
+
+  it('opens and closes every entry point the same way', () => {
+    expect(scripts).to.not.be.empty;
+    for (const { id, source } of scripts) {
+      expect(source.startsWith('#!/bin/bash\nset -euo pipefail\n'), id).to.equal(true);
+      expect(source, id).to.include('source "$SCRIPT_DIR/../lib/github-actions-logging.sh"');
+      expect(source.trimEnd().endsWith('main "$@"'), id).to.equal(true);
+    }
+  });
+
+  it('leaves the shared values to lib/config.sh, so no script carries a copy', () => {
+    // The engine root, the ingress node, the fleet's node names, the ssh key and the WordPress
+    // image were each pasted into a dozen scripts before this.
+    for (const { id, source } of scripts) {
+      expect(source, id).to.not.match(/^ENGINE_ROOT=/m);
+      expect(source, id).to.not.match(/^INGRESS_NODE=/m);
+      expect(source, id).to.not.include('/home/dd/engine');
+      expect(source, id).to.not.include('hp-envy');
+      expect(source, id).to.not.include('underpost/wp:');
+    }
+  });
+
+  it('states its deploy id once and reads it back from there', () => {
+    // A fleet-level script names no deploy of its own; one that names a deploy declares it.
+    for (const { id, source } of scripts.filter(({ source: text }) => /dd-[a-z0-9]/.test(text))) {
+      expect(source, id).to.match(/^DEPLOY_ID=dd-[a-z0-9-]+$/m);
+      const belowDeclaration = source.slice(source.indexOf('\n', source.search(/^DEPLOY_ID=/m)));
+      expect(belowDeclaration, id).to.not.match(/dd-[a-z0-9]/);
+    }
+  });
+
+  it('carries no library shebang and no trailing whitespace anywhere', () => {
+    for (const { id, source } of libraries) expect(source.startsWith('#!'), id).to.equal(false);
+    for (const { id, source } of [...scripts, ...libraries]) expect(source, id).to.not.match(/[ \t]+$/m);
+  });
+});

package/test/unit/test-tiers.test.js

@@ -6,10 +6,12 @@ import {
   TEST_TIERS,
   UNDERPOST_TESTING,
   coverageIncludeFactory,
+  coverageReportKey,
   coverageThresholdFactory,
   resolveTestSelection,
   testProjectsFactory,
   testSuiteNames,
+  vitestProjectSelector,
 } from '../../src/server/build/testing.js';
 
 // The table declares every tier the platform ships. A product build slices the
@@ -191,3 +193,28 @@ describe('coverage scope', () => {
     expect(() => coverageIncludeFactory(['--project', 'not-a-tier'])).to.throw(/unknown suite/);
   });
 });
+
+describe('coverage report directory', () => {
+  it('names the report after the suites the selection spans', () => {
+    expect(coverageReportKey('unit,infra,app')).to.equal('unit-infra-app');
+    expect(coverageReportKey('cyberia')).to.equal('cyberia');
+    expect(coverageReportKey('infra:1-security,infra:2-network')).to.equal('infra');
+  });
+
+  it('names every Vitest suite for a full run and none for a delegated one', () => {
+    expect(coverageReportKey('')).to.equal(coverageReportKey('all'));
+    expect(coverageReportKey('all').split('-')).to.have.members([
+      ...new Set(TEST_TIERS.filter(({ delegate }) => !delegate).map(({ name }) => name.split(':')[0])),
+    ]);
+    expect(coverageReportKey('contracts')).to.equal('');
+  });
+
+  // A deploy names its report by suite and the runner is handed the same tiers as
+  // `--project` flags; both must land on one directory.
+  it('agrees between a suite selector and the projects the runner was handed', () => {
+    const { projects } = resolveTestSelection('unit,infra,app');
+    const argv = ['npx', 'vitest', 'run', ...projects.flatMap((project) => ['--project', project]), '--coverage'];
+    expect(coverageReportKey(vitestProjectSelector(argv))).to.equal(coverageReportKey('unit,infra,app'));
+    expect(vitestProjectSelector(['--project=cyberia'])).to.equal('cyberia');
+  });
+});

package/test/unit/zip-archive.test.js

@@ -0,0 +1,142 @@
+'use strict';
+
+/**
+ * @module zip-archive.test
+ * @description Covers the JSZip-backed archive helpers shared by the file-storage CLI and the
+ * client builder: local-file archiving, full and single-entry extraction, entry lookup by
+ * basename, and the guard that keeps an archive path from escaping the extraction root.
+ *
+ * Uses 'chai' for assertions.
+ */
+
+import { expect } from 'chai';
+import fs from 'fs-extra';
+import JSZip from 'jszip';
+import * as dir from 'path';
+import {
+  extractZipEntryTo,
+  extractZipTo,
+  findZipEntry,
+  isZipBuffer,
+  loadZip,
+  readZipEntry,
+  zipFromLocalFiles,
+} from '../../src/server/storage/zip.js';
+
+describe('zip archive helpers', () => {
+  let fixturePath;
+
+  beforeEach(() => {
+    fixturePath = fs.mkdtempSync('/tmp/engine-zip-archive-');
+    fs.mkdirSync(`${fixturePath}/src/nested`, { recursive: true });
+    fs.writeFileSync(`${fixturePath}/src/index.html`, '<h1>index</h1>'.repeat(200), 'utf8');
+    fs.writeFileSync(`${fixturePath}/src/nested/app.js`, 'console.log(1);'.repeat(200), 'utf8');
+    fs.writeFileSync(`${fixturePath}/src/run.sh`, '#!/bin/sh\necho run\n', 'utf8');
+    fs.chmodSync(`${fixturePath}/src/run.sh`, 0o755);
+  });
+
+  afterEach(() => {
+    fs.removeSync(fixturePath);
+  });
+
+  const buildFixtureArchive = () =>
+    zipFromLocalFiles([
+      { localPath: `${fixturePath}/src/index.html`, entryName: 'index.html' },
+      { localPath: `${fixturePath}/src/nested/app.js`, entryName: 'nested/app.js' },
+      { localPath: `${fixturePath}/src/run.sh`, entryName: 'run.sh' },
+    ]);
+
+  it('writes a deflated archive that keeps the requested entry names', async () => {
+    const archive = await buildFixtureArchive();
+    const rawBytes = ['src/index.html', 'src/nested/app.js', 'src/run.sh'].reduce(
+      (total, relativePath) => total + fs.statSync(`${fixturePath}/${relativePath}`).size,
+      0,
+    );
+
+    expect(isZipBuffer(archive)).to.equal(true);
+    expect(archive.length).to.be.below(rawBytes);
+    const entries = Object.values((await loadZip(archive)).files);
+    expect(entries.filter((entry) => entry.dir).map((entry) => entry.name)).to.deep.equal(['nested/']);
+    expect(
+      entries
+        .filter((entry) => !entry.dir)
+        .map((entry) => entry.name)
+        .sort(),
+    ).to.deep.equal(['index.html', 'nested/app.js', 'run.sh']);
+  });
+
+  it('round-trips an archive through extraction, preserving content and executable bits', async () => {
+    const outputPath = `${fixturePath}/out`;
+    await extractZipTo(await buildFixtureArchive(), outputPath);
+
+    expect(fs.readFileSync(`${outputPath}/nested/app.js`, 'utf8')).to.equal(
+      fs.readFileSync(`${fixturePath}/src/nested/app.js`, 'utf8'),
+    );
+    expect(fs.statSync(`${outputPath}/run.sh`).mode & 0o777).to.equal(0o755);
+  });
+
+  it('extracts from an archive path as well as from a buffer', async () => {
+    const archivePath = `${fixturePath}/build.zip`;
+    fs.writeFileSync(archivePath, await buildFixtureArchive());
+    await extractZipTo(archivePath, `${fixturePath}/from-path`);
+
+    expect(fs.existsSync(`${fixturePath}/from-path/nested/app.js`)).to.equal(true);
+  });
+
+  it('resolves an entry by exact name, by basename, and by single-entry fallback', async () => {
+    const nested = await loadZip(await buildFixtureArchive());
+    expect(findZipEntry(nested, 'nested/app.js').name).to.equal('nested/app.js');
+    expect(findZipEntry(nested, 'app.js').name).to.equal('nested/app.js');
+    expect(findZipEntry(nested, 'absent.js')).to.equal(null);
+
+    const single = await loadZip(
+      await zipFromLocalFiles([{ localPath: `${fixturePath}/src/index.html`, entryName: 'deep/path/index.html' }]),
+    );
+    expect(findZipEntry(single, 'absent.js').name).to.equal('deep/path/index.html');
+  });
+
+  it('reads a wrapped entry out of a single-file archive', async () => {
+    const inner = await buildFixtureArchive();
+    fs.writeFileSync(`${fixturePath}/inner.zip`, inner);
+    const wrapper = await zipFromLocalFiles([
+      { localPath: `${fixturePath}/inner.zip`, entryName: 'wrapped/inner.zip' },
+    ]);
+
+    expect(await readZipEntry(wrapper, 'inner.zip')).to.deep.equal(inner);
+  });
+
+  it('flattens a single extracted entry into the target directory', async () => {
+    const archive = await zipFromLocalFiles([
+      { localPath: `${fixturePath}/src/index.html`, entryName: 'deep/path/index.html' },
+    ]);
+    const targetDir = `${fixturePath}/pull`;
+    const written = await extractZipEntryTo(archive, 'index.html', targetDir);
+
+    expect(written).to.equal(dir.resolve(targetDir, 'index.html'));
+    expect(fs.readFileSync(written, 'utf8')).to.equal(fs.readFileSync(`${fixturePath}/src/index.html`, 'utf8'));
+  });
+
+  it('rejects a missing entry rather than writing an empty file', async () => {
+    const archive = await buildFixtureArchive();
+    let thrown;
+    await extractZipEntryTo(archive, 'index.html', `${fixturePath}/missing`).catch((error) => (thrown = error));
+    expect(thrown).to.equal(undefined);
+
+    await extractZipEntryTo(await buildFixtureArchive(), 'absent.js', `${fixturePath}/missing`).catch(
+      (error) => (thrown = error),
+    );
+    expect(thrown?.message).to.match(/Zip entry not found/);
+  });
+
+  it('blocks an archive entry that resolves outside the extraction root', async () => {
+    const escaping = new JSZip();
+    escaping.file('../escaped.txt', 'escaped');
+    const archive = await escaping.generateAsync({ type: 'nodebuffer' });
+
+    let thrown;
+    await extractZipTo(archive, `${fixturePath}/guarded`).catch((error) => (thrown = error));
+
+    expect(thrown?.message).to.match(/Blocked zip entry outside extraction directory/);
+    expect(fs.existsSync(`${fixturePath}/escaped.txt`)).to.equal(false);
+  });
+});

package/vitest.config.js

@@ -2,13 +2,16 @@ import { defineConfig } from 'vitest/config';
 import {
   UNDERPOST_TESTING,
   coverageIncludeFactory,
+  coverageReportKey,
   coverageThresholdFactory,
   testProjectsFactory,
+  vitestProjectSelector,
 } from './src/server/build/testing.js';
 
 const allureResultsDirectory = process.env[UNDERPOST_TESTING.allureResultsEnvKey];
 const coverageThreshold = coverageThresholdFactory(process.env);
 const coverageInclude = coverageIncludeFactory(process.argv);
+const coverageReportDirectory = coverageReportKey(vitestProjectSelector(process.argv));
 
 // Spread into every tier: a Vitest project inherits nothing from the root
 // `test` block, and only `coverage` and `reporters` are read from it.
@@ -33,9 +36,14 @@ export default defineConfig({
     coverage: {
       provider: 'v8',
       reportsDirectory: UNDERPOST_TESTING.coverageDirectory,
-      // `lcov` is what Coveralls ingests, `json` is what a merged multi-job
-      // report is assembled from, `text` is what a local run reads.
-      reporter: ['text', 'lcov', 'json'],
+      // `lcovonly` is what Coveralls ingests, `json` is what a merged multi-job
+      // report is assembled from, `text` is what a local run reads, and `html` is
+      // what a deploy publishes — under the selection's own directory, so the
+      // report a deploy declares is the run it names and never the last run made.
+      reporter: ['text', 'lcovonly', 'json', ['html', { subdir: coverageReportDirectory }]],
+      // The directory holds one report per selection, so a run must not empty it; the
+      // runner (`src/cli/test.js`) clears its own selection's report before it starts.
+      clean: false,
       // Written even when the run fails: the coverage workflows upload the report
       // from a job the threshold step is meant to fail, and without it the badge
       // freezes at the last passing build instead of moving with the tree.

package/src/api/cyberia-instance/cyberia-fallback-default-items.js

@@ -1,63 +0,0 @@
-/**
- * Fallback-world default items — process-local override store.
- *
- * The procedural fallback world is never persisted, so its default item set
- * has no collection to live in. This module holds the set the FallbackWorldEngine
- * view composed, in memory, for the lifetime of the engine process:
- *
- *   - written by  POST /api/cyberia-instance/fallback-world/hot-reload
- *   - read by     fetchFullInstance()'s fallback branch (instance-data.js) and
- *                 GET /api/cyberia-instance/fallback-world[/default-items]
- *
- * Deliberately NOT persisted: an engine restart drops back to the code defaults,
- * so a stale editor session can never become the permanent shape of the world.
- * This keeps the fallback path's "code defaults are authoritative" invariant —
- * the only thing an operator can layer on top is this explicit, volatile list.
- *
- * @module src/api/cyberia-instance/cyberia-fallback-default-items.js
- */
-
-/** @typedef {{ id: string, defaultPlayerInventory: boolean }} FallbackDefaultItem */
-
-/** @type {FallbackDefaultItem[]} */
-let defaultItems = [];
-
-/**
- * Coerce a caller-supplied list into the canonical `{ id, defaultPlayerInventory }`
- * shape. Accepts the legacy `string[]` form and drops blank/duplicate ids so the
- * world generator never sees a malformed entry.
- *
- * @param {Array<string|FallbackDefaultItem>} entries
- * @returns {FallbackDefaultItem[]}
- */
-function normalizeFallbackDefaultItems(entries) {
-  if (!Array.isArray(entries)) return [];
-  const seen = new Set();
-  const normalized = [];
-  for (const entry of entries) {
-    const raw = typeof entry === 'string' ? { id: entry } : entry;
-    const id = typeof raw?.id === 'string' ? raw.id.trim() : '';
-    if (!id || seen.has(id)) continue;
-    seen.add(id);
-    normalized.push({ id, defaultPlayerInventory: !!raw.defaultPlayerInventory });
-  }
-  return normalized;
-}
-
-/**
- * Current override set. Returns a copy so callers cannot mutate the store.
- * @returns {FallbackDefaultItem[]}
- */
-const getFallbackDefaultItems = () => defaultItems.map((entry) => ({ ...entry }));
-
-/**
- * Replace the override set. An empty list clears it, restoring pure code defaults.
- * @param {Array<string|FallbackDefaultItem>} entries
- * @returns {FallbackDefaultItem[]} The stored set.
- */
-function setFallbackDefaultItems(entries) {
-  defaultItems = normalizeFallbackDefaultItems(entries);
-  return getFallbackDefaultItems();
-}
-
-export { getFallbackDefaultItems, setFallbackDefaultItems, normalizeFallbackDefaultItems };