shoplazza-cli 1.0.13 → 1.1.1

package/lib/app/services/devServer/tunnel/providers/cloudflare.js

@@ -0,0 +1,364 @@
+const { exec, spawn } = require('child_process');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+// Cloudflare版本配置
+const CLOUDFLARE_VERSION = '2024.8.2';
+const CLOUDFLARE_BASE_URL = `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARE_VERSION}`;
+
+// 不同平台和架构的二进制文件映射配置
+const PLATFORM_CONFIGS = {
+  linux: {
+    x64: 'cloudflared-linux-amd64',
+    arm64: 'cloudflared-linux-arm64',
+    arm: 'cloudflared-linux-arm',
+    ia32: 'cloudflared-linux-386'
+  },
+  darwin: {
+    x64: 'cloudflared-darwin-amd64.tgz',
+    arm64: 'cloudflared-darwin-arm64.tgz'
+  },
+  win32: {
+    x64: 'cloudflared-windows-amd64.exe',
+    ia32: 'cloudflared-windows-386.exe',
+    arm64: 'cloudflared-windows-amd64.exe'
+  }
+};
+
+// 根据当前系统平台和架构获取cloudflared二进制文件的下载URL
+function getDownloadUrl() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const platformConfig = PLATFORM_CONFIGS[platform];
+  if (!platformConfig) {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  const filename = platformConfig[arch];
+  if (!filename) {
+    throw new Error(`Unsupported architecture: ${platform}-${arch}`);
+  }
+
+  return {
+    url: `${CLOUDFLARE_BASE_URL}/${filename}`,
+    filename,
+    isCompressed: filename.endsWith('.tgz')
+  };
+}
+
+// 获取cloudflared二进制文件的本地存储路径
+function getBinaryPath() {
+  const platform = os.platform();
+  const extension = platform === 'win32' ? '.exe' : '';
+  const cloudflaredDir = path.join(process.env.APP_PROJECT_DIR, 'bin', 'cloudflared');
+
+  // 检查路径状态并确保目录存在
+  try {
+    const stat = fs.statSync(cloudflaredDir);
+    if (!stat.isDirectory()) {
+      console.log('⚠️  Removing conflicting file at cloudflared directory path...');
+      fs.unlinkSync(cloudflaredDir);
+      fs.mkdirSync(cloudflaredDir, { recursive: true });
+    }
+    // 如果已经是目录，无需处理
+  } catch (error) {
+    // 路径不存在，直接创建目录
+    fs.mkdirSync(cloudflaredDir, { recursive: true });
+  }
+
+  return path.join(cloudflaredDir, `cloudflared${extension}`);
+}
+
+// 比较两个版本号，返回值：>0表示versionA更新，<0表示versionB更新，=0表示相同
+function compareVersions(versionA, versionB) {
+  const parseVersion = (v) => v.split('.').map(Number);
+  const [majorA, minorA, patchA] = parseVersion(versionA);
+  const [majorB, minorB, patchB] = parseVersion(versionB);
+
+  if (majorA !== majorB) return majorA - majorB;
+  if (minorA !== minorB) return minorA - minorB;
+  return patchA - patchB;
+}
+
+// 检查本地cloudflared版本是否满足要求
+async function checkVersion(binaryPath) {
+  return new Promise((resolve) => {
+    // 如果二进制文件不存在，返回false
+    if (!fs.existsSync(binaryPath)) return resolve(false);
+
+    // 执行version命令获取当前版本
+    exec(`"${binaryPath}" --version`, (error, stdout) => {
+      if (error) return resolve(false);
+      const versionMatch = stdout.match(/cloudflared version (\d+\.\d+\.\d+)/);
+      if (versionMatch) {
+        const currentVersion = versionMatch[1];
+        const needsUpdate = compareVersions(CLOUDFLARE_VERSION, currentVersion) > 0;
+        console.log(`Current version: ${currentVersion}, Target version: ${CLOUDFLARE_VERSION}`);
+        resolve(!needsUpdate);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+
+// 下载文件，支持总体10秒下载时长限制和HTTP重定向处理
+async function downloadFile(url, destination) {
+  return new Promise(async (resolve, reject) => {
+    console.log(`📥 Downloading: ${path.basename(url)}`);
+
+    const file = fs.createWriteStream(destination);
+    let isFinished = false;
+
+    // 设置总体下载时长限制：10秒，不管下载速度如何
+    const downloadTimeoutId = setTimeout(() => {
+      if (!isFinished) {
+        isFinished = true;
+        request.destroy();
+        file.close();
+        if (fs.existsSync(destination)) fs.unlinkSync(destination);
+        reject(new Error('Download took too long'));
+      }
+    }, 10000);
+
+    const request = https.get(url, (response) => {
+      // 处理HTTP重定向
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        const redirectUrl = response.headers.location;
+        if (redirectUrl) {
+          clearTimeout(downloadTimeoutId);
+          file.close();
+          if (fs.existsSync(destination)) fs.unlinkSync(destination);
+          // 修复异步错误处理
+          downloadFile(redirectUrl, destination)
+            .then(() => resolve())
+            .catch((error) => reject(error));
+          return;
+        }
+      }
+
+      // 检查HTTP状态码
+      if (response.statusCode !== 200) {
+        clearTimeout(downloadTimeoutId);
+        file.close();
+        if (fs.existsSync(destination)) fs.unlinkSync(destination);
+        return reject(new Error(`Download failed: HTTP ${response.statusCode}`));
+      }
+
+      // 将响应数据写入文件
+      response.pipe(file);
+
+      file.on('finish', () => {
+        if (!isFinished) {
+          isFinished = true;
+          clearTimeout(downloadTimeoutId);
+          file.close();
+          console.log('✅ Download completed');
+          resolve();
+        }
+      });
+
+      file.on('error', (err) => {
+        if (!isFinished) {
+          isFinished = true;
+          clearTimeout(downloadTimeoutId);
+          file.close();
+          if (fs.existsSync(destination)) fs.unlinkSync(destination);
+          reject(err);
+        }
+      });
+    });
+
+    // 处理请求错误
+    request.on('error', (err) => {
+      if (!isFinished) {
+        isFinished = true;
+        clearTimeout(downloadTimeoutId);
+        file.close();
+        if (fs.existsSync(destination)) fs.unlinkSync(destination);
+        reject(err);
+      }
+    });
+
+    // 设置请求超时（服务器无响应）：5秒
+    request.setTimeout(5000, () => {
+      if (!isFinished) {
+        request.destroy();
+      }
+    });
+  });
+}
+
+// 解压tgz文件（仅macOS平台的cloudflared需要解压）
+async function extractTgz(tgzPath, extractDir) {
+  return new Promise((resolve, reject) => {
+    console.log('📦 Extracting file...');
+    const filename = path.basename(tgzPath);
+    exec(`tar -xzf "${filename}"`, { cwd: extractDir }, (error) => {
+      if (error) return reject(new Error(`Extraction failed: ${error.message}`));
+      console.log('✅ Extraction completed');
+      resolve();
+    });
+  });
+}
+
+// 安装cloudflared（如果不存在或版本过低）
+async function installCloudflared() {
+  console.log('🔍 Checking cloudflared...');
+  const binaryPath = getBinaryPath();
+
+  // 检查现有版本是否满足要求
+  if (await checkVersion(binaryPath)) {
+    console.log('✅ cloudflared is already at target version or higher');
+    return; // 成功时不需要返回值
+  }
+
+  console.log('🔄 Installing cloudflared...');
+  try {
+    const { url, filename, isCompressed } = getDownloadUrl();
+    const platform = os.platform();
+
+    // macOS平台需要解压tgz文件
+    if (isCompressed && platform === 'darwin') {
+      const tgzPath = path.join(path.dirname(binaryPath), filename);
+      await downloadFile(url, tgzPath);
+      await extractTgz(tgzPath, path.dirname(binaryPath));
+      const extractedPath = path.join(path.dirname(binaryPath), 'cloudflared');
+      if (fs.existsSync(extractedPath)) fs.renameSync(extractedPath, binaryPath);
+      if (fs.existsSync(tgzPath)) fs.unlinkSync(tgzPath);
+    } else {
+      // Linux直接下载二进制文件
+      await downloadFile(url, binaryPath);
+    }
+
+    // 为非Windows平台设置可执行权限
+    if (platform !== 'win32') {
+      fs.chmodSync(binaryPath, '755');
+    }
+
+    // 验证安装是否成功
+    const isWorking = await new Promise((resolve) => {
+      exec(`"${binaryPath}" --version`, (error) => resolve(!error));
+    });
+
+    if (isWorking) {
+      console.log('✅ cloudflared installed successfully!');
+      return; // 成功时不需要返回值
+    }
+    throw new Error('Installation verification failed');
+  } catch (error) {
+    console.error('❌ Installation failed:', error.message);
+    // 抛出具体错误而不是返回false，这样上层能获得具体的失败原因
+    throw new Error(`cloudflared installation failed: ${error.message}`);
+  }
+}
+
+// 启动Cloudflare Quick Tunnel，返回包含url和close方法的对象
+async function startQuickTunnel(port) {
+  console.log('🚀 Starting Cloudflare Tunnel...');
+
+  const binaryPath = getBinaryPath();
+  // 启动cloudflared进程，创建快速隧道
+  const tunnel = spawn(binaryPath, ['tunnel', '--url', `http://localhost:${port}`, '--no-autoupdate'], {
+    stdio: 'pipe'
+  });
+
+  let tunnelUrl = null;
+
+  // 设置10秒超时
+  const timeout = setTimeout(() => {
+    if (!tunnelUrl) {
+      console.error('❌ Tunnel startup timeout');
+      try {
+        tunnel.kill();
+      } catch {}
+    }
+  }, 10000);
+
+  // 从cloudflared输出中解析隧道URL
+  const tryParse = (buf) => {
+    const output = String(buf);
+    const match = output.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
+    if (match && !tunnelUrl) {
+      tunnelUrl = match[0];
+    }
+  };
+
+  // 监听标准输出和错误输出
+  tunnel.stdout.on('data', tryParse);
+  tunnel.stderr.on('data', tryParse);
+
+  return await new Promise((resolve, reject) => {
+    const finishIfReady = () => {
+      if (tunnelUrl) {
+        clearTimeout(timeout);
+        resolve({
+          url: tunnelUrl,
+          close: () => {
+            try {
+              tunnel.kill('SIGTERM');
+            } catch {}
+          }
+        });
+      }
+    };
+
+    // 监听隧道进程事件
+    tunnel.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`Tunnel process error: ${err.message}`));
+    });
+    tunnel.on('close', (code) => {
+      clearTimeout(timeout);
+      if (!tunnelUrl) return reject(new Error(`Tunnel exited with code=${code}`));
+    });
+
+    // 每100ms检查一次隧道URL是否获取到
+    const iv = setInterval(() => {
+      if (tunnelUrl) {
+        clearInterval(iv);
+        finishIfReady();
+      }
+    }, 100);
+
+    // 兜底：31秒后停止轮询
+    setTimeout(() => {
+      clearInterval(iv);
+      if (!tunnelUrl) {
+        reject(new Error('Tunnel not ready'));
+      }
+    }, 31000);
+  });
+}
+
+// Cloudflare隧道管理类
+class CloudflareTunnel {
+  constructor(port) {
+    this.port = port;
+    this._closer = null;
+  }
+
+  // 安装cloudflared（如果需要）并启动Quick Tunnel
+  async start() {
+    // installCloudflared现在会直接抛出错误，不需要检查返回值
+    await installCloudflared();
+    const { url, close } = await startQuickTunnel(this.port);
+    this._closer = close;
+    return { url, close };
+  }
+
+  // 关闭隧道
+  async close() {
+    if (this._closer) {
+      try {
+        await this._closer();
+      } catch {}
+      this._closer = null;
+    }
+  }
+}
+
+module.exports = CloudflareTunnel;

package/lib/app/services/devServer/tunnel/providers/ngrok.js

@@ -0,0 +1,70 @@
+const ngrok = require('@ngrok/ngrok');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const path = require('path');
+const { writeEnvWithDotenv } = require('../../../../utils/env');
+
+module.exports = class NgrokTunnel {
+  constructor(port, token, domain) {
+    this.port = port;
+    this.token = token;
+    this.domain = domain;
+  }
+
+  async start() {
+    if (!this.token) {
+      console.log(
+        `\nGet your ngrok token from ${chalk.underline.green('https://dashboard.ngrok.com/get-started/your-authtoken')}`
+      );
+
+      const token = await inquirer
+        .prompt({
+          type: 'input',
+          name: 'token',
+          message: 'Please input your ngrok token:',
+          validate: (value) => {
+            return value.trim() !== '' ? true : "NGROK_AUTHTOKEN can't be empty";
+          }
+        })
+        .then((r) => r.token);
+
+      this.token = token;
+    }
+
+    if (!this.domain) {
+      console.log(
+        `\nGet your ngrok domain from ${chalk.underline.green('https://dashboard.ngrok.com/domains')}`
+      );
+
+      const domain = await inquirer
+        .prompt({
+          type: 'input',
+          name: 'domain',
+          message: 'Please input your ngrok domain:'
+        })
+        .then((r) => r.domain);
+      this.domain = domain;
+    }
+
+    // 存储 token（创建或更新 .env，而不覆盖其它键）
+    await writeEnvWithDotenv(path.join(process.cwd(), '.env'), {
+      NGROK_AUTHTOKEN: this.token,
+      NGROK_DOMAIN: this.domain
+    });
+
+    const listener = await ngrok
+      .forward({
+        addr: this.port,
+        authtoken: this.token,
+        domain: this.domain
+      })
+      .catch((err) => {
+        throw err;
+      });
+
+    return {
+      url: listener.url(),
+      close: () => listener.close()
+    };
+  }
+};

package/lib/app/services/devServer/utils/index.js

@@ -0,0 +1,5 @@
+const secureCompare = require('./secureCompare');
+
+module.exports = {
+  secureCompare
+};

package/lib/app/services/devServer/utils/secureCompare.js

@@ -0,0 +1,5 @@
+const crypto = require('crypto');
+
+module.exports = function secureCompare(a, b) {
+  return crypto.timingSafeEqual(Buffer.from(a), Buffer.from(b));
+};

package/lib/app/services/devServer/views/app.ejs

@@ -0,0 +1,133 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Shoplazza Dev Server</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif;
+            background: linear-gradient(135deg, #f5f5f5 0%, #e8e8e8 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: #333;
+            line-height: 1.6;
+        }
+        
+        .container {
+            background: rgba(255, 255, 255, 0.95);
+            backdrop-filter: blur(20px);
+            border-radius: 20px;
+            padding: 3rem 2.5rem;
+            text-align: center;
+            max-width: 500px;
+            width: 90%;
+            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
+            border: 1px solid rgba(255, 255, 255, 0.2);
+        }
+        
+        .logo {
+            width: 80px;
+            height: 80px;
+            background: linear-gradient(135deg, #e53e3e, #c53030);
+            border-radius: 20px;
+            margin: 0 auto 2rem;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 2rem;
+            font-weight: bold;
+            color: white;
+            text-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+        }
+        
+        h1 {
+            font-size: 2.2rem;
+            margin-bottom: 1rem;
+            background: linear-gradient(135deg, #e53e3e, #c53030);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            font-weight: 700;
+            letter-spacing: -0.5px;
+        }
+        
+        p {
+            font-size: 1.1rem;
+            color: #666;
+            margin-bottom: 2rem;
+            opacity: 0.8;
+        }
+        
+        .status {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.5rem;
+            background: #e8f5e8;
+            color: #2e7d2e;
+            padding: 0.6rem 1.2rem;
+            border-radius: 50px;
+            font-size: 0.9rem;
+            font-weight: 500;
+            border: 1px solid #c3e6c3;
+        }
+        
+        .status-dot {
+            width: 8px;
+            height: 8px;
+            background: #4ade80;
+            border-radius: 50%;
+            animation: pulse 2s infinite;
+        }
+        
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.5; }
+        }
+        
+        .footer {
+            margin-top: 2rem;
+            font-size: 0.85rem;
+            color: #999;
+            opacity: 0.7;
+        }
+        
+        @media (max-width: 480px) {
+            .container {
+                padding: 2rem 1.5rem;
+                margin: 1rem;
+            }
+            
+            h1 {
+                font-size: 1.8rem;
+            }
+            
+            p {
+                font-size: 1rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="logo">S</div>
+        <h1>Welcome to Shoplazza</h1>
+        <p>Development server is running smoothly</p>
+        <div class="status">
+            <div class="status-dot"></div>
+            Server Active
+        </div>
+        <div class="footer">
+            Ready to build amazing apps
+        </div>
+    </div>
+</body>
+</html>

package/lib/app/services/extension-build/buildCheckout.js

@@ -0,0 +1,47 @@
+const path = require('path');
+const { build } = require('vite');
+const { vitePluginAddExtensionId } = require('./plugins/vite-plugin-add-extension-id');
+const { vitePluginTransformExtensionHtml } = require('./plugins/vite-plugin-transform-extension-html');
+
+async function buildCheckout(extension) {
+  // build checkout extension
+  const extensionDir = path.dirname(extension.configPath);
+
+  // entry file
+  const entryFile = path.join(extensionDir, 'src', 'index.js');
+
+  // outputDir
+  const outputDir = path.join(extensionDir, '..', '..', 'app-deploy');
+
+  const pageEntry = { [extension.extension_name]: entryFile };
+
+  const res = await build({
+    plugins: [vitePluginTransformExtensionHtml(), vitePluginAddExtensionId(extension.extension_name)],
+    root: path.dirname(entryFile),
+    build: {
+      minify: false,
+      emptyOutDir: false,
+      copyPublicDir: false,
+      rollupOptions: {
+        input: pageEntry,
+        output: {
+          entryFileNames: '[name].[hash].js',
+          chunkFileNames: '[name].[hash].js',
+          assetFileNames: '[name].[hash].[ext]',
+          compact: true,
+          inlineDynamicImports: false,
+          dir: outputDir
+        }
+      }
+    }
+  });
+
+  // 返回打包后的文件路径
+  const outputFile = path.join(outputDir, res.output[0].fileName);
+
+  return outputFile;
+}
+
+module.exports = {
+  buildCheckout
+};

package/lib/app/services/extension-build/buildFunction.js

@@ -0,0 +1,57 @@
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+const { getLibPath } = require('../../bin');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execPromise = promisify(exec);
+
+function hashFileStream(filePath, algorithm = 'md5') {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash(algorithm);
+    const stream = fs.createReadStream(filePath);
+
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+async function buildFunction(extension) {
+  // build function extension
+  const extensionDir = path.dirname(extension.configPath);
+
+  // entry file
+  const entryFile = path.join(extensionDir, 'src', 'index.js');
+
+  // entry file hash
+  const entryFileHash = await hashFileStream(entryFile);
+
+  // output file
+  const outputFile = path.join(
+    extensionDir,
+    '..',
+    '..',
+    'app-deploy',
+    `${extension.extension_name}.${entryFileHash}.wasm`
+  );
+
+  // javy path
+  const javyPath = getLibPath('javy');
+
+  try {
+    const { stderr } = await execPromise(`"${javyPath}" build "${entryFile}" -o "${outputFile}"`);
+    if (stderr) {
+      throw new Error(stderr);
+    }
+  } catch (err) {
+    throw err;
+  }
+
+  return outputFile;
+}
+
+module.exports = {
+  buildFunction
+};