cloud-ide-cide 2.0.34

package/serverInit.js

@@ -0,0 +1,665 @@
+/**
+ * cide server-init — scaffold .cide/ folder, install listener, manage Node background process.
+ *
+ * Commands:
+ *   cide server-init                  — interactive setup (scaffold + install + start for Node)
+ *   cide server-init --type php|node  — non-interactive type
+ *   cide server-init --path /var/www  — non-interactive path
+ *   cide server-init --start          — start the Node listener (background)
+ *   cide server-init --stop           — stop the Node listener
+ *   cide server-init --status         — check if Node listener is running
+ *   cide server-init --restart        — restart the Node listener
+ *
+ * Shell:
+ *   server init              — interactive setup
+ *   server start             — start Node listener
+ *   server stop              — stop Node listener
+ *   server status            — check listener status
+ *   server restart            — restart listener
+ *
+ * Server folder structure:
+ *
+ *   {server_root}/
+ *     .cide/
+ *       config.json           ← token, server type, pid, port
+ *       deployments.json      ← current + history per app
+ *       scripts/              ← listener script + deps
+ *       releases/{app}/{ver}/ ← extracted code per version
+ *       backups/{app}/{ver}.zip
+ *       logs/
+ *         deploy.log          ← upload/rollback audit log
+ *         server.log          ← Node listener stdout/stderr
+ *         server.pid          ← PID of running Node listener
+ *     current/{app}           ← symlink → active release
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const crypto = require('crypto');
+const { execSync, spawn } = require('child_process');
+
+const PHP_SCRIPT_NAME = 'upload-ui.php';
+const NODE_SCRIPT_NAME = 'upload-api.js';
+
+function getDeployerSourceDir() {
+  // Scripts are bundled inside the CLI package at deployer/
+  const bundledPath = path.join(__dirname, 'deployer');
+  if (fs.existsSync(bundledPath)) return bundledPath;
+  return null;
+}
+
+function askQuestion(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+
+function generateToken() {
+  return crypto.randomBytes(32).toString('hex');
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function safeReadJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
+}
+
+/**
+ * Find cide.json in cwd or parent directories.
+ */
+function findCideJson() {
+  let d = path.resolve(process.cwd());
+  for (let i = 0; i < 10; i++) {
+    const p = path.join(d, 'cide.json');
+    if (fs.existsSync(p)) return p;
+    const parent = path.dirname(d);
+    if (parent === d) break;
+    d = parent;
+  }
+  return null;
+}
+
+/**
+ * Auto-detect server type from cide.json in cwd or parent directories.
+ */
+function detectServerType() {
+  let d = path.resolve(process.cwd());
+  for (let i = 0; i < 10; i++) {
+    const cj = safeReadJson(path.join(d, 'cide.json'));
+    if (cj) {
+      const tmpl = (cj.templete || cj.template || '').toLowerCase();
+      if (tmpl === 'angular' || tmpl === 'react') return { type: 'php', template: tmpl, name: cj.name };
+      if (tmpl === 'node') return { type: 'node', template: tmpl, name: cj.name };
+    }
+    const parent = path.dirname(d);
+    if (parent === d) break;
+    d = parent;
+  }
+  return null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ── Node listener process management ──────────────────────────────────────────
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Find the .cide/ folder — walk up from cwd looking for .cide/config.json.
+ */
+function findCideDir() {
+  let d = path.resolve(process.cwd());
+  for (let i = 0; i < 10; i++) {
+    const candidate = path.join(d, '.cide', 'config.json');
+    if (fs.existsSync(candidate)) return path.join(d, '.cide');
+    const parent = path.dirname(d);
+    if (parent === d) break;
+    d = parent;
+  }
+  return null;
+}
+
+function getPidFile(cideDir) {
+  return path.join(cideDir, 'logs', 'server.pid');
+}
+
+function getServerLog(cideDir) {
+  return path.join(cideDir, 'logs', 'server.log');
+}
+
+function readPid(cideDir) {
+  const pidFile = getPidFile(cideDir);
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0); // signal 0 = just check if alive
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function startNodeListener(cideDir) {
+  const config = safeReadJson(path.join(cideDir, 'config.json'));
+  if (!config) {
+    console.error('  No config.json found. Run: cide server-init');
+    return false;
+  }
+  if (config.serverType !== 'node') {
+    console.error('  This is a PHP server — no background process needed.');
+    console.error('  PHP runs via Apache/Nginx automatically.');
+    return false;
+  }
+
+  // Check if already running
+  const existingPid = readPid(cideDir);
+  if (existingPid && isProcessRunning(existingPid)) {
+    console.log(`  Listener already running (PID: ${existingPid})`);
+    return true;
+  }
+
+  const scriptsDir = config.paths?.scripts || path.join(cideDir, 'scripts');
+  const scriptPath = path.join(scriptsDir, NODE_SCRIPT_NAME);
+
+  if (!fs.existsSync(scriptPath)) {
+    console.error(`  Listener script not found: ${scriptPath}`);
+    console.error('  Run: cide server-init');
+    return false;
+  }
+
+  // Check node_modules
+  if (!fs.existsSync(path.join(scriptsDir, 'node_modules'))) {
+    console.log('  Installing dependencies...');
+    try {
+      execSync('npm install', { cwd: scriptsDir, stdio: 'inherit', shell: true });
+    } catch (e) {
+      console.error('  npm install failed:', e.message);
+      return false;
+    }
+  }
+
+  const logFile = getServerLog(cideDir);
+  ensureDir(path.dirname(logFile));
+  const out = fs.openSync(logFile, 'a');
+  const err = fs.openSync(logFile, 'a');
+
+  const port = config.port || 4500;
+  const env = {
+    ...process.env,
+    CIDE_UPLOAD_TOKEN: config.token || '',
+    CIDE_UPLOAD_PORT: String(port),
+    CIDE_UPLOAD_BASE_PATH: cideDir,
+  };
+
+  const child = spawn('node', [scriptPath], {
+    cwd: scriptsDir,
+    env,
+    detached: true,
+    stdio: ['ignore', out, err],
+  });
+
+  child.unref();
+
+  // Save PID
+  const pidFile = getPidFile(cideDir);
+  fs.writeFileSync(pidFile, String(child.pid));
+
+  console.log(`  Listener started (PID: ${child.pid}, port: ${port})`);
+  console.log(`  Log: ${logFile}`);
+  return true;
+}
+
+function stopNodeListener(cideDir) {
+  const pid = readPid(cideDir);
+  if (!pid) {
+    console.log('  No listener PID found. Not running.');
+    return;
+  }
+
+  if (!isProcessRunning(pid)) {
+    console.log(`  PID ${pid} is not running (stale). Cleaning up.`);
+    try { fs.unlinkSync(getPidFile(cideDir)); } catch {}
+    return;
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    console.log(`  Listener stopped (PID: ${pid})`);
+  } catch (e) {
+    console.error(`  Failed to stop PID ${pid}: ${e.message}`);
+
+    // Try harder on Windows
+    try {
+      execSync(`taskkill /PID ${pid} /F`, { stdio: 'ignore', shell: true });
+      console.log(`  Force-killed PID ${pid}`);
+    } catch {
+      console.error(`  Could not kill PID ${pid}. Stop it manually.`);
+    }
+  }
+
+  try { fs.unlinkSync(getPidFile(cideDir)); } catch {}
+}
+
+function listenerStatus(cideDir) {
+  const config = safeReadJson(path.join(cideDir, 'config.json'));
+  if (!config) {
+    console.log('  No .cide/config.json found.');
+    return;
+  }
+
+  console.log('');
+  console.log(`  Server type : ${config.serverType}`);
+  console.log(`  Server root : ${config.serverRoot}`);
+  console.log(`  Port        : ${config.port || 4500}`);
+
+  if (config.serverType === 'php') {
+    console.log('  Status      : PHP runs via Apache/Nginx (no background process)');
+  } else {
+    const pid = readPid(cideDir);
+    if (pid && isProcessRunning(pid)) {
+      console.log(`  Status      : Running (PID: ${pid})`);
+    } else {
+      console.log('  Status      : Stopped');
+      if (pid) {
+        console.log(`  (Stale PID file: ${pid})`);
+        try { fs.unlinkSync(getPidFile(cideDir)); } catch {}
+      }
+    }
+    console.log(`  Log         : ${getServerLog(cideDir)}`);
+  }
+  console.log('');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ── Main server-init ──────────────────────────────────────────────────────────
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function serverInit(opts = {}) {
+  // ── Sub-commands: start / stop / status / restart ─────────────────────
+  if (opts.start || opts.stop || opts.status || opts.restart) {
+    const cideDir = findCideDir();
+    if (!cideDir) {
+      console.error('  No .cide/ folder found. Run: cide server-init first.');
+      process.exitCode = 1;
+      return;
+    }
+
+    if (opts.status) {
+      listenerStatus(cideDir);
+      return;
+    }
+    if (opts.stop) {
+      stopNodeListener(cideDir);
+      return;
+    }
+    if (opts.restart) {
+      stopNodeListener(cideDir);
+      startNodeListener(cideDir);
+      return;
+    }
+    if (opts.start) {
+      startNodeListener(cideDir);
+      return;
+    }
+    return;
+  }
+
+  // ── Full init flow ────────────────────────────────────────────────────
+  const deployerDir = getDeployerSourceDir();
+  if (!deployerDir) {
+    console.error('Could not find deployer scripts. The CLI package is missing the deployer/ folder.');
+    process.exitCode = 1;
+    return;
+  }
+
+  const rl = opts.readlineInterface || readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const ownRl = !opts.readlineInterface;
+
+  try {
+    // ── Step 1: Server type ─────────────────────────────────────────────
+    console.log('');
+    console.log('  Cloud IDE — Server Init');
+    console.log('  ─────────────────────────────────────────');
+    console.log('  Which server are you setting up?');
+    console.log('');
+    console.log('  [1]  PHP server  (for UI — Angular/React apps served by Apache/Nginx)');
+    console.log('  [2]  Node server (for API — Node.js apps served by Express/PM2)');
+    console.log('');
+
+    let serverType = opts.type || '';
+    if (!serverType) {
+      const answer = await askQuestion(rl, '  Select (1 or 2): ');
+      if (answer === '1' || answer.toLowerCase() === 'php') {
+        serverType = 'php';
+      } else if (answer === '2' || answer.toLowerCase() === 'node') {
+        serverType = 'node';
+      } else {
+        console.error(`  Invalid selection: "${answer}"`);
+        return;
+      }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════
+    // PHP flow — generate setup.php, user pastes on server, CLI calls it
+    // ═══════════════════════════════════════════════════════════════════
+    if (serverType === 'php') {
+      const setupSrc = path.join(deployerDir, 'php', 'setup.php');
+      if (!fs.existsSync(setupSrc)) {
+        console.error('  setup.php not found in CLI package.');
+        return;
+      }
+
+      // Save setup.php locally
+      const outputPath = path.join(process.cwd(), 'setup.php');
+      fs.copyFileSync(setupSrc, outputPath);
+
+      console.log('');
+      console.log(`  setup.php generated at: ${outputPath}`);
+      console.log('');
+      console.log('  Paste this file on your PHP server root');
+      console.log('  (the folder where your site is served from)');
+      console.log('');
+
+      // Wait for user to paste it
+      const pasted = await askQuestion(rl, '  Did you paste setup.php on the server? (yes/no): ');
+      if (pasted.toLowerCase() !== 'yes' && pasted.toLowerCase() !== 'y') {
+        console.log('  Setup paused. Paste setup.php on the server and run cide server-init again.');
+        return;
+      }
+
+      // Ask for the server URL where they pasted it
+      const serverUrl = await askQuestion(rl, '  Server URL where you pasted (e.g. https://ui.example.com): ');
+      if (!serverUrl) {
+        console.error('  Server URL is required.');
+        return;
+      }
+
+      // Call setup.php?token=CREATE on the server
+      const setupUrl = `${serverUrl.replace(/\/+$/, '')}/setup.php?token=CREATE`;
+      console.log(`\n  Calling: ${setupUrl}`);
+
+      let setupResult;
+      try {
+        const axios = require('axios');
+        const resp = await axios.get(setupUrl, { timeout: 30000 });
+        setupResult = resp.data;
+      } catch (err) {
+        const msg = err.response?.data?.message || err.message;
+        console.error(`\n  Failed to reach setup.php: ${msg}`);
+        console.error('  Make sure the file is accessible and try again.');
+        return;
+      }
+
+      if (setupResult.status !== 'SUCCESS') {
+        console.error(`\n  Setup failed: ${setupResult.message || JSON.stringify(setupResult)}`);
+        return;
+      }
+
+      console.log('  Server setup complete!');
+      console.log(`  Token: ${setupResult.token}`);
+      console.log('');
+
+      // Ask for build path and app code
+      const buildPath = await askQuestion(rl, '  Build path (e.g. dist/cloud-ide-lms-ui/browser): ');
+      const appCode = await askQuestion(rl, '  App code (e.g. cloud-ide-lms-ui): ');
+      const serverName = await askQuestion(rl, '  Server name (e.g. Production, Staging): ');
+
+      // Build the upload listener URL from setup response
+      const scriptUrl = `${serverUrl.replace(/\/+$/, '')}/.cide/scripts/upload-ui.php`;
+
+      // Auto-read environment.ts and host-manager.json
+      const cideJsonPath = findCideJson();
+      let envBlock = {};
+      let hostsBlock = {};
+      if (cideJsonPath) {
+        const projectDir = path.dirname(cideJsonPath);
+        const { findEnvFile, findHostManagerFile, parseExistingEnv } = require('./uploadProject');
+
+        const envFile = findEnvFile(projectDir);
+        if (envFile) {
+          envBlock = parseExistingEnv(fs.readFileSync(envFile, 'utf8'));
+          console.log(`\n  Read environment from: ${envFile}`);
+          Object.entries(envBlock).forEach(([k, v]) => console.log(`    ${k}: ${v}`));
+        }
+
+        const hostFile = findHostManagerFile(projectDir);
+        if (hostFile) {
+          try {
+            const hostJson = JSON.parse(fs.readFileSync(hostFile, 'utf8'));
+            if (Array.isArray(hostJson.hosts)) {
+              for (const h of hostJson.hosts) {
+                if (h.url) hostsBlock[h.url] = h.replace || '';
+              }
+            }
+            console.log(`  Read hosts from: ${hostFile}`);
+            Object.entries(hostsBlock).forEach(([k, v]) => console.log(`    ${k} → ${v}`));
+          } catch { /* skip */ }
+        }
+
+        if (Object.keys(envBlock).length || Object.keys(hostsBlock).length) {
+          console.log('  (Edit "env" and "hosts" in cide.json to set server-specific values)\n');
+        }
+      }
+
+      // Update local cide.json
+      if (cideJsonPath) {
+        const cj = safeReadJson(cideJsonPath);
+        if (cj) {
+          const newEntry = {
+            name: serverName || 'Production',
+            server_url: scriptUrl,
+            build_path: buildPath || 'dist',
+            app_code: appCode || cj.name || '',
+            token: setupResult.token,
+            env: envBlock,
+            hosts: hostsBlock,
+          };
+
+          // Normalize existing upload to array
+          let uploadArr = [];
+          if (Array.isArray(cj.upload)) {
+            uploadArr = cj.upload;
+          } else if (cj.upload && cj.upload.server_url) {
+            uploadArr = [cj.upload];
+          }
+          uploadArr.push(newEntry);
+          cj.upload = uploadArr;
+
+          fs.writeFileSync(cideJsonPath, JSON.stringify(cj, null, 4) + '\n');
+          console.log(`\n  Updated: ${cideJsonPath}`);
+          console.log(`  Added server: ${serverName || 'Production'} → ${scriptUrl}`);
+        }
+      } else {
+        console.log('\n  No cide.json found in current project.');
+        console.log('  Add this to your cide.json upload array:');
+        console.log(JSON.stringify({
+          name: serverName || 'Production',
+          server_url: scriptUrl,
+          build_path: buildPath || 'dist',
+          app_code: appCode || 'your-app',
+          token: setupResult.token,
+        }, null, 4));
+      }
+
+      console.log('');
+      if (setupResult.setupFileDeleted) {
+        console.log('  setup.php auto-deleted from server.');
+      } else {
+        console.log('  Note: Could not auto-delete setup.php. Remove it manually from the server.');
+      }
+      console.log('');
+      console.log('  Ready! Run: cide upload');
+      console.log('');
+
+      // Clean up local setup.php
+      try { fs.unlinkSync(outputPath); } catch {}
+
+      return;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════
+    // Node flow — scaffold locally, install, auto-start
+    // ═══════════════════════════════════════════════════════════════════
+    let serverRoot = opts.path || '';
+    if (!serverRoot) {
+      serverRoot = await askQuestion(rl, `  Server root directory [${process.cwd()}]: `);
+      if (!serverRoot) serverRoot = process.cwd();
+    }
+    serverRoot = path.resolve(serverRoot);
+
+    let port = 4500;
+    const portAnswer = await askQuestion(rl, '  Listener port [4500]: ');
+    if (portAnswer) {
+      const p = parseInt(portAnswer, 10);
+      if (!isNaN(p) && p > 0 && p < 65536) port = p;
+    }
+
+    const cideDir     = path.join(serverRoot, '.cide');
+    const scriptsDir  = path.join(cideDir, 'scripts');
+    const releasesDir = path.join(cideDir, 'releases');
+    const backupsDir  = path.join(cideDir, 'backups');
+    const logsDir     = path.join(cideDir, 'logs');
+    const currentDir  = path.join(serverRoot, 'current');
+
+    ensureDir(scriptsDir);
+    ensureDir(releasesDir);
+    ensureDir(backupsDir);
+    ensureDir(logsDir);
+    ensureDir(currentDir);
+
+    const configPath = path.join(cideDir, 'config.json');
+    const existingConfig = safeReadJson(configPath);
+    const token = existingConfig?.token || generateToken();
+
+    const config = {
+      serverType,
+      token,
+      port,
+      serverRoot,
+      createdAt: existingConfig?.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      paths: {
+        scripts: scriptsDir,
+        releases: releasesDir,
+        backups: backupsDir,
+        logs: logsDir,
+        current: currentDir,
+      },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+
+    const deploymentsPath = path.join(cideDir, 'deployments.json');
+    if (!fs.existsSync(deploymentsPath)) {
+      fs.writeFileSync(deploymentsPath, JSON.stringify({ apps: {} }, null, 2) + '\n');
+    }
+
+    const logPath = path.join(logsDir, 'deploy.log');
+    if (!fs.existsSync(logPath)) {
+      fs.writeFileSync(logPath, `# Cloud IDE deploy log — created ${new Date().toISOString()}\n`);
+    }
+
+    {
+      const src = path.join(deployerDir, 'node', NODE_SCRIPT_NAME);
+      if (!fs.existsSync(src)) {
+        console.error(`  Source script not found: ${src}`);
+        return;
+      }
+      fs.copyFileSync(src, path.join(scriptsDir, NODE_SCRIPT_NAME));
+
+      // package.json
+      const pkgPath = path.join(scriptsDir, 'package.json');
+      if (!fs.existsSync(pkgPath)) {
+        fs.writeFileSync(pkgPath, JSON.stringify({
+          name: 'cide-upload-api',
+          version: '1.0.0',
+          private: true,
+          scripts: { start: `node ${NODE_SCRIPT_NAME}` },
+          dependencies: {
+            express: '^4.18.0',
+            multer: '^1.4.5-lts.1',
+            'adm-zip': '^0.5.10',
+          },
+        }, null, 2) + '\n');
+      }
+
+      // npm install
+      console.log('\n  Installing Node dependencies...');
+      try {
+        execSync('npm install', { cwd: scriptsDir, stdio: 'inherit', shell: true });
+      } catch (e) {
+        console.error('  npm install failed. Run manually: cd ' + scriptsDir + ' && npm install');
+      }
+
+      // Auto-start the listener
+      console.log('');
+      startNodeListener(cideDir);
+    }
+
+    // ── Print Node summary ─────────────────────────────────────────────
+    console.log('');
+    console.log('  ─── Node Setup Complete ───');
+    console.log('');
+    console.log('  Server folder layout:');
+    console.log(`    ${serverRoot}/`);
+    console.log(`    ├── .cide/`);
+    console.log(`    │   ├── config.json          ← token, type, port`);
+    console.log(`    │   ├── deployments.json      ← current + history per app`);
+    console.log(`    │   ├── scripts/              ← listener script`);
+    console.log(`    │   ├── releases/{app}/{ver}/  ← extracted code`);
+    console.log(`    │   ├── backups/{app}/{ver}.zip ← upload backups`);
+    console.log(`    │   └── logs/`);
+    console.log(`    │       ├── deploy.log        ← deploy audit log`);
+    console.log(`    │       ├── server.log        ← listener output`);
+    console.log(`    │       └── server.pid        ← listener PID`);
+    console.log(`    └── current/{app}/            ← symlink → active release`);
+
+    console.log('');
+    console.log(`  Token: ${token}`);
+    if (existingConfig?.token === token) {
+      console.log('  (Existing token preserved)');
+    } else {
+      console.log('  (Save this token — it will not be shown again)');
+    }
+
+    console.log('');
+    console.log('  Node listener is running in background.');
+    console.log('');
+    console.log('  Manage it with:');
+    console.log('    cide server-init --status   ← check if running');
+    console.log('    cide server-init --stop     ← stop listener');
+    console.log('    cide server-init --start    ← start listener');
+    console.log('    cide server-init --restart  ← restart listener');
+
+    console.log('');
+    console.log('  In your project cide.json, add to the "upload" array:');
+    console.log('    "upload": [');
+    console.log('      {');
+    console.log(`        "name": "Production API",`);
+    console.log(`        "server_url": "https://your-server.com:${port}/upload",`);
+    console.log('        "build_path": "dist/your-project-name",');
+    console.log('        "app_code": "your-project-name",');
+    console.log(`        "token": "${token}"`);
+    console.log('      }');
+    console.log('    ]');
+    console.log('');
+  } finally {
+    if (ownRl) rl.close();
+  }
+}
+
+module.exports = serverInit;
+module.exports.findCideDir = findCideDir;
+module.exports.startNodeListener = startNodeListener;
+module.exports.stopNodeListener = stopNodeListener;
+module.exports.listenerStatus = listenerStatus;