@underpostnet/cyberia 3.2.90 → 3.3.73

package/src/server/storage/repository.js

@@ -0,0 +1,68 @@
+/**
+ * Repository identity: who owns the source this build came from, and the
+ * canonical URLs derived from it.
+ *
+ * Every environment publishes from a different fork, so an owner baked into a
+ * component renders a link to someone else's repository. The owner is resolved
+ * once here, travels to the client in `renderPayload.repository`, and is the
+ * only thing any GitHub, Pages or Coveralls URL is composed from.
+ *
+ * @module src/server/storage/repository.js
+ * @namespace ServerRepository
+ */
+
+import { environmentValueFactory } from '../runtime/environment.js';
+
+/**
+ * @constant REPOSITORY_DEFAULTS
+ * @description Fallbacks for a tree published without repository environment.
+ * The only place in the codebase allowed to name an owner or a repository.
+ * @memberof ServerRepository
+ */
+const REPOSITORY_DEFAULTS = {
+  owner: 'underpostnet',
+  name: 'engine',
+  template: 'pwa-microservices-template',
+  // Prebuilt package repositories are the template repository plus this suffix.
+  packageSuffix: '-ghpkg',
+};
+
+/**
+ * @method repositoryIdentityFactory
+ * @description Resolves the repository identity this build publishes under.
+ * @param {object} [overrides] - Explicit values that win over the environment.
+ * @returns {{owner: string, name: string, template: string, packageSuffix: string}} Identity.
+ * @memberof ServerRepository
+ */
+const repositoryIdentityFactory = (overrides = {}) => ({
+  ...REPOSITORY_DEFAULTS,
+  ...(environmentValueFactory('GITHUB_USERNAME') ? { owner: environmentValueFactory('GITHUB_USERNAME') } : {}),
+  ...Object.fromEntries(Object.entries(overrides).filter(([, value]) => value)),
+});
+
+/**
+ * @method githubUrlFactory
+ * @description Composes a github.com URL under the resolved owner.
+ * @param {object} [params]
+ * @param {object} [params.identity] - Identity to compose against.
+ * @param {string[]} [params.segments] - Path segments after the owner.
+ * @returns {string} Absolute URL, trailing slash included.
+ * @memberof ServerRepository
+ */
+const githubUrlFactory = ({ identity = repositoryIdentityFactory(), segments = [] } = {}) =>
+  `https://github.com/${[identity.owner, ...segments].filter(Boolean).join('/')}/`;
+
+/**
+ * @method githubCommitUrlFactory
+ * @description Markdown link to one commit, for generated changelogs.
+ * @param {object} params
+ * @param {string} params.shortHash - Abbreviated hash used as the link text.
+ * @param {string} params.hash - Full hash the link resolves to.
+ * @param {object} [params.identity] - Identity to compose against.
+ * @returns {string} Markdown link.
+ * @memberof ServerRepository
+ */
+const githubCommitUrlFactory = ({ shortHash, hash, identity = repositoryIdentityFactory() }) =>
+  `[${shortHash}](https://github.com/${identity.owner}/${identity.name}/commit/${hash})`;
+
+export { REPOSITORY_DEFAULTS, githubCommitUrlFactory, githubUrlFactory, repositoryIdentityFactory };

package/src/server.js

@@ -1,14 +1,11 @@
 'use strict';
 
-// https://nodejs.org/api
-// https://expressjs.com/en/4x/api.html
-
 import dotenv from 'dotenv';
-import { loggerFactory } from './server/logger.js';
+import { loggerFactory } from './server/ops/logger.js';
 import { buildClient } from './client-builder/client-build.js';
-import { buildRuntime } from './server/runtime.js';
-import { ProcessController } from './server/process.js';
-import { Config } from './server/conf.js';
+import { buildRuntime } from './server/runtime/runtime.js';
+import { ProcessController } from './server/runtime/process.js';
+import { Config } from './server/runtime/conf.js';
 
 dotenv.config();
 

package/src/ws/IoInterface.js

@@ -4,7 +4,7 @@
  * @namespace SocketIoInterface
  */
 
-import { loggerFactory } from '../server/logger.js';
+import { loggerFactory } from '../server/ops/logger.js';
 import { Socket } from 'socket.io';
 
 const logger = loggerFactory(import.meta);

package/src/ws/IoServer.js

@@ -6,7 +6,7 @@
 'use strict';
 
 import { Server } from 'socket.io';
-import { loggerFactory } from '../server/logger.js';
+import { loggerFactory } from '../server/ops/logger.js';
 import Underpost from '../index.js';
 
 const logger = loggerFactory(import.meta);

package/src/ws/core/core.ws.connection.js

@@ -3,7 +3,7 @@
  * @module ws/core/core.ws.connection
  */
 
-import { loggerFactory } from '../../server/logger.js';
+import { loggerFactory } from '../../server/ops/logger.js';
 import { CoreWsChatChannel } from './channels/core.ws.chat.js';
 import { CoreWsMailerChannel } from './channels/core.ws.mailer.js';
 import { CoreWsStreamChannel } from './channels/core.ws.stream.js';

package/src/ws/core/core.ws.emit.js

@@ -3,7 +3,7 @@
  * @module ws/core/core.ws.emit
  */
 
-import { loggerFactory } from '../../server/logger.js';
+import { loggerFactory } from '../../server/ops/logger.js';
 
 const logger = loggerFactory(import.meta);
 

package/src/ws/core/core.ws.server.js

@@ -10,7 +10,7 @@ import { CoreWsConnectionHandler } from './core.ws.connection.js';
 import { CoreWsChatChannel } from './channels/core.ws.chat.js';
 import { CoreWsMailerChannel } from './channels/core.ws.mailer.js';
 import { CoreWsStreamChannel } from './channels/core.ws.stream.js';
-import { resolveHostKeyContext } from '../../server/conf.js';
+import { resolveHostKeyContext } from '../../server/runtime/conf.js';
 
 /**
  * @class CoreWsServer

package/src/ws/default/default.ws.connection.js

@@ -3,7 +3,7 @@
  * @module ws/default/default.ws.connection
  */
 
-import { loggerFactory } from '../../server/logger.js';
+import { loggerFactory } from '../../server/ops/logger.js';
 import { DefaultWsMainChannel } from './channels/default.ws.main.js';
 
 const logger = loggerFactory(import.meta);

package/src/ws/default/default.ws.emit.js

@@ -1,4 +1,4 @@
-import { loggerFactory } from '../../server/logger.js';
+import { loggerFactory } from '../../server/ops/logger.js';
 
 const logger = loggerFactory(import.meta);
 

package/src/ws/default/default.ws.server.js

@@ -8,7 +8,7 @@
 import { IoServer } from '../IoServer.js';
 import { DefaultWsConnectionHandler } from './default.ws.connection.js';
 import { DefaultWsMainChannel } from './channels/default.ws.main.js';
-import { resolveHostKeyContext } from '../../server/conf.js';
+import { resolveHostKeyContext } from '../../server/runtime/conf.js';
 
 /**
  * @class DefaultWsServer

package/test/e2e/event-e2e-public-ingress-down.js

@@ -0,0 +1,45 @@
+import Underpost from '../../src/index.js';
+
+/** The ports HAProxy publishes on the hub; blocking these takes every host down. */
+const EDGE_PORTS = '80,443';
+
+/**
+ * End-to-end rehearsal for `public-ingress-down`.
+ *
+ * The outage is induced where the public edge actually terminates — the hub —
+ * by blocking inbound traffic on the published ports. That is the one fault
+ * that takes every host down at once, which is the condition this event
+ * remediates; stopping a workload would produce the partial state the handler
+ * deliberately refuses to act on.
+ *
+ * The block is scoped to those ports rather than to every port, because
+ * remediation reaches the hub over SSH: a total ingress block would drop the
+ * connection that repairs it and leave the edge unrecoverable from anywhere but
+ * the provider console. `--unblock-all-ingress`, which the handler runs, clears
+ * this block along with any other.
+ *
+ * @module test/event-e2e-public-ingress-down.js
+ */
+export default {
+  description: 'Blocks public ingress on each hub, then verifies the edge is restored and every host answers again.',
+
+  async subjects({ options }) {
+    return Underpost.event.subjectSelection('hub', options).map((hubHost) => {
+      const target = Underpost.event.hubTarget(hubHost);
+      return {
+        label: `ingress via ${target.nodeName || hubHost}`,
+        probes: Underpost.event.publicIngressUrls().map((entry) => ({ module: 'http_2xx', target: entry.url })),
+        dispatchOptions: { nodes: target.nodeName || hubHost },
+        remote: { user: target.user, host: target.host },
+      };
+    });
+  },
+
+  async break(context, subject) {
+    return await Underpost.event.runCommand(`node bin ip --block-ingress-port ${EDGE_PORTS}`, subject.remote);
+  },
+
+  async restore(context, subject) {
+    return await Underpost.event.runCommand(`node bin ip --unblock-ingress-port ${EDGE_PORTS}`, subject.remote);
+  },
+};

package/test/e2e/event-e2e-wireguard-server-down.js

@@ -0,0 +1,38 @@
+import Underpost from '../../src/index.js';
+
+/**
+ * End-to-end rehearsal for `wireguard-server-down`.
+ *
+ * Every registered hub is rehearsed, or those `--nodes` selects. A hub is
+ * taken down the only way an operator can reach it while its tunnel is dead —
+ * through the external SSH endpoint registered for it — which is also the path
+ * the remediation must use. Stopping the interface any other way would not
+ * exercise that dependency.
+ *
+ * @module test/event-e2e-wireguard-server-down.js
+ */
+export default {
+  description: 'Stops WireGuard on each hub over its registered management SSH, then verifies the repair.',
+
+  async subjects({ options }) {
+    return Underpost.event.subjectSelection('hub', options).map((hubHost) => {
+      const target = Underpost.event.hubTarget(hubHost);
+      if (!target.address)
+        throw new Error(`[event] the tunnel address of hub ${hubHost} is underivable; nothing can be probed`);
+      return {
+        label: `hub ${target.nodeName || hubHost}`,
+        probes: [{ module: 'icmp', target: target.address }],
+        dispatchOptions: { nodes: target.nodeName || hubHost },
+        remote: { user: target.user, host: target.host },
+      };
+    });
+  },
+
+  async break(context, subject) {
+    return await Underpost.event.runCommand('node bin wireguard --wireguard-stop', subject.remote);
+  },
+
+  async restore(context, subject) {
+    return await Underpost.event.runCommand('node bin wireguard --wireguard-start', subject.remote);
+  },
+};

package/test/e2e/event-e2e-wireguard-spoke-down.js

@@ -0,0 +1,40 @@
+import Underpost from '../../src/index.js';
+
+/**
+ * End-to-end rehearsal for `wireguard-spoke-down`.
+ *
+ * Every peer of this node's hub is rehearsed, or those `--nodes` /
+ * `--spoke` selects, one at a time. Each is taken down through the same
+ * identity chain the remediation resolves — locally for the selected control
+ * node, over LAN SSH for a worker — so a spoke that can be broken but not
+ * repaired fails the rehearsal rather than an outage.
+ *
+ * @module test/event-e2e-wireguard-spoke-down.js
+ */
+export default {
+  description: 'Stops WireGuard on each registered spoke, then verifies the repair of that spoke alone.',
+
+  async subjects({ options }) {
+    const hubAddress = Underpost.event.hubAddress();
+    return Underpost.event.subjectSelection('spoke', options).map((spokeId) => {
+      const spoke = Underpost.event.spokes().find((entry) => entry.id === spokeId);
+      const target = Underpost.event.spokeTarget(spokeId);
+      return {
+        label: `spoke ${spokeId}`,
+        // The local spoke is proved through the hub tunnel: its own 10.0.0.x stays
+        // reachable on the machine itself even when the tunnel carries nothing.
+        probes: [{ module: 'icmp', target: spoke.local ? hubAddress : spoke.address }],
+        dispatchOptions: { spoke: spokeId },
+        remote: { user: target.user, host: target.host },
+      };
+    });
+  },
+
+  async break(context, subject) {
+    return await Underpost.event.runCommand('node bin wireguard --wireguard-stop', subject.remote);
+  },
+
+  async restore(context, subject) {
+    return await Underpost.event.runCommand('node bin wireguard --wireguard-start', subject.remote);
+  },
+};

package/test/{api.test.js → integration/app/api.test.js}

@@ -1,29 +1,48 @@
 'use strict';
 
 import axios from 'axios';
-import dotenv from 'dotenv';
+import express from 'express';
 
 import { expect } from 'chai';
-import { loggerFactory } from '../src/server/logger.js';
-
-dotenv.config();
-
-const PORT = parseInt(process.env.PORT) + 1;
+import { TestRouter } from '../../../src/api/test/test.router.js';
+import { loggerFactory } from '../../../src/server/ops/logger.js';
 
 const logger = loggerFactory(import.meta);
 
 await logger.setUpInfo();
 
-const BASE_URL =
-  process.env.NODE_ENV === 'development'
-    ? `http://localhost:${PORT}/${process.env.BASE_API}`
-    : `https://www.nexodev.org/api`;
-
 describe(`GET 'Test' API Request `, async () => {
+  const app = express();
+  app.use('/api/test', TestRouter.router({ authMiddleware: (_req, _res, next) => next() }));
+
+  let server;
+  let baseUrl;
+
+  beforeAll(
+    () =>
+      new Promise((resolve, reject) => {
+        server = app.listen(0, '127.0.0.1', () => {
+          baseUrl = `http://127.0.0.1:${server.address().port}/api`;
+          resolve();
+        });
+        server.on('error', reject);
+      }),
+  );
+
+  afterAll(
+    () =>
+      new Promise((resolve, reject) =>
+        server.close((error) => {
+          if (error) reject(error);
+          else resolve();
+        }),
+      ),
+  );
+
   {
     const youtubeId = '2aib-pmgUdQ';
-    const url = `${BASE_URL}/test/youtube-id/?url=https://www.youtube.com/watch?v=${youtubeId}`;
     it(`youtube id from raw youtube url`, async () => {
+      const url = `${baseUrl}/test/youtube-id/?url=https://www.youtube.com/watch?v=${youtubeId}`;
       logger.info('request info', { url });
       const res = await axios.get(url);
       logger.info('response', res.data);
@@ -32,8 +51,8 @@ describe(`GET 'Test' API Request `, async () => {
   }
   {
     const email = 'test@gmail.com';
-    const url = `${BASE_URL}/test/verify-email/?email=${email}`;
     it(`valid format email`, async () => {
+      const url = `${baseUrl}/test/verify-email/?email=${email}`;
       logger.info('request info', { url });
       const res = await axios.get(url);
       logger.info('response', res.data);
@@ -42,8 +61,8 @@ describe(`GET 'Test' API Request `, async () => {
   }
   {
     const password = 'Password123!';
-    const url = `${BASE_URL}/test/is-strong-password/?password=${password}`;
     it(`valid password`, async () => {
+      const url = `${baseUrl}/test/is-strong-password/?password=${password}`;
       logger.info('request info', { url });
       const res = await axios.get(url);
       logger.info('response', res.data);

package/test/integration/app/cyberia/cyberia-cli-plain-reads.test.js

@@ -0,0 +1,30 @@
+'use strict';
+
+import { expect } from 'chai';
+import { execFileSync } from 'node:child_process';
+import fs from 'fs-extra';
+
+// The reroute notice is diagnostic output, so it must not reach stdout: a caller reading a value
+// out of `--plain` would otherwise parse the banner as the value. Spawning the real CLI is the
+// only way to observe the two streams apart, and it belongs to this tier because the cyberia CLI
+// boots on the native packages the product manifest pins — repositories that only run
+// `unit,infra,app` never install them.
+describe('rerouted plain reads stay machine-readable', () => {
+  const CYBERIA_CLI = 'bin/cyberia.js';
+  const repoRoot = new URL('../../../../', import.meta.url);
+
+  it.skipIf(!fs.existsSync(new URL(CYBERIA_CLI, repoRoot)))(
+    'prints nothing for a key the store lacks',
+    () => {
+      const stdout = execFileSync(
+        process.execPath,
+        [CYBERIA_CLI, 'host', 'get', '--plain', 'UNDERPOST_TEST_MISSING_KEY'],
+        { cwd: repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
+      );
+      expect(stdout.trim()).to.equal('');
+      // A cold CLI start imports the whole command surface; the budget is for the import, not the
+      // read, and is stated here rather than left to the runner default a loaded machine exceeds.
+    },
+    60000,
+  );
+});

package/test/{cyberia-instance-conf-defaults.test.js → integration/app/cyberia/cyberia-instance-conf-defaults.test.js}

@@ -4,7 +4,7 @@ import { expect } from 'chai';
 import {
   fillInstanceConfDefaults,
   CYBERIA_INSTANCE_CONF_DEFAULTS,
-} from '../src/api/cyberia-server-defaults/cyberia-server-defaults.js';
+} from '../../../../src/api/cyberia-server-defaults/cyberia-server-defaults.js';
 
 // The CyberiaInstanceConfSchema fields that must always be present after a
 // backfill. Mirrors cyberia-instance-conf.model.js (minus instanceCode, which
@@ -22,6 +22,7 @@ const SCHEMA_FIELDS = [
   'botAggroRange',
   'defaultPlayerWidth',
   'defaultPlayerHeight',
+  'playerBaseSpeed',
   'playerBaseLifeRegenMin',
   'playerBaseLifeRegenMax',
   'sumStatsLimit',