cloud-ide-cide 2.0.34

package/uploadProject.js

@@ -0,0 +1,727 @@
+/**
+ * cide upload — zip a project's build output and upload it to a deployment server.
+ *
+ * cide.json "upload" config — array of servers:
+ *   {
+ *     "upload": [
+ *       {
+ *         "name": "Production",
+ *         "server_url": "https://prod.example.com/.cide/scripts/upload-ui.php",
+ *         "build_path": "dist/my-app",
+ *         "app_code":   "my-app",
+ *         "token":      "secret",
+ *         "env": {
+ *           "production": true,
+ *           "apiUrl": "https://api.example.com/api"
+ *         }
+ *       },
+ *       {
+ *         "name": "Staging",
+ *         "server_url": "https://staging.example.com/.cide/scripts/upload-ui.php",
+ *         "build_path": "dist/my-app",
+ *         "app_code":   "my-app",
+ *         "token":      "secret2",
+ *         "env": {
+ *           "production": false,
+ *           "apiUrl": "https://staging-api.example.com/api"
+ *         }
+ *       }
+ *     ]
+ *   }
+ *
+ * Single object format still supported (backward compatible):
+ *   "upload": { "server_url": "...", ... }
+ *
+ * Usage:
+ *   cide upload              — list projects, pick one, pick server, upload
+ *   cide upload -p 1         — upload project #1 (asks which server if multiple)
+ *   cide upload --list       — list uploadable projects and their servers
+ *   cide upload --history    — show deployment history
+ *   cide upload --rollback   — rollback to a previous version
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { execSync } = require('child_process');
+const AdmZip = require('adm-zip');
+const axios = require('axios');
+const FormData = require('form-data');
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function safeReadJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
+}
+
+function askQuestion(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+
+function getToken(server) {
+  return server.token || process.env.CIDE_UPLOAD_TOKEN || '';
+}
+
+function getAuthHeaders(token) {
+  return { Authorization: `Bearer ${token}` };
+}
+
+/**
+ * Normalize upload config — always returns an array of server configs.
+ * Supports both old single-object and new array format.
+ */
+function normalizeUploadConfig(upload) {
+  if (!upload) return [];
+  if (Array.isArray(upload)) return upload.filter((s) => s && s.server_url);
+  // Single object (backward compat)
+  if (upload.server_url) return [upload];
+  return [];
+}
+
+/**
+ * Resolve endpoint URL for history/rollback.
+ * PHP uses ?action= param, Node uses /history or /rollback route.
+ */
+function resolveEndpoint(serverUrl, action) {
+  const u = new URL(serverUrl);
+  if (u.pathname.endsWith('.php')) {
+    u.searchParams.set('action', action);
+    return u.toString();
+  }
+  const base = u.pathname.replace(/\/upload\/?$/, '');
+  u.pathname = `${base}/${action}`;
+  return u.toString();
+}
+
+// ── Environment swap & build ──────────────────────────────────────────────────
+
+/**
+ * Find environment.ts in the project (src/environments/environment.ts).
+ */
+function findEnvFile(projectAbsPath) {
+  const candidates = [
+    path.join(projectAbsPath, 'src', 'environments', 'environment.ts'),
+    path.join(projectAbsPath, 'src', 'environment', 'environment.ts'),
+  ];
+  return candidates.find((p) => fs.existsSync(p)) || null;
+}
+
+/**
+ * Find host-manager.json in the project (public/routes/host-manager.json).
+ */
+function findHostManagerFile(projectAbsPath) {
+  const p = path.join(projectAbsPath, 'public', 'routes', 'host-manager.json');
+  return fs.existsSync(p) ? p : null;
+}
+
+/**
+ * Replace a variable's value in environment.ts content, preserving structure.
+ * Handles: string ('...'), number, boolean values.
+ *
+ *   mapEnvValue(content, 'apiUrl', 'https://api.example.com')
+ *   turns:  apiUrl: 'http://localhost:3000/api',
+ *   into:   apiUrl: 'https://api.example.com',
+ */
+function mapEnvValue(content, key, newValue) {
+  // Match:  key: 'old'  or  key: "old"  or  key: true  or  key: 123
+  const pattern = new RegExp(
+    `(\\b${key}\\s*:\\s*)(?:'[^']*'|"[^"]*"|\\d+(?:\\.\\d+)?|true|false)`,
+  );
+  if (!pattern.test(content)) return content;
+  const replacement = typeof newValue === 'string' ? `$1'${newValue}'` : `$1${newValue}`;
+  return content.replace(pattern, replacement);
+}
+
+/**
+ * Resolve a hosts value — if it starts with "env." read from the env config.
+ *   "env.apiUrl" → value of env.apiUrl from the server config
+ *   plain URL    → use as-is
+ */
+function resolveHostValue(value, envConfig) {
+  if (typeof value === 'string' && value.startsWith('env.')) {
+    const envKey = value.slice(4); // "env.apiUrl" → "apiUrl"
+    return envConfig && envConfig[envKey] != null ? String(envConfig[envKey]) : value;
+  }
+  return value;
+}
+
+/**
+ * Map env values into environment.ts (in-place per variable),
+ * map hosts into host-manager.json (resolving env. references),
+ * build, then restore both files. Returns true on success.
+ *
+ * cide.json server entry:
+ *   "env":   { "production": true, "apiUrl": "https://api.example.com" }
+ *   "hosts": { "__cloud_ide_suite_layout__": "env.apiUrl" }
+ *                                             ^^^ resolved from env block
+ */
+function buildWithEnv(project, server) {
+  const envFile = findEnvFile(project.absPath);
+  const hostFile = findHostManagerFile(project.absPath);
+  const serverEnv = server.env;
+  const serverHosts = server.hosts;
+  let originalEnv = null;
+  let originalHosts = null;
+
+  // ── Map values into environment.ts (in-place) ────────────────────────
+  if (envFile && serverEnv && Object.keys(serverEnv).length > 0) {
+    originalEnv = fs.readFileSync(envFile, 'utf8');
+    let content = originalEnv;
+    for (const [key, value] of Object.entries(serverEnv)) {
+      content = mapEnvValue(content, key, value);
+    }
+    fs.writeFileSync(envFile, content);
+    console.log(`  Environment mapped: ${path.relative(project.absPath, envFile)}`);
+    Object.entries(serverEnv).forEach(([k, v]) => console.log(`    ${k} → ${v}`));
+  }
+
+  // ── Map values into host-manager.json ─────────────────────────────────
+  if (hostFile && serverHosts && Object.keys(serverHosts).length > 0) {
+    originalHosts = fs.readFileSync(hostFile, 'utf8');
+    const hostJson = JSON.parse(originalHosts);
+    if (Array.isArray(hostJson.hosts)) {
+      for (const entry of hostJson.hosts) {
+        if (entry.url && serverHosts[entry.url] != null) {
+          entry.replace = resolveHostValue(serverHosts[entry.url], serverEnv);
+        }
+      }
+    }
+    fs.writeFileSync(hostFile, JSON.stringify(hostJson, null, 4) + '\n');
+    console.log(`  Hosts mapped: ${path.relative(project.absPath, hostFile)}`);
+    for (const [k, v] of Object.entries(serverHosts)) {
+      const resolved = resolveHostValue(v, serverEnv);
+      console.log(`    ${k} → ${resolved}${v !== resolved ? ` (from ${v})` : ''}`);
+    }
+  }
+
+  try {
+    const cj = project.cideJson;
+    const tmpl = (cj.templete || cj.template || '').toLowerCase();
+
+    if (tmpl === 'angular') {
+      console.log('  Building Angular project...');
+      execSync('ng build', { cwd: project.absPath, stdio: 'inherit', shell: true });
+    } else if (tmpl === 'react') {
+      console.log('  Building React project...');
+      execSync('npm run build', { cwd: project.absPath, stdio: 'inherit', shell: true });
+    } else if (tmpl === 'node') {
+      console.log('  Building Node project...');
+      execSync('npm run build', { cwd: project.absPath, stdio: 'inherit', shell: true });
+    } else {
+      console.log('  Building project...');
+      execSync('npm run build', { cwd: project.absPath, stdio: 'inherit', shell: true });
+    }
+
+    console.log('  Build complete.');
+    return true;
+  } catch (err) {
+    console.error(`  Build failed: ${err.message}`);
+    return false;
+  } finally {
+    // Always restore both files
+    if (originalEnv !== null && envFile) {
+      fs.writeFileSync(envFile, originalEnv);
+      console.log('  Environment restored.');
+    }
+    if (originalHosts !== null && hostFile) {
+      fs.writeFileSync(hostFile, originalHosts);
+      console.log('  Hosts restored.');
+    }
+  }
+}
+
+/**
+ * Parse existing environment.ts to extract key-value pairs.
+ * Simple parser — handles string, number, boolean values.
+ */
+function parseExistingEnv(content) {
+  const env = {};
+  const regex = /(\w+)\s*:\s*(?:'([^']*)'|"([^"]*)"|(\d+(?:\.\d+)?)|(\btrue\b|\bfalse\b))/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const key = match[1];
+    if (match[2] !== undefined) env[key] = match[2];
+    else if (match[3] !== undefined) env[key] = match[3];
+    else if (match[4] !== undefined) env[key] = Number(match[4]);
+    else if (match[5] !== undefined) env[key] = match[5] === 'true';
+  }
+  return env;
+}
+
+// ── Discover projects ─────────────────────────────────────────────────────────
+
+/**
+ * Walk up from cwd and scan siblings for cide.json files with upload config.
+ * Returns [{ name, absPath, cideJson, servers: [...] }]
+ */
+function discoverUploadableProjects() {
+  const cwd = path.resolve(process.cwd());
+  const visited = new Set();
+  const projects = [];
+
+  function tryDir(dir) {
+    if (visited.has(dir)) return;
+    visited.add(dir);
+    const cj = safeReadJson(path.join(dir, 'cide.json'));
+    if (!cj || !cj.upload) return;
+    const servers = normalizeUploadConfig(cj.upload);
+    if (servers.length === 0) return;
+    projects.push({
+      name: cj.name || path.basename(dir),
+      absPath: dir,
+      cideJson: cj,
+      servers,
+    });
+  }
+
+  tryDir(cwd);
+
+  let d = cwd;
+  for (let i = 0; i < 10; i++) {
+    const parent = path.dirname(d);
+    if (parent === d) break;
+    try {
+      const entries = fs.readdirSync(parent, { withFileTypes: true });
+      for (const e of entries) {
+        if (!e.isDirectory() || e.name === 'node_modules' || e.name.startsWith('.')) continue;
+        tryDir(path.resolve(parent, e.name));
+      }
+    } catch { /* skip */ }
+    d = parent;
+  }
+
+  return projects;
+}
+
+// ── List ──────────────────────────────────────────────────────────────────────
+
+function printProjectList(projects) {
+  if (projects.length === 0) {
+    console.log('\nNo projects found with upload config in cide.json.');
+    console.log('Add an "upload" array with at least one server entry to your cide.json.\n');
+    return;
+  }
+  console.log('\n  Uploadable projects:\n');
+  projects.forEach((p, i) => {
+    console.log(`  [${i + 1}]  ${p.name}`);
+    p.servers.forEach((s, si) => {
+      const buildPath = path.resolve(p.absPath, s.build_path || 'dist');
+      const exists = fs.existsSync(buildPath) ? '(built)' : '(not built)';
+      const label = s.name || `Server ${si + 1}`;
+      console.log(`       ${label}: ${s.server_url}  ${exists}`);
+    });
+    console.log('');
+  });
+}
+
+// ── Select project ────────────────────────────────────────────────────────────
+
+async function selectProject(projects, opts) {
+  if (opts.packages != null) {
+    const n = parseInt(String(opts.packages), 10);
+    if (isNaN(n) || n < 1 || n > projects.length) {
+      console.error(`Invalid selection: ${opts.packages}. Choose 1–${projects.length}.`);
+      return null;
+    }
+    return projects[n - 1];
+  }
+
+  const rl = opts.readlineInterface || readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const ownRl = !opts.readlineInterface;
+
+  try {
+    const answer = await askQuestion(rl, `  Select project (1–${projects.length}): `);
+    if (ownRl) rl.close();
+    const n = parseInt(answer, 10);
+    if (isNaN(n) || n < 1 || n > projects.length) {
+      console.error(`Invalid selection: "${answer}".`);
+      return null;
+    }
+    return projects[n - 1];
+  } catch {
+    if (ownRl) rl.close();
+    return null;
+  }
+}
+
+// ── Select server (when project has multiple) ─────────────────────────────────
+
+async function selectServer(project, opts) {
+  const servers = project.servers;
+
+  // Only one server — use it directly
+  if (servers.length === 1) return servers[0];
+
+  console.log(`\n  ${project.name} has ${servers.length} servers:\n`);
+  servers.forEach((s, i) => {
+    const label = s.name || s.server_url;
+    console.log(`    [${i + 1}]  ${label}`);
+    if (s.name) console.log(`          ${s.server_url}`);
+  });
+  console.log('');
+
+  // --server flag for non-interactive
+  if (opts.server != null) {
+    const n = parseInt(String(opts.server), 10);
+    if (!isNaN(n) && n >= 1 && n <= servers.length) return servers[n - 1];
+    // Try match by name
+    const match = servers.find((s) => (s.name || '').toLowerCase() === String(opts.server).toLowerCase());
+    if (match) return match;
+    console.error(`  Invalid server: "${opts.server}". Choose 1–${servers.length} or a server name.`);
+    return null;
+  }
+
+  const rl = opts.readlineInterface || readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const ownRl = !opts.readlineInterface;
+
+  try {
+    const answer = await askQuestion(rl, `  Select server (1–${servers.length}): `);
+    if (ownRl) rl.close();
+    const n = parseInt(answer, 10);
+    if (isNaN(n) || n < 1 || n > servers.length) {
+      console.error(`  Invalid selection: "${answer}".`);
+      return null;
+    }
+    return servers[n - 1];
+  } catch {
+    if (ownRl) rl.close();
+    return null;
+  }
+}
+
+// ── Zip ───────────────────────────────────────────────────────────────────────
+
+function zipBuildFolder(buildAbsPath) {
+  if (!fs.existsSync(buildAbsPath)) {
+    throw new Error(`Build path does not exist: ${buildAbsPath}\nRun the build first (cide build).`);
+  }
+  const zip = new AdmZip();
+  zip.addLocalFolder(buildAbsPath);
+  return zip.toBuffer();
+}
+
+// ── Upload ────────────────────────────────────────────────────────────────────
+
+async function uploadToServer(project, server, message) {
+  const buildAbsPath = path.resolve(project.absPath, server.build_path || 'dist');
+  const token = getToken(server);
+
+  if (!token) {
+    throw new Error(
+      'No upload token configured.\n' +
+      'Set "token" in the upload entry of cide.json, or set CIDE_UPLOAD_TOKEN env var.'
+    );
+  }
+
+  console.log(`\n  Zipping ${buildAbsPath} ...`);
+  const zipBuffer = zipBuildFolder(buildAbsPath);
+  const sizeMB = (zipBuffer.length / (1024 * 1024)).toFixed(2);
+  console.log(`  Zip size: ${sizeMB} MB`);
+
+  console.log(`  Uploading to ${server.server_url} ...`);
+
+  const form = new FormData();
+  form.append('file', zipBuffer, {
+    filename: `${server.app_code || project.name}.zip`,
+    contentType: 'application/zip',
+  });
+  form.append('appCode', server.app_code || project.name);
+  form.append('environment', server.environment || 'production');
+  if (message) form.append('message', message);
+
+  const response = await axios.post(server.server_url, form, {
+    headers: { ...form.getHeaders(), ...getAuthHeaders(token) },
+    maxContentLength: Infinity,
+    maxBodyLength: Infinity,
+    timeout: 5 * 60 * 1000,
+  });
+
+  return response.data;
+}
+
+// ── History ───────────────────────────────────────────────────────────────────
+
+async function fetchHistory(project, server) {
+  const token = getToken(server);
+  if (!token) throw new Error('No upload token configured.');
+
+  const appCode = server.app_code || project.name;
+  const url = resolveEndpoint(server.server_url, 'history');
+  const sep = url.includes('?') ? '&' : '?';
+
+  const response = await axios.get(`${url}${sep}appCode=${encodeURIComponent(appCode)}`, {
+    headers: getAuthHeaders(token),
+    timeout: 30000,
+  });
+
+  return response.data;
+}
+
+function printHistory(data) {
+  console.log('');
+  if (data.current) {
+    console.log('  Current active version:');
+    console.log(`    Version : ${data.current.version}`);
+    console.log(`    Deployed: ${data.current.deployedAt}`);
+    console.log(`    Action  : ${data.current.action}`);
+    if (data.current.message) console.log(`    Message : ${data.current.message}`);
+    if (data.current.previousVersion) {
+      console.log(`    Previous: ${data.current.previousVersion}`);
+    }
+  } else {
+    console.log('  No active deployment.');
+  }
+
+  console.log('');
+  console.log(`  Deployment history (${data.totalReleases || data.history?.length || 0} releases):`);
+  console.log('  ────────────────────────────────────────────────────');
+
+  const history = data.history || [];
+  const reversed = [...history].reverse();
+  reversed.forEach((entry, i) => {
+    const marker = data.current && entry.version === data.current.version && entry.deployedAt === data.current.deployedAt
+      ? ' ← active'
+      : '';
+    console.log(`  [${reversed.length - i}]  ${entry.version}  ${entry.action.padEnd(8)}  ${entry.deployedAt}${marker}`);
+    if (entry.message) console.log(`        ${entry.message}`);
+  });
+  console.log('');
+}
+
+// ── Rollback ──────────────────────────────────────────────────────────────────
+
+async function rollbackOnServer(project, server, version) {
+  const token = getToken(server);
+  if (!token) throw new Error('No upload token configured.');
+
+  const url = resolveEndpoint(server.server_url, 'rollback');
+  const appCode = server.app_code || project.name;
+
+  const response = await axios.post(url, { appCode, version }, {
+    headers: { 'Content-Type': 'application/json', ...getAuthHeaders(token) },
+    timeout: 60000,
+  });
+
+  return response.data;
+}
+
+// ── Main entry ────────────────────────────────────────────────────────────────
+
+async function uploadProject(opts = {}) {
+  const projects = discoverUploadableProjects();
+
+  // --list
+  if (opts.list) {
+    printProjectList(projects);
+    return;
+  }
+
+  if (projects.length === 0) {
+    printProjectList(projects);
+    return;
+  }
+
+  // --history
+  if (opts.history) {
+    printProjectList(projects);
+    const project = await selectProject(projects, opts);
+    if (!project) return;
+    const server = await selectServer(project, opts);
+    if (!server) return;
+    try {
+      const label = server.name || server.server_url;
+      console.log(`\n  Fetching history for: ${project.name} → ${label}`);
+      const data = await fetchHistory(project, server);
+      if (data.status !== 'SUCCESS') {
+        console.error(`  Failed: ${data.message || JSON.stringify(data)}`);
+        process.exitCode = 1;
+        return;
+      }
+      printHistory(data);
+    } catch (err) {
+      console.error(`\n  Failed: ${err.response?.data?.message || err.message}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  // --rollback
+  if (opts.rollback) {
+    printProjectList(projects);
+    const project = await selectProject(projects, opts);
+    if (!project) return;
+    const server = await selectServer(project, opts);
+    if (!server) return;
+
+    try {
+      const label = server.name || server.server_url;
+      console.log(`\n  Fetching history for: ${project.name} → ${label}`);
+      const data = await fetchHistory(project, server);
+      if (data.status !== 'SUCCESS') {
+        console.error(`  Failed: ${data.message || JSON.stringify(data)}`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const history = data.history || [];
+      if (history.length < 2) {
+        console.log('  No previous versions to roll back to.');
+        return;
+      }
+
+      printHistory(data);
+
+      const currentVer = data.current?.version;
+      const versions = [];
+      const seen = new Set();
+      for (const entry of [...history].reverse()) {
+        if (!seen.has(entry.version) && entry.version !== currentVer) {
+          seen.add(entry.version);
+          versions.push(entry.version);
+        }
+      }
+
+      if (versions.length === 0) {
+        console.log('  No other versions available to roll back to.');
+        return;
+      }
+
+      console.log('  Available rollback versions:');
+      versions.forEach((v, i) => console.log(`    [${i + 1}]  ${v}`));
+      console.log('');
+
+      let rollbackVersion;
+      if (typeof opts.rollback === 'string' && opts.rollback !== 'true' && opts.rollback !== '') {
+        rollbackVersion = opts.rollback;
+      } else {
+        const rl = opts.readlineInterface || readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+        const ownRl = !opts.readlineInterface;
+        try {
+          const answer = await askQuestion(rl, `  Select version to rollback to (1–${versions.length}): `);
+          if (ownRl) rl.close();
+          const n = parseInt(answer, 10);
+          if (isNaN(n) || n < 1 || n > versions.length) {
+            console.error(`  Invalid selection: "${answer}".`);
+            return;
+          }
+          rollbackVersion = versions[n - 1];
+        } catch {
+          if (ownRl) rl.close();
+          return;
+        }
+      }
+
+      console.log(`\n  Rolling back ${project.name} to version: ${rollbackVersion}`);
+      const result = await rollbackOnServer(project, server, rollbackVersion);
+
+      if (result.status === 'SUCCESS') {
+        console.log('  Rollback successful!');
+        console.log(`  Now active : ${result.rolledBackTo}`);
+        console.log(`  Previous   : ${result.previousVersion}`);
+        console.log('');
+      } else {
+        console.error(`  Rollback failed: ${result.message || JSON.stringify(result)}`);
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      console.error(`\n  Rollback failed: ${err.response?.data?.message || err.message}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  // Default: upload
+  printProjectList(projects);
+  const project = await selectProject(projects, opts);
+  if (!project) return;
+  const server = await selectServer(project, opts);
+  if (!server) return;
+
+  const label = server.name || server.server_url;
+
+  // Ask to build first (--build = yes, --no-build = skip, otherwise ask)
+  if (opts.build !== false) {
+    const rl = opts.readlineInterface || readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    const ownRl = !opts.readlineInterface;
+    let shouldBuild = opts.build === true;
+    if (!shouldBuild) {
+      try {
+        const answer = await askQuestion(rl, '  Build before upload? (Y/n): ');
+        shouldBuild = !answer || answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+      } catch { /* skip */ }
+    }
+    if (shouldBuild) {
+      console.log(`\n  Building for: ${label}`);
+      const ok = buildWithEnv(project, server);
+      if (!ok) {
+        console.error('  Build failed. Upload aborted.');
+        if (ownRl) rl.close();
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (ownRl) rl.close();
+  }
+
+  // Ask for deploy message (changelog)
+  let message = opts.message || '';
+  if (!message) {
+    const rl = opts.readlineInterface || readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    const ownRl = !opts.readlineInterface;
+    try {
+      message = await askQuestion(rl, '  Deploy message (changelog): ');
+      if (ownRl) rl.close();
+    } catch {
+      if (ownRl) rl.close();
+    }
+  }
+
+  console.log(`\n  Uploading: ${project.name} → ${label}`);
+
+  try {
+    const result = await uploadToServer(project, server, message);
+    console.log('');
+    if (result.status === 'SUCCESS') {
+      console.log('  Upload successful!');
+      console.log(`  Version  : ${result.releaseVersion}`);
+      console.log(`  App      : ${result.appCode}`);
+      console.log(`  Server   : ${label}`);
+      if (result.previousVersion) console.log(`  Previous : ${result.previousVersion}`);
+      if (result.releasePath) console.log(`  Path     : ${result.releasePath}`);
+      console.log('');
+    } else {
+      console.error(`  Upload failed: ${result.message || JSON.stringify(result)}`);
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    const msg = err.response?.data?.message || err.message || err;
+    console.error(`\n  Upload failed: ${msg}`);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = uploadProject;
+module.exports.discoverUploadableProjects = discoverUploadableProjects;
+module.exports.printProjectList = printProjectList;
+module.exports.findEnvFile = findEnvFile;
+module.exports.findHostManagerFile = findHostManagerFile;
+module.exports.parseExistingEnv = parseExistingEnv;
+module.exports.mapEnvValue = mapEnvValue;
+module.exports.resolveHostValue = resolveHostValue;