enigma-memory 0.1.18 → 0.1.22

package/apps/relay/bin/enigma-relay.mjs

@@ -1,7 +1,15 @@
 #!/usr/bin/env node
-import { realpathSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
+import { once } from 'node:events';
+import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { DEFAULT_RELAY_PORT, main as cliMain } from '../../cli/bin/enigma.mjs';
+import {
+  createRelayServer,
+  createRelayState,
+  loadRelayStateFromFile,
+  saveRelayStateToFile,
+} from '../src/server.mjs';
 
 function relayUsage() {
   return {
@@ -21,21 +29,111 @@ function relayUsage() {
 function print(value, io) {
   io.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
+function publicStartError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? '');
+  if (/state schema mismatch/i.test(message)) return 'relay state schema mismatch';
+  if (/requires (?:a |an )?[A-Za-z0-9 _/-]+(?:adapter|ref|value)/i.test(message) && !/[\\:]|Bearer|token|secret/i.test(message)) {
+    return message.slice(0, 240);
+  }
+  return 'relay failed to start; inspect local operator logs';
+}
+
 
 function isHelp(argv) {
   return argv.includes('--help') || argv.includes('-h');
 }
 
-function relayArgv(argv) {
-  return argv[0] === 'demo' || argv[0] === 'serve' ? ['relay', ...argv] : ['relay', 'serve', ...argv];
+function parseServeArgs(argv) {
+  const args = argv[0] === 'serve' ? argv.slice(1) : argv;
+  const parsed = { host: '127.0.0.1', port: DEFAULT_RELAY_PORT, once: false, stateFile: null };
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === '--once') {
+      parsed.once = true;
+    } else if (argument === '--host' || argument === '--port' || argument === '--state-file') {
+      const value = args[++index];
+      if (!value) throw new TypeError(`${argument} requires a value`);
+      if (argument === '--host') parsed.host = value;
+      if (argument === '--state-file') parsed.stateFile = value;
+      if (argument === '--port') {
+        parsed.port = Number(value);
+        if (!Number.isSafeInteger(parsed.port) || parsed.port < 0 || parsed.port > 65535) {
+          throw new TypeError('--port must be an integer between 0 and 65535');
+        }
+      }
+    } else {
+      throw new TypeError(`unknown relay serve option: ${argument}`);
+    }
+  }
+  return parsed;
+}
+
+async function loadServeModuleOptions(env) {
+  const moduleRef = env.ENIGMA_RELAY_SERVE_MODULE ?? env.ENIGMA_FEDERATION_SERVE_MODULE;
+  if (!moduleRef) return {};
+  const moduleUrl = /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(moduleRef)
+    ? moduleRef
+    : pathToFileURL(resolve(moduleRef)).href;
+  const loaded = await import(moduleUrl);
+  const factory = loaded.createRelayServeOptions ?? loaded.createServeOptions ?? loaded.default;
+  if (typeof factory !== 'function') {
+    throw new TypeError('relay serve module must export createRelayServeOptions(), createServeOptions(), or a default factory');
+  }
+  const options = await factory({ service: 'relay', env: { ...env } });
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new TypeError('relay serve module factory must return an options object');
+  }
+  return options;
+}
+
+async function runServe(argv, io, env) {
+  const flags = parseServeArgs(argv);
+  const moduleOptions = await loadServeModuleOptions(env);
+  const stateOptions = {
+    ...moduleOptions,
+    mode: moduleOptions.mode ?? env.ENIGMA_DEPLOYMENT_MODE ?? env.ENIGMA_MODE ?? env.NODE_ENV ?? 'local',
+  };
+  const state = moduleOptions.state ?? (
+    flags.stateFile && existsSync(flags.stateFile)
+      ? await loadRelayStateFromFile(flags.stateFile, stateOptions)
+      : createRelayState(stateOptions)
+  );
+  const server = createRelayServer({ ...stateOptions, state, stateFile: flags.stateFile });
+  server.listen(flags.port, flags.host);
+  await once(server, 'listening');
+  const address = server.address();
+  print({
+    ok: true,
+    service: 'enigma-relay',
+    mode: state.mode,
+    address: typeof address === 'object' && address ? { host: address.address, port: address.port } : address,
+    federation: server.federationRuntime?.status() ?? { enabled: false },
+    durable_state: server.relayStatePersistence?.status() ?? { enabled: false },
+  }, io);
+  if (flags.stateFile && !server.relayStatePersistence) await saveRelayStateToFile(server.relayState, flags.stateFile);
+  if (flags.once) {
+    server.close();
+    await once(server, 'close');
+  }
+  return 0;
 }
 
-export async function main(argv = process.argv.slice(2), io = { stdout: process.stdout, stderr: process.stderr }) {
+export async function main(
+  argv = process.argv.slice(2),
+  io = { stdout: process.stdout, stderr: process.stderr },
+  env = process.env
+) {
   if (isHelp(argv)) {
     print(relayUsage(), io);
     return 0;
   }
-  return cliMain(relayArgv(argv), io);
+  if (argv[0] === 'demo') return cliMain(['relay', ...argv], io);
+  try {
+    return await runServe(argv, io, env);
+  } catch (error) {
+    print({ ok: false, error: { code: 'RELAY_START_FAILED', message: publicStartError(error) } }, io);
+    return 2;
+  }
 }
 function isMainModule(metaUrl) {
   if (!process.argv[1]) return false;