@omen.foundation/node-microservice-runtime 0.1.67 → 0.1.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omen.foundation/node-microservice-runtime",
-  "version": "0.1.67",
+  "version": "0.1.68",
   "description": "Beamable microservice runtime for Node.js/TypeScript services.",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,8 @@
     "beamo-node": "./dist/cli/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "scripts"
   ],
   "scripts": {
     "clean": "rimraf dist dist-cjs",

package/scripts/deprecate-all-versions.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * Script to deprecate all old versions that contain .env files
+ * 
+ * Usage: node scripts/deprecate-all-versions.js
+ * 
+ * This will deprecate all versions from 0.1.0 to 0.1.66
+ * You cannot unpublish packages older than 72 hours, so deprecation is the alternative
+ */
+
+import { execSync } from 'child_process';
+
+const PACKAGE_NAME = '@omen.foundation/node-microservice-runtime';
+const DEPRECATE_MESSAGE = 'Security: This version contains exposed credentials. Use version 0.1.67 or later.';
+
+// All versions that need to be deprecated
+const VERSIONS = [
+  '0.1.0', '0.1.1', '0.1.2', '0.1.3', '0.1.4', '0.1.5', '0.1.6', '0.1.7', '0.1.8', '0.1.9',
+  '0.1.10', '0.1.11', '0.1.12', '0.1.13', '0.1.14', '0.1.15', '0.1.16', '0.1.17', '0.1.18', '0.1.19',
+  '0.1.20', '0.1.21', '0.1.22', '0.1.23', '0.1.24', '0.1.25', '0.1.26', '0.1.27', '0.1.28', '0.1.29',
+  '0.1.30', '0.1.31', '0.1.32', '0.1.33', '0.1.34', '0.1.35', '0.1.36', '0.1.37', '0.1.38', '0.1.39',
+  '0.1.40', '0.1.41', '0.1.42', '0.1.43', '0.1.44', '0.1.45', '0.1.46', '0.1.47', '0.1.48', '0.1.49',
+  '0.1.50', '0.1.51', '0.1.52', '0.1.53', '0.1.54', '0.1.55', '0.1.56', '0.1.57', '0.1.58', '0.1.59',
+  '0.1.60', '0.1.61', '0.1.62', '0.1.63', '0.1.64', '0.1.65', '0.1.66'
+];
+
+console.log(`\n🚨 Deprecating ${VERSIONS.length} versions of ${PACKAGE_NAME}\n`);
+console.log(`Message: "${DEPRECATE_MESSAGE}"\n`);
+
+let successCount = 0;
+let failCount = 0;
+const failedVersions = [];
+
+for (const version of VERSIONS) {
+  const fullPackageName = `${PACKAGE_NAME}@${version}`;
+  
+  try {
+    console.log(`Deprecating ${fullPackageName}...`);
+    
+    // Escape the message for shell
+    const escapedMessage = DEPRECATE_MESSAGE.replace(/'/g, "\\'").replace(/"/g, '\\"');
+    const command = `npm deprecate "${fullPackageName}" "${escapedMessage}"`;
+    
+    execSync(command, { stdio: 'inherit' });
+    
+    console.log(`✅ Deprecated ${version}\n`);
+    successCount++;
+    
+    // Small delay to avoid rate limiting
+    if (successCount % 10 === 0) {
+      console.log('Pausing for 2 seconds to avoid rate limiting...\n');
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+  } catch (error) {
+    console.error(`❌ Failed to deprecate ${version}: ${error.message}\n`);
+    failCount++;
+    failedVersions.push(version);
+  }
+}
+
+console.log(`\n=== Summary ===`);
+console.log(`✅ Successfully deprecated: ${successCount} versions`);
+console.log(`❌ Failed: ${failCount} versions`);
+
+if (failedVersions.length > 0) {
+  console.log(`\nFailed versions:`);
+  failedVersions.forEach(v => console.log(`  - ${v}`));
+  console.log(`\nYou may need to deprecate these manually or they may already be deprecated.`);
+}
+
+console.log(`\n⚠️  Important: Rotate your Beamable SECRET immediately!`);
+console.log(`   All these versions contained exposed credentials.`);

package/scripts/generate-openapi.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import dotenv from 'dotenv';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function parseArgs(argv) {
+  const args = {
+    entry: 'dist/main.js',
+    output: 'beam_openApi.json',
+    envFile: undefined,
+    cid: undefined,
+    pid: undefined,
+    host: undefined,
+    namePrefix: undefined,
+    service: undefined,
+  };
+
+  const queue = [...argv];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    switch (current) {
+      case '--entry':
+        args.entry = queue.shift();
+        break;
+      case '--output':
+        args.output = queue.shift();
+        break;
+      case '--env-file':
+        args.envFile = queue.shift();
+        break;
+      case '--cid':
+        args.cid = queue.shift();
+        break;
+      case '--pid':
+        args.pid = queue.shift();
+        break;
+      case '--host':
+        args.host = queue.shift();
+        break;
+      case '--routing-key':
+      case '--name-prefix':
+        args.namePrefix = queue.shift();
+        break;
+      case '--service':
+        args.service = queue.shift();
+        break;
+      default:
+        throw new Error(`Unknown argument: ${current}`);
+    }
+  }
+
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.envFile) {
+    const envPath = path.resolve(args.envFile);
+    dotenv.config({ path: envPath });
+  }
+
+  if (args.cid) {
+    process.env.CID = args.cid;
+  }
+  if (args.pid) {
+    process.env.PID = args.pid;
+  }
+  if (args.host) {
+    process.env.HOST = args.host;
+  }
+  if (args.namePrefix) {
+    process.env.NAME_PREFIX = args.namePrefix;
+  }
+
+  process.env.BEAMABLE_SKIP_RUNTIME = 'true';
+
+  const entryPath = path.resolve(args.entry);
+  const outputPath = path.resolve(args.output);
+
+  const runtimeEntry = path.resolve(__dirname, '../dist/runtime.js');
+  try {
+    await fs.access(runtimeEntry);
+  } catch (error) {
+    throw new Error('Runtime distribution not found. Run "npm run compile" in @omen.foundation/node-microservice-runtime.');
+  }
+
+  await import(pathToFileURL(entryPath).href);
+
+  const { generateOpenApiDocumentForRegisteredServices } = await import(pathToFileURL(runtimeEntry).href);
+
+  const document = generateOpenApiDocumentForRegisteredServices(
+    {
+      cid: process.env.CID,
+      pid: process.env.PID,
+      host: process.env.HOST,
+      routingKey: process.env.NAME_PREFIX,
+    },
+    { serviceName: args.service },
+  );
+
+  await fs.writeFile(outputPath, `${JSON.stringify(document, null, 2)}\n`, 'utf8');
+
+  console.log(`OpenAPI documentation generated at ${outputPath}`);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/scripts/lib/cli-utils.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+
+export function runCommand(
+  command,
+  args,
+  { cwd = process.cwd(), env = process.env, stdio = 'inherit', capture = false, shell, silent = false } = {},
+) {
+  return new Promise((resolve, reject) => {
+    const stdioOption = capture ? 'pipe' : (silent ? 'ignore' : stdio);
+    const child = spawn(command, args, {
+      cwd,
+      env,
+      stdio: stdioOption,
+      shell: shell ?? (process.platform === 'win32'),
+    });
+
+    const stdoutChunks = [];
+    const stderrChunks = [];
+
+    if (capture) {
+      child.stdout?.on('data', (chunk) => stdoutChunks.push(chunk));
+      child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+    }
+
+    child.on('error', (error) => {
+      reject(error);
+    });
+
+    child.on('exit', (code, signal) => {
+      if (code === 0) {
+        resolve({
+          code,
+          signal,
+          stdout: capture ? Buffer.concat(stdoutChunks).toString('utf8').trim() : undefined,
+          stderr: capture ? Buffer.concat(stderrChunks).toString('utf8').trim() : undefined,
+        });
+      } else {
+        const error = new Error(`Command failed: ${command} ${args.join(' ')}`);
+        error.code = code;
+        error.signal = signal;
+        if (capture) {
+          error.stdout = Buffer.concat(stdoutChunks).toString('utf8');
+          error.stderr = Buffer.concat(stderrChunks).toString('utf8');
+        }
+        reject(error);
+      }
+    });
+  });
+}
+
+export function parseBooleanEnv(value, fallback = false) {
+  if (value === undefined) {
+    return fallback;
+  }
+  return ['1', 'true', 'yes', 'on'].includes(value.toString().trim().toLowerCase());
+}

package/scripts/prepare-cjs.mjs

@@ -0,0 +1,44 @@
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+
+async function copyCjsFiles() {
+  const srcRoot = join(process.cwd(), 'dist-cjs');
+  const dstRoot = join(process.cwd(), 'dist');
+
+  await ensureDir(dstRoot);
+
+  const stack = [''];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const srcDir = join(srcRoot, current);
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const relativePath = join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(relativePath);
+        continue;
+      }
+
+      if (!entry.name.endsWith('.js')) {
+        continue;
+      }
+
+      const sourceFile = join(srcRoot, relativePath);
+      const destFile = join(dstRoot, current, entry.name.replace(/\.js$/, '.cjs'));
+      await ensureDir(dirname(destFile));
+      const contents = await readFile(sourceFile);
+      await writeFile(destFile, contents);
+    }
+  }
+
+  await rm(srcRoot, { recursive: true, force: true });
+}
+
+copyCjsFiles().catch((error) => {
+  console.error('Failed to prepare CommonJS artifacts:', error);
+  process.exitCode = 1;
+});