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

package/scripts/validate-service.mjs

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { runCommand } from './lib/cli-utils.mjs';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-function parseArgs(argv) {
-  const args = {
-    entry: 'dist/main.js',
-    output: 'beam_openApi.json',
-    envFile: undefined,
-    cid: process.env.CID,
-    pid: process.env.PID,
-    host: process.env.HOST,
-    namePrefix: process.env.NAME_PREFIX,
-    service: undefined,
-    skipBuild: false,
-  };
-
-  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;
-      case '--skip-build':
-        args.skipBuild = true;
-        break;
-      default:
-        throw new Error(`Unknown argument: ${current}`);
-    }
-  }
-
-  if (!args.envFile && process.env.npm_config_env_file) {
-    args.envFile = process.env.npm_config_env_file;
-  }
-
-  return args;
-}
-
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
-
-  if (!args.skipBuild) {
-    await runCommand('npm', ['run', 'build']);
-  }
-
-  const generateScript = path.resolve(__dirname, 'generate-openapi.mjs');
-  const commandArgs = ['--entry', args.entry, '--output', args.output];
-
-  if (args.envFile) {
-    commandArgs.push('--env-file', args.envFile);
-  }
-  if (args.cid) {
-    commandArgs.push('--cid', args.cid);
-  }
-  if (args.pid) {
-    commandArgs.push('--pid', args.pid);
-  }
-  if (args.host) {
-    commandArgs.push('--host', args.host);
-  }
-  if (args.namePrefix) {
-    commandArgs.push('--routing-key', args.namePrefix);
-  }
-  if (args.service) {
-    commandArgs.push('--service', args.service);
-  }
-
-  await runCommand(process.execPath, [generateScript, ...commandArgs], { shell: false });
-
-  console.log('Validation completed successfully.');
-}
-
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : error);
-  process.exit(1);
-});

package/scripts/ws-test.mjs

@@ -1,25 +0,0 @@
-import WebSocket from 'ws';
-
-const url = process.argv[2] ?? 'wss://api.beamable.com/socket';
-
-const ws = new WebSocket(url);
-
-ws.on('open', () => {
-  console.log('ws open');
-  const payload = JSON.stringify({ id: -1, method: 'get', path: 'gateway/nonce', body: {} });
-  console.log('sending', payload);
-  ws.send(payload);
-});
-
-ws.on('message', (data) => {
-  console.log('message', data.toString());
-  ws.close();
-});
-
-ws.on('error', (err) => {
-  console.error('error', err);
-});
-
-ws.on('close', (code, reason) => {
-  console.log('closed', code, reason.toString());
-});

package/src/auth.ts

@@ -1,117 +0,0 @@
-import { createHash } from 'node:crypto';
-import { URL } from 'node:url';
-import type { EnvironmentConfig } from './types.js';
-import type { GatewayRequester } from './requester.js';
-import { AuthenticationError } from './errors.js';
-
-interface NonceResponse {
-  nonce: string;
-}
-
-interface AuthResponse {
-  result: string;
-}
-
-interface TokenResponse {
-  access_token?: string;
-  error?: string;
-}
-
-export class AuthManager {
-  private readonly env: EnvironmentConfig;
-  private readonly requester: GatewayRequester;
-
-  constructor(env: EnvironmentConfig, requester: GatewayRequester) {
-    this.env = env;
-    this.requester = requester;
-  }
-
-  async authenticate(): Promise<void> {
-    if (this.env.secret) {
-      await this.authenticateWithRealmSecret();
-      return;
-    }
-    if (this.env.refreshToken) {
-      await this.authenticateWithRefreshToken();
-      return;
-    }
-    throw new AuthenticationError('Neither SECRET nor REFRESH_TOKEN is configured.');
-  }
-
-  private async authenticateWithRealmSecret(): Promise<void> {
-    const nonce = await this.requester.request<NonceResponse>('get', 'gateway/nonce');
-    if (!nonce?.nonce) {
-      throw new AuthenticationError('Gateway did not provide a nonce for authentication.');
-    }
-    const signature = this.calculateRealmSignature(this.env.secret ?? '', nonce.nonce);
-    const body = {
-      cid: this.env.cid,
-      pid: this.env.pid,
-      signature,
-    };
-    const response = await this.requester.request<AuthResponse>('post', 'gateway/auth', body);
-    if (!response || response.result !== 'ok') {
-      throw new AuthenticationError(`Realm secret authentication failed with result=${response?.result ?? 'unknown'}.`);
-    }
-  }
-
-  private async authenticateWithRefreshToken(): Promise<void> {
-    const accessToken = await this.exchangeRefreshToken();
-    const body = {
-      cid: this.env.cid,
-      pid: this.env.pid,
-      token: accessToken,
-    };
-    const response = await this.requester.request<AuthResponse>('post', 'gateway/auth', body);
-    if (!response || response.result !== 'ok') {
-      throw new AuthenticationError(`Refresh-token authentication failed with result=${response?.result ?? 'unknown'}.`);
-    }
-  }
-
-  private calculateRealmSignature(secret: string, nonce: string): string {
-    const hash = createHash('md5');
-    hash.update(secret + nonce, 'utf8');
-    return hash.digest('base64');
-  }
-
-  private async exchangeRefreshToken(): Promise<string> {
-    if (!this.env.refreshToken) {
-      throw new AuthenticationError('REFRESH_TOKEN missing.');
-    }
-    const baseUrl = this.hostToHttpUrl();
-    const tokenUrl = new URL('/basic/auth/token', baseUrl).toString();
-    const response = await fetch(tokenUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Accept: 'application/json',
-        'beam-scope': `${this.env.cid}.${this.env.pid}`,
-      },
-      body: JSON.stringify({
-        grant_type: 'refresh_token',
-        refresh_token: this.env.refreshToken,
-      }),
-    });
-
-    if (!response.ok) {
-      throw new AuthenticationError(`Failed to retrieve access token. status=${response.status}`);
-    }
-
-    const payload = (await response.json()) as TokenResponse;
-    if (!payload.access_token) {
-      throw new AuthenticationError(`Refresh-token exchange failed: ${payload.error ?? 'unknown error'}`);
-    }
-    return payload.access_token;
-  }
-
-  private hostToHttpUrl(): string {
-    const host = this.env.host.replace(/\/socket$/, '');
-    if (host.startsWith('wss://')) {
-      return `https://${host.substring('wss://'.length)}`;
-    }
-    if (host.startsWith('ws://')) {
-      return `http://${host.substring('ws://'.length)}`;
-    }
-    return host;
-  }
-}