@omen.foundation/node-microservice-runtime 0.1.0

package/scripts/publish-service.mjs

@@ -0,0 +1,1126 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import fssync from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { fetch } from 'undici';
+import tar from 'tar-stream';
+import dotenv from 'dotenv';
+import { runCommand } from './lib/cli-utils.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DEFAULT_NODE_VERSION = '20';
+const MANIFEST_MEDIA_TYPE = 'application/vnd.docker.distribution.manifest.v2+json';
+const CONFIG_MEDIA_TYPE = 'application/vnd.docker.container.image.v1+json';
+const LAYER_MEDIA_TYPE = 'application/vnd.docker.image.rootfs.diff.tar.gzip';
+
+// ANSI color codes for colorful output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+};
+
+// Progress bar manager
+class ProgressBar {
+  constructor(totalSteps) {
+    this.totalSteps = totalSteps;
+    this.currentStep = 0;
+    this.currentTask = '';
+    this.startTime = Date.now();
+  }
+
+  start(task) {
+    this.currentTask = task;
+    this.currentStep++;
+    this.update();
+  }
+
+  complete(task) {
+    this.currentTask = task;
+    this.update();
+    process.stdout.write('\n');
+  }
+
+  update() {
+    const percentage = Math.round((this.currentStep / this.totalSteps) * 100);
+    const barWidth = 30;
+    const filled = Math.round((percentage / 100) * barWidth);
+    const empty = barWidth - filled;
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    
+    const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+    
+    // Clear line and write progress
+    process.stdout.write(`\r${colors.cyan}${bar}${colors.reset} ${colors.bright}${percentage}%${colors.reset} ${colors.dim}${this.currentTask}${colors.reset} ${colors.dim}(${elapsed}s)${colors.reset}`);
+  }
+
+  success(message) {
+    process.stdout.write(`\r${colors.green}✓${colors.reset} ${message}\n`);
+  }
+
+  info(message) {
+    process.stdout.write(`\r${colors.blue}ℹ${colors.reset} ${message}\n`);
+  }
+
+  error(message) {
+    process.stdout.write(`\r${colors.red}✗${colors.reset} ${message}\n`);
+  }
+}
+
+function parseArgs(argv) {
+  const args = {
+    entry: 'dist/main.js',
+    openapi: 'beam_openApi.json',
+    envFile: undefined,
+    cid: process.env.BEAMABLE_CID || process.env.CID,
+    pid: process.env.BEAMABLE_PID || process.env.PID,
+    host: process.env.BEAMABLE_HOST || process.env.HOST,
+    namePrefix: process.env.BEAMABLE_NAME_PREFIX || process.env.NAME_PREFIX,
+    token: process.env.BEAMABLE_TOKEN || process.env.BEAMABLE_ACCESS_TOKEN || process.env.ACCESS_TOKEN,
+    gamePid: process.env.BEAMABLE_GAME_PID,
+    comments: process.env.BEAMABLE_PUBLISH_COMMENTS,
+    service: process.env.BEAMABLE_SERVICE_ID,
+    dockerTag: process.env.BEAMABLE_DOCKER_TAG,
+    nodeVersion: process.env.BEAMABLE_NODE_VERSION || DEFAULT_NODE_VERSION,
+    skipValidate: false,
+    apiHost: process.env.BEAMABLE_API_HOST,
+  };
+
+  const queue = [...argv];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    switch (current) {
+      case '--entry':
+        args.entry = queue.shift();
+        break;
+      case '--openapi':
+        args.openapi = 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 '--token':
+        args.token = queue.shift();
+        break;
+      case '--game-pid':
+        args.gamePid = queue.shift();
+        break;
+      case '--comments':
+        args.comments = queue.shift();
+        break;
+      case '--service':
+        args.service = queue.shift();
+        break;
+      case '--docker-tag':
+        args.dockerTag = queue.shift();
+        break;
+      case '--node-version':
+        args.nodeVersion = queue.shift();
+        break;
+      case '--skip-validate':
+        args.skipValidate = true;
+        break;
+      case '--api-host':
+        args.apiHost = queue.shift();
+        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;
+}
+
+function ensure(value, message) {
+  if (!value) {
+    throw new Error(message);
+  }
+  return value;
+}
+
+function md5Hex(input) {
+  return crypto.createHash('md5').update(input).digest('hex');
+}
+
+function sha256Digest(buffer) {
+  return `sha256:${crypto.createHash('sha256').update(buffer).digest('hex')}`;
+}
+
+function shortDigest(fullDigest) {
+  if (!fullDigest) {
+    return '';
+  }
+  const parts = fullDigest.split(':');
+  const hash = parts.length > 1 ? parts[1] : parts[0];
+  return hash.substring(0, 12);
+}
+
+function normalizeApiHost(host) {
+  if (!host) {
+    return undefined;
+  }
+  if (host.startsWith('wss://')) {
+    return `https://${host.substring('wss://'.length).replace(/\/socket$/, '')}`;
+  }
+  if (host.startsWith('ws://')) {
+    return `http://${host.substring('ws://'.length).replace(/\/socket$/, '')}`;
+  }
+  return host.replace(/\/$/, '');
+}
+
+async function readJson(filePath) {
+  const content = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(content);
+}
+
+async function copyDirectory(source, destination) {
+  const entries = await fs.readdir(source, { withFileTypes: true });
+  await fs.mkdir(destination, { recursive: true });
+  for (const entry of entries) {
+    const srcPath = path.join(source, entry.name);
+    const destPath = path.join(destination, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else if (entry.isFile()) {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+async function readDockerImageTar(tarPath) {
+  const files = new Map();
+  const extract = tar.extract();
+
+  await new Promise((resolve, reject) => {
+    extract.on('entry', (header, stream, next) => {
+      const chunks = [];
+      stream.on('data', (chunk) => chunks.push(chunk));
+      stream.on('end', () => {
+        files.set(header.name, Buffer.concat(chunks));
+        next();
+      });
+      stream.on('error', reject);
+    });
+    extract.on('finish', resolve);
+    extract.on('error', reject);
+
+    fssync.createReadStream(tarPath).pipe(extract);
+  });
+
+  const manifestBuffer = files.get('manifest.json');
+  if (!manifestBuffer) {
+    throw new Error('Docker image archive missing manifest.json');
+  }
+
+  const manifestJson = JSON.parse(manifestBuffer.toString());
+  if (!Array.isArray(manifestJson) || manifestJson.length === 0) {
+    throw new Error('Unexpected manifest.json structure.');
+  }
+
+  const manifestEntry = manifestJson[0];
+  const configName = manifestEntry.Config || manifestEntry.config;
+  const layerNames = manifestEntry.Layers || manifestEntry.layers;
+
+  if (!configName || !layerNames) {
+    throw new Error('Manifest entry missing Config or Layers.');
+  }
+
+  const configBuffer = files.get(configName);
+  if (!configBuffer) {
+    throw new Error(`Config blob missing in archive: ${configName}`);
+  }
+
+  const layers = layerNames.map((layerName) => {
+    const buffer = files.get(layerName);
+    if (!buffer) {
+      throw new Error(`Layer missing in archive: ${layerName}`);
+    }
+    return { name: layerName, buffer };
+  });
+
+  return { manifestEntry, configBuffer, layers };
+}
+
+async function checkBlobExists(baseUrl, digest, headers) {
+  const url = new URL(`blobs/${digest}`, baseUrl);
+  const response = await fetch(url, { method: 'HEAD', headers, redirect: 'manual' });
+
+  if (response.status === 307 && response.headers.get('location')) {
+    const redirected = response.headers.get('location');
+    const nextBase = redirected.startsWith('http') ? redirected : new URL(redirected, baseUrl).href;
+    return checkBlobExists(nextBase, digest, headers);
+  }
+
+  return response.status === 200;
+}
+
+async function prepareUploadLocation(baseUrl, headers) {
+  const url = new URL('blobs/uploads/', baseUrl);
+  // Debug logging only - removed verbose output
+  // Match C# CLI exactly: StringContent("") sets Content-Type and Content-Length
+  let response;
+  try {
+    response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        ...headers,
+        'Content-Type': 'text/plain; charset=utf-8',
+        'Content-Length': '0',
+      },
+      body: '', // Empty body
+    });
+  } catch (error) {
+    // Network/SSL errors happen before HTTP response
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    const errorDetails = {
+      url: url.toString(),
+      error: errorMsg,
+      ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
+      ...(error instanceof Error && error.cause ? { cause: error.cause } : {}),
+    };
+    if (process.env.BEAMO_DEBUG === '1' || process.env.BEAMO_NODE_DEBUG === '1') {
+      console.error('[beamo-node] Network error preparing upload location:', errorDetails);
+    }
+    throw new Error(`Network error preparing upload location: ${errorMsg}. URL: ${url.toString()}`);
+  }
+  
+  if (!response.ok) {
+    const text = await response.text();
+    if (process.env.BEAMO_DEBUG === '1' || process.env.BEAMO_NODE_DEBUG === '1') {
+      console.error('[beamo-node] Upload location failed', {
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: text.substring(0, 500),
+      });
+    }
+    throw new Error(`Failed to prepare upload location: ${response.status} ${text}`);
+  }
+  return response.headers.get('location');
+}
+
+async function uploadBlob(baseUrl, digest, buffer, headers) {
+  if (await checkBlobExists(baseUrl, digest, headers)) {
+    return { digest, size: buffer.length };
+  }
+
+  const location = await prepareUploadLocation(baseUrl, headers);
+  if (!location) {
+    throw new Error('Registry did not provide an upload location.');
+  }
+
+  // Match C# CLI: NormalizeWithDigest forces HTTPS and default port (-1 means use default for scheme)
+  const locationUrl = new URL(location.startsWith('http') ? location : new URL(location, baseUrl).href);
+  // Force HTTPS and remove explicit port (use default port 443 for HTTPS)
+  locationUrl.protocol = 'https:';
+  locationUrl.port = ''; // Empty string means use default port for the scheme
+  locationUrl.searchParams.set('digest', digest);
+  const uploadUrl = locationUrl;
+
+  const response = await fetch(uploadUrl, {
+    method: 'PUT',
+    headers: { ...headers, 'Content-Type': 'application/octet-stream' },
+    body: buffer,
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to upload blob ${digest}: ${response.status} ${text}`);
+  }
+
+  return { digest, size: buffer.length };
+}
+
+async function uploadManifest(baseUrl, manifestJson, shortImageId, headers) {
+  // Match C# CLI: upload manifest using the short imageId as the tag
+  // The backend looks up images using this short imageId tag
+  const manifestJsonString = JSON.stringify(manifestJson);
+  const url = new URL(`manifests/${shortImageId}`, baseUrl);
+  
+  // Debug logging only
+  // Debug logging only - removed verbose output
+
+  const response = await fetch(url, {
+    method: 'PUT',
+    headers: { ...headers, 'Content-Type': MANIFEST_MEDIA_TYPE },
+    body: manifestJsonString,
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to upload manifest: ${response.status} ${text}`);
+  }
+}
+
+async function fetchJson(url, options = {}) {
+  const response = await fetch(url, options);
+  if (!response.ok) {
+    const text = await response.text();
+    const error = new Error(`Request failed ${response.status}: ${text}`);
+    error.status = response.status;
+    throw error;
+  }
+  return response.json();
+}
+
+async function resolveGamePid(apiHost, token, cid, pid, explicitGamePid) {
+  if (explicitGamePid) {
+    return explicitGamePid;
+  }
+
+  const scope = pid ? `${cid}.${pid}` : cid;
+  try {
+    const url = new URL(`/basic/realms/game`, apiHost);
+    url.searchParams.set('rootPID', pid);
+    const body = await fetchJson(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        ...(scope ? { 'X-BEAM-SCOPE': scope } : {}),
+      },
+    });
+
+    const projects = Array.isArray(body?.projects) ? body.projects : [];
+    if (projects.length === 0) {
+      return pid;
+    }
+
+    const byPid = new Map(projects.map((project) => [project.pid, project]));
+    let current = byPid.get(pid);
+    const visited = new Set();
+    while (current && current.parent && !visited.has(current.parent)) {
+      visited.add(current.pid);
+      current = byPid.get(current.parent);
+    }
+    const resolved = current?.pid ?? pid;
+    // Debug logging only
+    return resolved;
+  } catch (error) {
+    // Debug logging only
+    return pid;
+  }
+}
+
+async function getScopedAccessToken(apiHost, cid, pid, refreshToken, fallbackToken) {
+  const scope = pid ? `${cid}.${pid}` : cid;
+  if (!refreshToken) {
+    return { accessToken: fallbackToken, refreshToken };
+  }
+
+  try {
+    const response = await fetch(new URL('/basic/auth/token', apiHost), {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        ...(scope ? { 'X-BEAM-SCOPE': scope } : {}),
+      },
+      body: JSON.stringify({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+      }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Refresh token request failed: ${response.status} ${text}`);
+    }
+
+    const body = await response.json();
+    const accessToken = body.access_token ?? fallbackToken;
+    const nextRefresh = body.refresh_token ?? refreshToken;
+    return { accessToken, refreshToken: nextRefresh };
+  } catch (error) {
+    // Debug logging only
+    return { accessToken: fallbackToken, refreshToken };
+  }
+}
+
+async function getRegistryUrl(apiHost, token, cid, pid) {
+  const scope = pid ? `${cid}.${pid}` : cid;
+  const body = await fetchJson(new URL('/basic/beamo/registry', apiHost), {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/json',
+      ...(scope ? { 'X-BEAM-SCOPE': scope } : {}),
+    },
+  });
+  const uri = body.uri || body.registry || body.url;
+  if (!uri) {
+    throw new Error('Registry URI response missing "uri" field.');
+  }
+  // Match C# CLI exactly: GetDockerImageRegistryUri() returns scheme://host/v2/ (Host property strips port)
+  const normalized = uri.includes('://') ? uri : `https://${uri}`;
+  const parsed = new URL(normalized);
+  // parsedUri.Host in C# is just the hostname (no port), so we use hostname here
+  return `${parsed.protocol}//${parsed.hostname}/v2/`;
+}
+
+async function uploadDockerImage({
+  apiHost,
+  registryUrl,
+  cid,
+  pid,
+  gamePid,
+  token,
+  serviceId,
+  uniqueName,
+  imageTarPath,
+  fullImageId,
+  progress,
+}) {
+  const baseUrl = `${registryUrl}${uniqueName}/`;
+  // Match C# CLI exactly: use x-ks-* headers (all lowercase) with CID, PID (realm PID), and access token
+  const headers = {
+    'x-ks-clientid': cid,
+    'x-ks-projectid': pid, // Use realm PID (not gamePid) - matches ctx.Pid in C# CLI
+    'x-ks-token': token, // Access token from login
+  };
+
+  const { manifestEntry, configBuffer, layers } = await readDockerImageTar(imageTarPath);
+
+  // Upload config
+  if (progress) {
+    process.stdout.write(`\r${colors.blue}↑${colors.reset} Uploading config...`);
+  }
+  const configDigest = await uploadBlob(baseUrl, sha256Digest(configBuffer), configBuffer, headers);
+
+  // Upload layers with progress
+  const layerDescriptors = [];
+  const totalLayers = layers.length;
+  for (let i = 0; i < layers.length; i++) {
+    if (progress) {
+      process.stdout.write(`\r${colors.blue}↑${colors.reset} Uploading layers (${i + 1}/${totalLayers})...`);
+    }
+    const descriptor = await uploadBlob(baseUrl, sha256Digest(layers[i].buffer), layers[i].buffer, headers);
+    layerDescriptors.push({
+      digest: descriptor.digest,
+      size: descriptor.size,
+      mediaType: LAYER_MEDIA_TYPE,
+    });
+  }
+
+  const uploadManifestJson = {
+    schemaVersion: 2,
+    mediaType: MANIFEST_MEDIA_TYPE,
+    config: {
+      mediaType: CONFIG_MEDIA_TYPE,
+      digest: configDigest.digest,
+      size: configDigest.size,
+    },
+    layers: layerDescriptors,
+  };
+
+  // Upload manifest using short imageId as tag (matching C# CLI behavior)
+  if (progress) {
+    process.stdout.write(`\r${colors.blue}↑${colors.reset} Uploading manifest...`);
+  }
+  const shortImageId = shortDigest(fullImageId);
+  await uploadManifest(baseUrl, uploadManifestJson, shortImageId, headers);
+  if (progress) {
+    process.stdout.write('\r');
+  }
+}
+
+async function fetchCurrentManifest(apiHost, token, cid, pid) {
+  const response = await fetch(new URL('/api/beamo/manifests/current', apiHost), {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/json',
+      'X-BEAM-SCOPE': `${cid}.${pid}`,
+    },
+  });
+  if (response.status === 404) {
+    // No existing manifest (first publish) - return null
+    return null;
+  }
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to fetch current manifest: ${response.status} ${text}`);
+  }
+  return response.json();
+}
+
+async function discoverStorageObjects(srcDir) {
+  const storageObjects = [];
+  try {
+    const srcPath = path.resolve(srcDir || 'src');
+    const files = await getAllTypeScriptFiles(srcPath);
+    
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      // Match @StorageObject('StorageName') pattern
+      const storageRegex = /@StorageObject\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+      let match;
+      while ((match = storageRegex.exec(content)) !== null) {
+        const storageName = match[1];
+        if (storageName && !storageObjects.find(s => s.id === storageName)) {
+          storageObjects.push({
+            id: storageName,
+            enabled: true,
+            checksum: null,
+            archived: false,
+          });
+        }
+      }
+    }
+  } catch (error) {
+    // If we can't discover storage, that's okay - we'll just use existing ones
+      // Debug logging only
+  }
+  return storageObjects;
+}
+
+async function discoverFederationComponents(srcDir) {
+  const components = [];
+  try {
+    const srcPath = path.resolve(srcDir || 'src');
+    const files = await getAllTypeScriptFiles(srcPath);
+    
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      
+      // Match @FederatedInventory({ identity: IdentityClass }) pattern
+      const federatedInventoryRegex = /@FederatedInventory\s*\(\s*\{\s*identity:\s*(\w+)\s*\}\s*\)/g;
+      let match;
+      while ((match = federatedInventoryRegex.exec(content)) !== null) {
+        const identityClassName = match[1];
+        
+        // Find the identity class definition in the same file or other files
+        // Look for: class IdentityClass implements FederationIdentity { getUniqueName(): string { return 'name'; } }
+        // Use multiline matching to handle class definitions that span multiple lines
+        const identityClassRegex = new RegExp(
+          `class\\s+${identityClassName}[^{]*\\{[\\s\\S]*?getUniqueName\\(\\)[\\s\\S]*?return\\s+['"]([^'"]+)['"]`,
+          's'
+        );
+        let identityMatch = identityClassRegex.exec(content);
+        
+        // If not found in current file, search other files
+        if (!identityMatch) {
+          for (const otherFile of files) {
+            if (otherFile !== file) {
+              const otherContent = await fs.readFile(otherFile, 'utf-8');
+              identityMatch = identityClassRegex.exec(otherContent);
+              if (identityMatch) {
+                break;
+              }
+            }
+          }
+        }
+        
+        if (identityMatch) {
+          const identityName = identityMatch[1];
+          // Add both IFederatedInventory and IFederatedLogin components
+          const inventoryComponent = `IFederatedInventory/${identityName}`;
+          const loginComponent = `IFederatedLogin/${identityName}`;
+          if (!components.includes(inventoryComponent)) {
+            components.push(inventoryComponent);
+          }
+          if (!components.includes(loginComponent)) {
+            components.push(loginComponent);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    // If we can't discover components, that's okay - we'll just use existing ones
+    // Debug logging only
+  }
+  return components;
+}
+
+async function getAllTypeScriptFiles(dir) {
+  const files = [];
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) {
+        files.push(...await getAllTypeScriptFiles(fullPath));
+      } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {
+        files.push(fullPath);
+      }
+    }
+  } catch (error) {
+    // Ignore errors reading directories
+  }
+  return files;
+}
+
+async function updateManifest({
+  apiHost,
+  token,
+  cid,
+  pid,
+  serviceId,
+  shortImageId,
+  comments,
+  existingManifest,
+  discoveredStorage,
+  discoveredComponents,
+  discoveredDependencies,
+}) {
+  const serviceReferences = existingManifest?.serviceReferences?.Value
+    ?? existingManifest?.serviceReferences
+    ?? existingManifest?.manifest
+    ?? [];
+  const storageRefsRaw = existingManifest?.storageReferences?.Value
+    ?? existingManifest?.storageReferences
+    ?? [];
+  const existingStorage = Array.isArray(storageRefsRaw)
+    ? storageRefsRaw.map((reference) => ({
+        id: reference.id?.Value ?? reference.id,
+        enabled: reference.enabled?.Value ?? reference.enabled ?? true,
+        checksum: reference.checksum?.Value ?? reference.checksum,
+        archived: reference.archived?.Value ?? reference.archived ?? false,
+      }))
+    : [];
+  
+  // Merge discovered storage with existing storage
+  // If a storage object exists in both, keep the existing one (preserves checksum, etc.)
+  const storageMap = new Map();
+  existingStorage.forEach(s => storageMap.set(s.id, s));
+  discoveredStorage.forEach(s => {
+    if (!storageMap.has(s.id)) {
+      storageMap.set(s.id, s);
+    }
+  });
+  const storageReferences = Array.from(storageMap.values());
+
+  // Extract existing components and dependencies for the service
+  const existingServiceRef = serviceReferences.find(
+    (ref) => (ref.serviceName?.Value ?? ref.serviceName) === serviceId
+  );
+  const existingComponents = existingServiceRef?.components?.Value 
+    ?? existingServiceRef?.components 
+    ?? [];
+  const existingDependencies = existingServiceRef?.dependencies?.Value 
+    ?? existingServiceRef?.dependencies 
+    ?? [];
+
+  // Components are ServiceComponent objects with {name: string}
+  // Merge discovered with existing (preserve existing, add new)
+  const componentsMap = new Map();
+  // Add existing components
+  if (Array.isArray(existingComponents)) {
+    existingComponents.forEach(comp => {
+      const name = comp.name?.Value ?? comp.name ?? comp;
+      if (typeof name === 'string') {
+        componentsMap.set(name, { name });
+      }
+    });
+  }
+  // Add discovered components (will overwrite existing if same name)
+  (discoveredComponents || []).forEach(compName => {
+    componentsMap.set(compName, { name: compName });
+  });
+  const components = Array.from(componentsMap.values());
+
+  // Dependencies are objects with {id, storageType}, need to merge by id
+  const dependenciesMap = new Map();
+  // Add existing dependencies
+  if (Array.isArray(existingDependencies)) {
+    existingDependencies.forEach(dep => {
+      const id = dep.id?.Value ?? dep.id ?? dep;
+      if (typeof id === 'string') {
+        const storageType = dep.storageType?.Value ?? dep.storageType ?? 'mongo';
+        dependenciesMap.set(id, { id, storageType });
+      }
+    });
+  }
+  // Add discovered dependencies (will overwrite existing if same id)
+  (discoveredDependencies || []).forEach(dep => {
+    dependenciesMap.set(dep.id, dep);
+  });
+  const dependencies = Array.from(dependenciesMap.values());
+
+  let updated = false;
+  const mappedServices = serviceReferences.map((reference) => {
+    const name = reference.serviceName?.Value ?? reference.serviceName;
+    if (name === serviceId) {
+      updated = true;
+      return {
+        serviceName: serviceId,
+        enabled: true,
+        templateId: reference.templateId?.Value ?? reference.templateId ?? 'small',
+        containerHealthCheckPort: reference.containerHealthCheckPort?.Value ?? reference.containerHealthCheckPort ?? 6565,
+        imageId: shortImageId,
+        imageCpuArch: reference.imageCpuArch?.Value ?? reference.imageCpuArch ?? 'linux/amd64',
+        logProvider: reference.logProvider?.Value ?? reference.logProvider ?? 'Clickhouse',
+        dependencies,
+        components,
+      };
+    }
+    return {
+      serviceName: name,
+      enabled: reference.enabled?.Value ?? reference.enabled ?? true,
+      templateId: reference.templateId?.Value ?? reference.templateId ?? 'small',
+      containerHealthCheckPort: reference.containerHealthCheckPort?.Value ?? reference.containerHealthCheckPort ?? 6565,
+      imageId: reference.imageId?.Value ?? reference.imageId ?? shortImageId,
+      imageCpuArch: reference.imageCpuArch?.Value ?? reference.imageCpuArch ?? 'linux/amd64',
+      logProvider: reference.logProvider?.Value ?? reference.logProvider ?? 'Clickhouse',
+      dependencies: reference.dependencies?.Value ?? reference.dependencies ?? [],
+      components: reference.components?.Value ?? reference.components ?? [],
+    };
+  });
+
+  if (!updated) {
+    mappedServices.push({
+      serviceName: serviceId,
+      enabled: true,
+      templateId: 'small',
+      containerHealthCheckPort: 6565,
+      imageId: shortImageId,
+      imageCpuArch: 'linux/amd64',
+      logProvider: 'Clickhouse',
+      dependencies,
+      components,
+    });
+  }
+
+  const requestBody = {
+    autoDeploy: true,
+    comments: comments ?? '',
+    manifest: mappedServices,
+    storageReferences,
+  };
+
+  const response = await fetch(new URL('/api/beamo/manifests', apiHost), {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      'X-BEAM-SCOPE': `${cid}.${pid}`,
+    },
+    body: JSON.stringify(requestBody),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to publish manifest: ${response.status} ${text}`);
+  }
+}
+
+async function prepareDockerContext({ entry, distDir, openapiPath, packageJson, packageLock, nodeVersion }) {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'beam-node-ms-'));
+  const contextDir = path.join(tempRoot, 'context');
+  const appDir = path.join(contextDir, 'app');
+  await fs.mkdir(appDir, { recursive: true });
+
+  // Read and modify package.json to handle file: dependencies
+  const pkg = JSON.parse(await fs.readFile(packageJson, 'utf8'));
+  const modifiedPkg = { ...pkg };
+  
+  // Check if there's a file: dependency for @omen.foundation/node-microservice-runtime
+  const runtimeDep = modifiedPkg.dependencies?.['@omen.foundation/node-microservice-runtime'];
+  if (runtimeDep?.startsWith('file:')) {
+    // Copy the Microservice package from node_modules (it should be installed locally)
+    // The file: path is relative to the package.json location
+    const packageJsonDir = path.dirname(packageJson);
+    const filePath = runtimeDep.replace('file:', '');
+    const microservicePath = path.resolve(packageJsonDir, filePath);
+    const microserviceDest = path.join(appDir, 'node_modules/@omen.foundation/node-microservice-runtime');
+    
+    try {
+      await fs.access(microservicePath);
+      await fs.mkdir(path.dirname(microserviceDest), { recursive: true });
+      await copyDirectory(microservicePath, microserviceDest);
+      // Change the dependency to point to the local copy in Docker
+      modifiedPkg.dependencies['@omen.foundation/node-microservice-runtime'] = 'file:./node_modules/@omen.foundation/node-microservice-runtime';
+    } catch (error) {
+      // If the path doesn't exist, we need to install first
+      // For now, throw a helpful error
+      throw new Error(
+        `Cannot find @omen.foundation/node-microservice-runtime at ${microservicePath}. ` +
+        `Please run 'npm install' in the microservice project directory first. ` +
+        `Original error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  
+  await fs.writeFile(path.join(appDir, 'package.json'), JSON.stringify(modifiedPkg, null, 2), 'utf8');
+  
+  try {
+    await fs.copyFile(packageLock, path.join(appDir, 'package-lock.json'));
+  } catch {
+    // ignore missing package-lock
+  }
+
+  await copyDirectory(distDir, path.join(appDir, 'dist'));
+  try {
+    await fs.copyFile(openapiPath, path.join(appDir, 'beam_openApi.json'));
+  } catch {
+    await fs.writeFile(path.join(appDir, 'beam_openApi.json'), '{}\n');
+  }
+
+  // Check if we copied node_modules (for file: dependencies)
+  const nodeModulesPath = path.join(appDir, 'node_modules/@omen.foundation');
+  const hasNodeModules = await fs.access(nodeModulesPath).then(() => true).catch(() => false);
+  
+  const dockerfile = `# syntax=docker/dockerfile:1
+ARG NODE_VERSION=${nodeVersion}
+FROM node:${nodeVersion}-alpine
+
+WORKDIR /beam/service
+
+COPY app/package*.json ./
+# Install dependencies first (file: dependency removed from package.json)
+RUN npm install --omit=dev && npm cache clean --force
+${hasNodeModules ? '# Copy pre-installed @omen.foundation package AFTER npm install (so it doesn't get overwritten)\nCOPY app/node_modules/@omen.foundation ./node_modules/@omen.foundation\n' : ''}
+
+COPY app/dist ./dist
+COPY app/beam_openApi.json ./beam_openApi.json
+
+# Expose health check port (matches C# microservice behavior)
+EXPOSE 6565
+
+ENV NODE_ENV=production
+
+# Add startup script to log what's happening and catch errors
+RUN echo '#!/bin/sh' > /beam/service/start.sh && \\
+    echo 'echo "Starting Node.js microservice..."' >> /beam/service/start.sh && \\
+    echo 'echo "Working directory: $(pwd)"' >> /beam/service/start.sh && \\
+    echo 'echo "Node version: $(node --version)"' >> /beam/service/start.sh && \\
+    echo 'echo "Files in dist:"' >> /beam/service/start.sh && \\
+    echo 'ls -la dist/ || echo "dist directory not found!"' >> /beam/service/start.sh && \\
+    echo 'echo "Starting main.js..."' >> /beam/service/start.sh && \\
+    echo 'exec node dist/main.js' >> /beam/service/start.sh && \\
+    chmod +x /beam/service/start.sh
+
+# Use ENTRYPOINT with startup script to ensure we see what's happening
+ENTRYPOINT ["/beam/service/start.sh"]
+
+# Debug option: uncomment the line below and comment the ENTRYPOINT above
+# to keep the container alive for debugging (like C# Dockerfile does)
+# ENTRYPOINT ["tail", "-f", "/dev/null"]
+`;
+  await fs.writeFile(path.join(contextDir, 'Dockerfile'), dockerfile, 'utf8');
+
+  return { tempRoot, contextDir };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.envFile) {
+    dotenv.config({ path: path.resolve(args.envFile) });
+  }
+
+  const pkg = await readJson(path.resolve('package.json'));
+  const beamableConfig = pkg.beamable || {};
+
+  const serviceId = args.service || beamableConfig.beamoId || pkg.name;
+  ensure(serviceId, 'Service identifier is required. Provide --service or set beamable.beamoId in package.json.');
+
+  const cid = ensure(args.cid || beamableConfig.cid || process.env.CID, 'CID is required (set CID env var or --cid).');
+  const pid = ensure(args.pid || beamableConfig.pid || process.env.PID, 'PID is required (set PID env var or --pid).');
+  const host = args.host || beamableConfig.host || process.env.HOST || 'wss://api.beamable.com/socket';
+  const apiHost = normalizeApiHost(args.apiHost || beamableConfig.apiHost || process.env.BEAMABLE_API_HOST || host);
+  const token = ensure(args.token || process.env.ACCESS_TOKEN || process.env.BEAMABLE_TOKEN, 'Access token is required (set BEAMABLE_TOKEN env var or --token).');
+  
+  const configuredGamePid = args.gamePid || beamableConfig.gamePid || process.env.BEAMABLE_GAME_PID;
+  const refreshToken = args.refreshToken || process.env.BEAMABLE_REFRESH_TOKEN || process.env.REFRESH_TOKEN;
+
+  if (!apiHost) {
+    throw new Error('API host could not be determined. Set BEAMABLE_API_HOST or provide --api-host.');
+  }
+
+  // Initialize progress bar (8 main steps)
+  const progress = new ProgressBar(8);
+  console.log(`${colors.bright}${colors.cyan}Publishing ${serviceId}...${colors.reset}\n`);
+
+  // Step 1: Build
+  progress.start('Building project');
+  if (!args.skipValidate) {
+    const validateScript = path.resolve(__dirname, 'validate-service.mjs');
+    const validateArgs = ['--entry', args.entry, '--output', args.openapi, '--cid', cid, '--pid', pid, '--host', host];
+    if (args.envFile) {
+      validateArgs.push('--env-file', args.envFile);
+    }
+    if (args.namePrefix) {
+      validateArgs.push('--routing-key', args.namePrefix);
+    }
+    validateArgs.push('--skip-build');
+    await runCommand('npm', ['run', 'build'], { silent: true });
+    await runCommand(process.execPath, [validateScript, ...validateArgs], { shell: false, silent: true });
+  } else {
+    await runCommand('npm', ['run', 'build'], { silent: true });
+  }
+  progress.complete('Build complete');
+
+  const packageJsonPath = path.resolve('package.json');
+  const packageLockPath = path.resolve('package-lock.json');
+  const distDir = path.resolve('dist');
+  const openapiPath = path.resolve(args.openapi);
+  const entryFile = path.resolve(args.entry);
+
+  await fs.access(entryFile);
+  await fs.access(distDir);
+
+  let tempRoot;
+  try {
+    // Step 2: Prepare Docker context
+    progress.start('Preparing Docker context');
+    const context = await prepareDockerContext({
+      entry: entryFile,
+      distDir,
+      openapiPath,
+      packageJson: packageJsonPath,
+      packageLock: packageLockPath,
+      nodeVersion: args.nodeVersion,
+    });
+    tempRoot = context.tempRoot;
+    const { contextDir } = context;
+    progress.complete('Docker context prepared');
+
+    // Step 3: Build Docker image
+    progress.start('Building Docker image');
+    const dockerTag = args.dockerTag || `${serviceId.toLowerCase().replace(/[^a-z0-9-_]/g, '-')}:${Date.now()}`;
+    await runCommand('docker', ['build', '-t', dockerTag, contextDir], { cwd: contextDir, silent: true });
+    progress.complete('Docker image built');
+
+    // Step 4: Extract image ID and save
+    progress.start('Preparing image for upload');
+    const inspect = await runCommand('docker', ['image', 'inspect', '--format', '{{.Id}}', dockerTag], { capture: true });
+    const fullImageId = inspect.stdout.trim();
+    const imageTarPath = path.join(tempRoot, `${serviceId.replace(/[^a-z0-9-_]/gi, '_')}.tar`);
+    await runCommand('docker', ['image', 'save', dockerTag, '-o', imageTarPath], { silent: true });
+    progress.complete('Image prepared');
+
+    // Step 5: Authenticate and get registry
+    progress.start('Authenticating');
+    const resolvedGamePid = await resolveGamePid(apiHost, token, cid, pid, configuredGamePid);
+    
+    // Verify token is valid (401 means invalid token, 403 might just be permission issue)
+    try {
+      const testUrl = new URL('/basic/accounts/me', apiHost);
+      const testResponse = await fetch(testUrl, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: 'application/json',
+          'X-BEAM-SCOPE': `${cid}.${pid}`,
+        },
+      });
+      if (testResponse.status === 401) {
+        throw new Error(`Token validation failed: ${testResponse.status} ${await testResponse.text()}`);
+      }
+    } catch (error) {
+      if (error.message.includes('401')) {
+        throw new Error(`Token validation failed: ${error.message}. Please run "beamo-node login" again.`);
+      }
+    }
+    
+    const registryUrl = await getRegistryUrl(apiHost, token, cid, resolvedGamePid);
+    const uniqueName = md5Hex(`${cid}_${resolvedGamePid}_${serviceId}`).substring(0, 30);
+    progress.complete('Authenticated');
+
+    // Step 6: Upload Docker image
+    progress.start('Uploading Docker image to registry');
+    await uploadDockerImage({
+      apiHost,
+      registryUrl,
+      cid,
+      pid,
+      gamePid: resolvedGamePid,
+      token,
+      serviceId,
+      uniqueName,
+      imageTarPath,
+      fullImageId,
+      progress,
+    });
+    progress.complete('Image uploaded');
+
+    // Step 7: Discover storage, components, and dependencies
+    progress.start('Discovering storage objects and components');
+    const shortImageId = shortDigest(fullImageId);
+    const existingManifest = await fetchCurrentManifest(apiHost, token, cid, pid);
+    const discoveredStorage = await discoverStorageObjects('src');
+    const discoveredComponents = await discoverFederationComponents('src');
+    // Dependencies are ServiceDependencyReference objects with id and storageType
+    // storageType is typically "mongo" for MongoDB storage objects
+    const discoveredDependencies = discoveredStorage.map(s => ({
+      id: s.id,
+      storageType: 'mongo', // All storage objects use MongoDB
+    }));
+    progress.complete('Storage and components discovered');
+
+    // Step 8: Publish manifest
+    progress.start('Publishing manifest');
+    await updateManifest({
+      apiHost,
+      token,
+      cid,
+      pid,
+      serviceId,
+      shortImageId,
+      comments: args.comments,
+      existingManifest,
+      discoveredStorage,
+      discoveredComponents,
+      discoveredDependencies,
+    });
+    progress.complete('Manifest published');
+
+    // Success message
+    console.log(`\n${colors.green}${colors.bright}✓ Publish complete!${colors.reset}`);
+    console.log(`${colors.dim}  Service:${colors.reset} ${serviceId}`);
+    console.log(`${colors.dim}  Image ID:${colors.reset} ${fullImageId}`);
+    console.log(`${colors.dim}  Registry:${colors.reset} ${registryUrl}${uniqueName}`);
+  } finally {
+    if (tempRoot) {
+      await fs.rm(tempRoot, { recursive: true, force: true });
+    }
+  }
+}
+
+main().catch(async (error) => {
+  // Show clean error message
+  console.error(`\n${colors.red}${colors.bright}✗ Publish failed${colors.reset}`);
+  if (error instanceof Error) {
+    console.error(`${colors.red}${error.message}${colors.reset}`);
+    if (process.env.BEAMO_DEBUG === '1' || process.env.BEAMO_NODE_DEBUG === '1') {
+      console.error(`\n${colors.dim}Stack:${colors.reset} ${error.stack}`);
+      if (error.cause) {
+        console.error(`${colors.dim}Cause:${colors.reset} ${error.cause}`);
+      }
+      if (error.stdout) {
+        console.error(`${colors.dim}stdout:${colors.reset} ${error.stdout}`);
+      }
+      if (error.stderr) {
+        console.error(`${colors.dim}stderr:${colors.reset} ${error.stderr}`);
+      }
+      console.error(`\n${colors.dim}Full error:${colors.reset}`, JSON.stringify(error, Object.getOwnPropertyNames(error), 2));
+    }
+  } else {
+    console.error(`${colors.red}${error}${colors.reset}`);
+  }
+  process.exit(1);
+});