moontraze 2.0.6 → 2.0.8

package/lib/deploy.js

@@ -6,6 +6,72 @@ const chalk = require('chalk');
 const { getConfig, getProject } = require('./config');
 const { zipCwd } = require('./zip');
 
+/**
+ * Job status poll + Vercel-style gray progress
+ */
+async function waitForDeployJob({ apiUrl, token, jobId }) {
+  const start = Date.now();
+  const timeoutMs = 15 * 60 * 1000; // 15 min
+  let lastMessage = '';
+
+  const printProgress = (msg) => {
+    if (!msg || msg === lastMessage) return;
+    lastMessage = msg;
+    process.stdout.write('\r\x1b[K' + chalk.gray('  ' + msg));
+  };
+
+  printProgress('Queued...');
+
+  while (Date.now() - start < timeoutMs) {
+    await new Promise((r) => setTimeout(r, 1500));
+
+    let data = {};
+    try {
+      const res = await fetch(
+        `${apiUrl}/api/hosting/deployments/job/${encodeURIComponent(jobId)}`,
+        { headers: { Authorization: `Bearer ${token}` } }
+      );
+      data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        throw new Error(data.error || `Status check failed (${res.status})`);
+      }
+    } catch (e) {
+      printProgress('Checking status...');
+      continue;
+    }
+
+    const state = data.state;
+    const progress = data.progress;
+    let message = 'Working...';
+
+    if (typeof progress === 'object' && progress?.message) {
+      message = progress.message;
+    } else if (typeof progress === 'number') {
+      message = `Building... ${progress}%`;
+    } else if (state === 'waiting' || state === 'delayed') {
+      message = 'Queued — waiting for worker...';
+    } else if (state === 'active') {
+      message = 'Building...';
+    } else if (state === 'completed') {
+      message = 'Done';
+    }
+
+    printProgress(message);
+
+    if (state === 'completed') {
+      process.stdout.write('\n');
+      return data.result || {};
+    }
+    if (state === 'failed') {
+      process.stdout.write('\n');
+      throw new Error(data.error || 'Deploy failed');
+    }
+  }
+
+  process.stdout.write('\n');
+  throw new Error('Deploy timed out. Check dashboard or try again.');
+}
+
 async function deploy({
   prod = true,
   projectName,
@@ -13,21 +79,19 @@ async function deploy({
   domain: domainArg,
 } = {}) {
   const cfg = getConfig();
-
   const api =
     apiUrlArg ||
     process.env.MOON_API ||
     cfg.apiUrl ||
     'https://api.moontraze.com';
-
   const domain =
     domainArg ||
     process.env.MOON_DOMAIN ||
     cfg.domain ||
     'moontraze.com';
-
   const token = cfg.token || process.env.MOON_TOKEN || null;
-  const label = process.env.MOON_LABEL || process.env.MOON_PLATFORM || 'Moontraze';
+  const label =
+    process.env.MOON_LABEL || process.env.MOON_PLATFORM || 'Moontraze';
 
   if (!token) {
     throw new Error(
@@ -38,7 +102,10 @@ async function deploy({
   const linked = getProject();
   const name = (projectName || linked?.projectName || '')
     .toLowerCase()
-    .replace(/[^a-z0-9-]/g, '');
+    .trim()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
 
   if (!name || name.length < 3) {
     throw new Error(
@@ -50,8 +117,6 @@ async function deploy({
   console.log(chalk.cyan(label));
   console.log(`  API      ${api}`);
   console.log(`  Project  ${name}`);
-  console.log(`  Target   https://${name}.${domain}`);
-  console.log('');
 
   const spinner = ora('Packaging...').start();
   const t0 = Date.now();
@@ -61,22 +126,47 @@ async function deploy({
     zipPath = await zipCwd();
     const mb = (fs.statSync(zipPath).size / 1024 / 1024).toFixed(2);
 
+    // -------- Check if project already exists --------
     spinner.text = 'Checking project...';
     let alreadyExists = false;
+    let existingUrl = null;
+    let hostLabel = null;
 
     try {
-      const statusRes = await fetch(`${api}/api/hosting/status/${name}`, {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-      if (statusRes.ok) {
-        const statusData = await statusRes.json();
-        alreadyExists = !!statusData.exists;
+      const statusRes = await fetch(
+        `${api}/api/hosting/status/${encodeURIComponent(name)}`,
+        { headers: { Authorization: `Bearer ${token}` } }
+      );
+      const statusData = await statusRes.json().catch(() => ({}));
+
+      // exists true = deployed / building / failed (status API fix ke baad)
+      if (statusRes.ok && statusData.exists) {
+        alreadyExists = true;
+        existingUrl = statusData.primaryUrl || statusData.url || null;
+        hostLabel = statusData.hostLabel || null;
       }
     } catch (_) {
-      // assume new
+      // network fail → backend khud decide karega
     }
 
-    spinner.text = `Uploading (${mb} MB)...`;
+    // Target URL dikhao
+    const previewUrl =
+      existingUrl ||
+      (hostLabel
+        ? `https://${hostLabel}.${domain}`
+        : `https://${name}.${domain}`);
+    spinner.stop();
+    console.log(`  Target   ${previewUrl}`);
+    console.log(
+      chalk.gray(
+        alreadyExists
+          ? '  Mode     Redeploy (existing project)'
+          : '  Mode     New deploy'
+      )
+    );
+    console.log('');
+
+    spinner.start(`Uploading (${mb} MB)...`);
 
     const form = new FormData();
     form.append('projectName', name);
@@ -84,12 +174,10 @@ async function deploy({
       filename: `${name}.zip`,
       contentType: 'application/zip',
     });
+    // Backend bhi force-redeploy karta hai agar same name exist kare
     form.append('redeploy', alreadyExists ? 'true' : 'false');
 
-    const endpoint = alreadyExists
-      ? `${api}/api/hosting/redeploy`
-      : `${api}/api/hosting/deploy`;
-
+    const endpoint = `${api}/api/hosting/deploy`;
     const res = await fetch(endpoint, {
       method: 'POST',
       headers: {
@@ -107,23 +195,62 @@ async function deploy({
       data = { error: text };
     }
 
-    const sec = ((Date.now() - t0) / 1000).toFixed(1);
+    // ---------- Queued flow ----------
+    if (res.status === 202 && data.jobId) {
+      spinner.stop();
+      console.log(chalk.gray('  Upload done — build starting...'));
+      console.log('');
 
+      const result = await waitForDeployJob({
+        apiUrl: api,
+        token,
+        jobId: data.jobId,
+      });
+
+      const sec = ((Date.now() - t0) / 1000).toFixed(1);
+      const url =
+        result?.url ||
+        existingUrl ||
+        data.url ||
+        `https://${name}.${domain}`;
+
+      const wasRedeploy =
+        alreadyExists || data.redeploy === true || result?.redeploy === true;
+
+      console.log('');
+      console.log(chalk.green(`  Production  ${url}`));
+      if (result?.version || data.deployment?.version) {
+        console.log(
+          chalk.gray(
+            `  Version     ${result?.version || data.deployment?.version}`
+          )
+        );
+      }
+      console.log(chalk.gray(`  Time        ${sec}s`));
+      console.log(chalk.green(wasRedeploy ? '✓ Redeployed' : '✓ Deployed'));
+      console.log('');
+      return result;
+    }
+
+    // ---------- Sync fallback ----------
+    const sec = ((Date.now() - t0) / 1000).toFixed(1);
     if (!res.ok) {
       spinner.fail(`Failed (${sec}s)`);
       throw new Error(data.error || `HTTP ${res.status}`);
     }
 
     spinner.succeed(`Ready in ${sec}s`);
-
-    const url = data.url || `https://${name}.${domain}`;
+    const url = data.url || existingUrl || `https://${name}.${domain}`;
     console.log('');
     console.log(chalk.green(`  Production  ${url}`));
     if (data.deployment?.version) {
       console.log(chalk.gray(`  Version     ${data.deployment.version}`));
     }
-    console.log(chalk.green(alreadyExists ? '✓ Redeployed' : '✓ Deployed'));
+    console.log(
+      chalk.green(alreadyExists || data.redeploy ? '✓ Redeployed' : '✓ Deployed')
+    );
     console.log('');
+    return data;
   } finally {
     if (zipPath && fs.existsSync(zipPath)) {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moontraze",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "Deploy to Moontraze hosting",
   "main": "./bin/moontraze.js",
   "bin": {