@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/cloudfront/store.js

@@ -0,0 +1,326 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * CloudFront JSON Persistence Store
+ * Manages persistence of distributions and related data to JSON files
+ */
+class CloudFrontStore {
+  constructor(storePath = './data/cloudfront') {
+    this.storePath = storePath;
+    this.distributionsFile = path.join(storePath, 'distributions.json');
+    this.invalidationsFile = path.join(storePath, 'invalidations.json');
+    this.keyPairsFile = path.join(storePath, 'key-pairs.json');
+    this.init();
+  }
+
+  /**
+   * Initialize store - create directories and files if needed
+   */
+  init() {
+    if (!fs.existsSync(this.storePath)) {
+      fs.mkdirSync(this.storePath, { recursive: true });
+    }
+
+    // Initialize distribution file
+    if (!fs.existsSync(this.distributionsFile)) {
+      this._writeFile(this.distributionsFile, { distributions: [] });
+    }
+
+    // Initialize invalidations file
+    if (!fs.existsSync(this.invalidationsFile)) {
+      this._writeFile(this.invalidationsFile, { invalidations: [] });
+    }
+
+    // Initialize key pairs file
+    if (!fs.existsSync(this.keyPairsFile)) {
+      this._writeFile(this.keyPairsFile, { keyPairs: [] });
+    }
+  }
+
+  /**
+   * Save a distribution
+   * @param {object} distribution - Distribution object
+   */
+  saveDistribution(distribution) {
+    const data = this._readFile(this.distributionsFile);
+    
+    const index = data.distributions.findIndex(d => d.id === distribution.id);
+    if (index !== -1) {
+      data.distributions[index] = distribution;
+    } else {
+      data.distributions.push(distribution);
+    }
+
+    this._writeFile(this.distributionsFile, data);
+  }
+
+  /**
+   * Get a distribution
+   * @param {string} distributionId - Distribution ID
+   * @returns {object|null} Distribution or null
+   */
+  getDistribution(distributionId) {
+    const data = this._readFile(this.distributionsFile);
+    return data.distributions.find(d => d.id === distributionId) || null;
+  }
+
+  /**
+   * Get all distributions
+   * @returns {object[]} Array of distributions
+   */
+  getAllDistributions() {
+    const data = this._readFile(this.distributionsFile);
+    return data.distributions || [];
+  }
+
+  /**
+   * Delete a distribution
+   * @param {string} distributionId - Distribution ID
+   * @returns {boolean} True if deleted
+   */
+  deleteDistribution(distributionId) {
+    const data = this._readFile(this.distributionsFile);
+    
+    const index = data.distributions.findIndex(d => d.id === distributionId);
+    if (index === -1) {
+      return false;
+    }
+
+    data.distributions.splice(index, 1);
+    this._writeFile(this.distributionsFile, data);
+    return true;
+  }
+
+  /**
+   * Save invalidation
+   * @param {object} invalidation - Invalidation object
+   */
+  saveInvalidation(invalidation) {
+    const data = this._readFile(this.invalidationsFile);
+    
+    const index = data.invalidations.findIndex(i => i.id === invalidation.id);
+    if (index !== -1) {
+      data.invalidations[index] = invalidation;
+    } else {
+      data.invalidations.push(invalidation);
+    }
+
+    this._writeFile(this.invalidationsFile, data);
+  }
+
+  /**
+   * Get invalidation
+   * @param {string} invalidationId - Invalidation ID
+   * @returns {object|null} Invalidation or null
+   */
+  getInvalidation(invalidationId) {
+    const data = this._readFile(this.invalidationsFile);
+    return data.invalidations.find(i => i.id === invalidationId) || null;
+  }
+
+  /**
+   * Get invalidations by distribution
+   * @param {string} distributionId - Distribution ID
+   * @returns {object[]} Array of invalidations
+   */
+  getInvalidationsByDistribution(distributionId) {
+    const data = this._readFile(this.invalidationsFile);
+    return data.invalidations.filter(i => i.distributionId === distributionId) || [];
+  }
+
+  /**
+   * Delete invalidation
+   * @param {string} invalidationId - Invalidation ID
+   * @returns {boolean} True if deleted
+   */
+  deleteInvalidation(invalidationId) {
+    const data = this._readFile(this.invalidationsFile);
+    
+    const index = data.invalidations.findIndex(i => i.id === invalidationId);
+    if (index === -1) {
+      return false;
+    }
+
+    data.invalidations.splice(index, 1);
+    this._writeFile(this.invalidationsFile, data);
+    return true;
+  }
+
+  /**
+   * Save key pair
+   * @param {object} keyPair - Key pair object
+   */
+  saveKeyPair(keyPair) {
+    const data = this._readFile(this.keyPairsFile);
+    
+    const index = data.keyPairs.findIndex(k => k.id === keyPair.id);
+    if (index !== -1) {
+      data.keyPairs[index] = keyPair;
+    } else {
+      data.keyPairs.push(keyPair);
+    }
+
+    this._writeFile(this.keyPairsFile, data);
+  }
+
+  /**
+   * Get key pair
+   * @param {string} keyPairId - Key pair ID
+   * @returns {object|null} Key pair or null
+   */
+  getKeyPair(keyPairId) {
+    const data = this._readFile(this.keyPairsFile);
+    return data.keyPairs.find(k => k.id === keyPairId) || null;
+  }
+
+  /**
+   * Get all key pairs
+   * @returns {object[]} Array of key pairs
+   */
+  getAllKeyPairs() {
+    const data = this._readFile(this.keyPairsFile);
+    return data.keyPairs || [];
+  }
+
+  /**
+   * Delete key pair
+   * @param {string} keyPairId - Key pair ID
+   * @returns {boolean} True if deleted
+   */
+  deleteKeyPair(keyPairId) {
+    const data = this._readFile(this.keyPairsFile);
+    
+    const index = data.keyPairs.findIndex(k => k.id === keyPairId);
+    if (index === -1) {
+      return false;
+    }
+
+    data.keyPairs.splice(index, 1);
+    this._writeFile(this.keyPairsFile, data);
+    return true;
+  }
+
+  /**
+   * Export all data
+   * @returns {object} All data in the store
+   */
+  export() {
+    return {
+      distributions: this.getAllDistributions(),
+      invalidations: this._readFile(this.invalidationsFile).invalidations || [],
+      keyPairs: this.getAllKeyPairs(),
+      exportedAt: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Import data
+   * @param {object} data - Data to import
+   */
+  import(data) {
+    if (data.distributions && Array.isArray(data.distributions)) {
+      const distributionData = { distributions: data.distributions };
+      this._writeFile(this.distributionsFile, distributionData);
+    }
+
+    if (data.invalidations && Array.isArray(data.invalidations)) {
+      const invalidationData = { invalidations: data.invalidations };
+      this._writeFile(this.invalidationsFile, invalidationData);
+    }
+
+    if (data.keyPairs && Array.isArray(data.keyPairs)) {
+      const keyPairData = { keyPairs: data.keyPairs };
+      this._writeFile(this.keyPairsFile, keyPairData);
+    }
+  }
+
+  /**
+   * Clear all data
+   */
+  clear() {
+    this._writeFile(this.distributionsFile, { distributions: [] });
+    this._writeFile(this.invalidationsFile, { invalidations: [] });
+    this._writeFile(this.keyPairsFile, { keyPairs: [] });
+  }
+
+  /**
+   * Get storage stats
+   * @returns {object} Storage statistics
+   */
+  getStats() {
+    const distributionData = this._readFile(this.distributionsFile);
+    const invalidationData = this._readFile(this.invalidationsFile);
+    const keyPairData = this._readFile(this.keyPairsFile);
+
+    return {
+      distributions: distributionData.distributions?.length || 0,
+      invalidations: invalidationData.invalidations?.length || 0,
+      keyPairs: keyPairData.keyPairs?.length || 0,
+      storePath: this.storePath,
+      lastModified: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Create a backup
+   * @param {string} [backupPath] - Optional custom backup path
+   * @returns {string} Path to backup file
+   */
+  createBackup(backupPath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backup = backupPath || path.join(this.storePath, `backup-${timestamp}.json`);
+    
+    const data = this.export();
+    this._writeFile(backup, data);
+    
+    return backup;
+  }
+
+  /**
+   * Restore from backup
+   * @param {string} backupPath - Path to backup file
+   */
+  restoreFromBackup(backupPath) {
+    if (!fs.existsSync(backupPath)) {
+      throw new Error(`Backup file not found: ${backupPath}`);
+    }
+
+    const data = this._readFile(backupPath);
+    this.import(data);
+  }
+
+  /**
+   * Private Methods
+   */
+
+  _readFile(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return {};
+      }
+
+      const content = fs.readFileSync(filePath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      console.error(`Error reading file ${filePath}:`, error);
+      return {};
+    }
+  }
+
+  _writeFile(filePath, data) {
+    try {
+      const directory = path.dirname(filePath);
+      if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory, { recursive: true });
+      }
+
+      fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+    } catch (error) {
+      console.error(`Error writing file ${filePath}:`, error);
+      throw error;
+    }
+  }
+}
+
+module.exports = CloudFrontStore;

package/src/services/cloudshell/env-builder.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * Builds the environment variables for a CloudShell PTY session.
+ * Includes AWS credentials and endpoint URLs for all active services.
+ *
+ * @param {Function} getActiveServices - returns array of { name, port }
+ * @returns {Object} environment variables object
+ */
+function buildShellEnvironment(getActiveServices) {
+  const env = {
+    ...process.env,
+    AWS_ACCESS_KEY_ID: 'local-access-key',
+    AWS_SECRET_ACCESS_KEY: 'local-secret-key',
+    AWS_DEFAULT_REGION: 'us-east-1',
+  };
+
+  const services = getActiveServices();
+  for (const { name, port } of services) {
+    const envKey = `AWS_ENDPOINT_${name.toUpperCase().replace(/-/g, '_')}`;
+    env[envKey] = `http://localhost:${port}`;
+  }
+
+  return env;
+}
+
+module.exports = { buildShellEnvironment };

package/src/services/cloudshell/index.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const path = require('path');
+const express = require('express');
+
+/**
+ * Initializes CloudShell: registers routes, sets up WebSocket server,
+ * and hooks into the server lifecycle.
+ *
+ * If node-pty is not available (e.g., native compilation failed),
+ * logs a warning and returns a no-op shutdown handle.
+ *
+ * @param {import('express').Application} app - Management API Express app
+ * @param {import('http').Server} httpServer - the underlying HTTP server
+ * @param {Function} getActiveServices - function to query active services
+ * @returns {{ shutdown: Function }} cleanup handle
+ */
+function initializeCloudShell(app, httpServer, getActiveServices) {
+  try {
+    // Attempt to load node-pty to verify it's available
+    require('node-pty');
+  } catch (err) {
+    console.warn('CloudShell: node-pty not available, feature disabled');
+    return { shutdown: () => {} };
+  }
+
+  const { SessionManager } = require('./session-manager');
+  const { createWebSocketServer } = require('./websocket-handler');
+  const { registerRoutes } = require('./routes');
+
+  // Instantiate session manager
+  const sessionManager = new SessionManager();
+
+  // Register REST API routes
+  registerRoutes(app, sessionManager, getActiveServices);
+
+  // Set up WebSocket server
+  createWebSocketServer(httpServer, sessionManager);
+
+  // Serve static files (frontend) at /cloudshell
+  app.use('/cloudshell', express.static(path.join(__dirname, 'static')));
+
+  return {
+    shutdown: () => sessionManager.destroyAll(),
+  };
+}
+
+module.exports = { initializeCloudShell };

package/src/services/cloudshell/routes.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const { buildShellEnvironment } = require('./env-builder');
+
+/**
+ * Registers CloudShell REST API routes on the Express app.
+ *
+ * @param {import('express').Application} app - the Management API Express app
+ * @param {import('./session-manager').SessionManager} sessionManager - session manager instance
+ * @param {Function} getActiveServices - function returning active services and ports
+ */
+function registerRoutes(app, sessionManager, getActiveServices) {
+  /**
+   * GET /__admin/cloudshell/sessions
+   * Returns all active sessions with IDs and creation timestamps.
+   */
+  app.get('/__admin/cloudshell/sessions', (req, res) => {
+    console.log('CloudShell: GET /sessions received');
+    const sessions = sessionManager.listSessions();
+    res.json({ sessions });
+  });
+
+  /**
+   * POST /__admin/cloudshell/sessions
+   * Creates a new CloudShell session with pre-configured environment.
+   * Returns 201 with { id, createdAt } on success.
+   * Returns 500 with { error } if PTY spawn fails.
+   */
+  app.post('/__admin/cloudshell/sessions', (req, res) => {
+    console.log('CloudShell: POST /sessions received');
+    try {
+      const env = buildShellEnvironment(getActiveServices);
+      console.log('CloudShell: Environment built, creating session...');
+      const session = sessionManager.createSession(env);
+      console.log('CloudShell: Session created:', session.id);
+      res.status(201).json({ id: session.id, createdAt: session.createdAt });
+    } catch (err) {
+      console.error('CloudShell: Failed to create session:', err.message);
+      res.status(500).json({ error: 'Failed to create session: ' + err.message });
+    }
+  });
+
+  /**
+   * DELETE /__admin/cloudshell/sessions/:id
+   * Terminates a specific session.
+   * Returns 200 on success, 404 if session not found.
+   */
+  app.delete('/__admin/cloudshell/sessions/:id', (req, res) => {
+    const { id } = req.params;
+    const destroyed = sessionManager.destroySession(id);
+
+    if (destroyed) {
+      res.status(200).json({});
+    } else {
+      res.status(404).json({ error: 'Session not found' });
+    }
+  });
+}
+
+module.exports = { registerRoutes };

package/src/services/cloudshell/session-manager.js

@@ -0,0 +1,226 @@
+'use strict';
+
+const pty = require('node-pty');
+const { v4: uuidv4 } = require('uuid');
+
+/**
+ * Returns the default shell for the current platform.
+ * @returns {string} shell executable path or name
+ */
+function getDefaultShell() {
+  if (process.platform === 'win32') {
+    return 'powershell.exe';
+  }
+  return process.env.SHELL || '/bin/bash';
+}
+
+/**
+ * @typedef {Object} Session
+ * @property {string} id - UUID v4 session identifier
+ * @property {import('node-pty').IPty} pty - node-pty process instance
+ * @property {import('ws').WebSocket|null} ws - currently attached WebSocket (null if disconnected)
+ * @property {string} createdAt - ISO timestamp of session creation
+ */
+
+/**
+ * Manages the lifecycle of CloudShell terminal sessions.
+ * Stores sessions in an in-memory Map<string, Session>.
+ */
+class SessionManager {
+  constructor() {
+    /** @type {Map<string, Session>} */
+    this.sessions = new Map();
+  }
+
+  /**
+   * Creates a new PTY session with pre-configured environment.
+   * @param {Object} env - environment variables to inject into the PTY process
+   * @returns {Session} the newly created session
+   */
+  createSession(env) {
+    const shell = getDefaultShell();
+    const id = uuidv4();
+
+    let ptyProcess;
+    try {
+      ptyProcess = pty.spawn(shell, [], {
+        name: 'xterm-256color',
+        cols: 80,
+        rows: 24,
+        cwd: process.cwd(),
+        env: env,
+      });
+    } catch (err) {
+      throw new Error(`Failed to spawn PTY (${shell}): ${err.message}`);
+    }
+
+    const session = {
+      id,
+      pty: ptyProcess,
+      ws: null,
+      createdAt: new Date().toISOString(),
+    };
+
+    // Handle unexpected PTY exit to clean up session
+    ptyProcess.onExit(({ exitCode, signal }) => {
+      // Only clean up if session still exists (wasn't explicitly destroyed)
+      if (this.sessions.has(id)) {
+        const s = this.sessions.get(id);
+        if (s && s.ws) {
+          try {
+            s.ws.close(1011, 'PTY process exited');
+          } catch (e) { /* ignore */ }
+        }
+        this.sessions.delete(id);
+      }
+    });
+
+    this.sessions.set(id, session);
+    return session;
+  }
+
+  /**
+   * Returns a session by ID, or undefined if not found.
+   * @param {string} id - session ID
+   * @returns {Session|undefined}
+   */
+  getSession(id) {
+    return this.sessions.get(id);
+  }
+
+  /**
+   * Lists all active sessions.
+   * @returns {Array<{id: string, createdAt: string}>}
+   */
+  listSessions() {
+    const result = [];
+    for (const session of this.sessions.values()) {
+      result.push({ id: session.id, createdAt: session.createdAt });
+    }
+    return result;
+  }
+
+  /**
+   * Terminates a session: kills PTY, closes WebSocket, removes from map.
+   * @param {string} id - session ID to destroy
+   * @returns {boolean} true if session existed and was terminated
+   */
+  destroySession(id) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      return false;
+    }
+
+    try {
+      session.pty.kill();
+    } catch (err) {
+      // PTY may already be dead; ignore
+    }
+
+    if (session.ws) {
+      try {
+        session.ws.close(1011, 'Session terminated');
+      } catch (err) {
+        // WebSocket may already be closed; ignore
+      }
+      session.ws = null;
+    }
+
+    this.sessions.delete(id);
+    return true;
+  }
+
+  /**
+   * Terminates all sessions. Called on server shutdown.
+   */
+  destroyAll() {
+    for (const id of this.sessions.keys()) {
+      this.destroySession(id);
+    }
+  }
+
+  /**
+   * Attaches a WebSocket to an existing session and pipes PTY output to WS.
+   * @param {string} id - session ID
+   * @param {import('ws').WebSocket} ws - WebSocket connection to attach
+   * @returns {boolean} true if session exists and was attached
+   */
+  attachWebSocket(id, ws) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      return false;
+    }
+
+    // Detach any previously attached WebSocket
+    if (session.ws) {
+      try {
+        session.ws.close(1000, 'Replaced by new connection');
+      } catch (err) {
+        // ignore
+      }
+    }
+
+    session.ws = ws;
+
+    // Pipe PTY output to WebSocket
+    const dataListener = session.pty.onData((data) => {
+      if (session.ws && session.ws.readyState === 1) { // WebSocket.OPEN === 1
+        session.ws.send(data);
+      }
+    });
+
+    // Clean up listener when WebSocket closes
+    ws.on('close', () => {
+      dataListener.dispose();
+      if (session.ws === ws) {
+        session.ws = null;
+      }
+    });
+
+    return true;
+  }
+
+  /**
+   * Detaches the WebSocket from a session (keeps PTY alive).
+   * @param {string} id - session ID
+   */
+  detachWebSocket(id) {
+    const session = this.sessions.get(id);
+    if (!session || !session.ws) {
+      return;
+    }
+
+    try {
+      session.ws.close(1000, 'Detached');
+    } catch (err) {
+      // ignore
+    }
+    session.ws = null;
+  }
+
+  /**
+   * Resizes the PTY for a given session. Ignores invalid (≤0) values.
+   * @param {string} id - session ID
+   * @param {number} cols - new column count
+   * @param {number} rows - new row count
+   */
+  resizeSession(id, cols, rows) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      return;
+    }
+
+    // Ignore invalid dimensions
+    if (!cols || !rows || cols <= 0 || rows <= 0) {
+      return;
+    }
+
+    try {
+      session.pty.resize(cols, rows);
+    } catch (err) {
+      // PTY may have exited; ignore resize errors
+    }
+  }
+}
+
+module.exports = { SessionManager, getDefaultShell };