@oinone/cli 7.2.4 → 7.2.6

package/bin/commands/create/enterprise.js

@@ -0,0 +1,81 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { t } = require('../../i18n');
+const config = require('../../config');
+
+async function applyEnterpriseConfig({ targetPath, prefix, oinoneVersion, authToken, writeProjectCredential, newNpmrcPath, newGitignorePath }) {
+  const entConfig = config.getEnterpriseConfig(oinoneVersion);
+
+  if (entConfig.npmrc && entConfig.npmrc.uncommentRegistry && await fs.pathExists(newNpmrcPath)) {
+    let npmrcContent = await fs.readFile(newNpmrcPath, 'utf8');
+    npmrcContent = npmrcContent.replace(/#\s*(@oinone:registry=.*)/, '$1');
+    await fs.writeFile(newNpmrcPath, npmrcContent, 'utf8');
+  }
+
+  const bootPkgPath = path.join(targetPath, 'packages', `${prefix}-boot`, 'package.json');
+  if (await fs.pathExists(bootPkgPath)) {
+    const bootPkg = await fs.readJson(bootPkgPath);
+    if (!bootPkg.dependencies) bootPkg.dependencies = {};
+    Object.assign(bootPkg.dependencies, entConfig.packageJson.dependencies);
+
+    const sortedDeps = {};
+    Object.keys(bootPkg.dependencies).sort().forEach(key => {
+      sortedDeps[key] = bootPkg.dependencies[key];
+    });
+    bootPkg.dependencies = sortedDeps;
+
+    await fs.writeJson(bootPkgPath, bootPkg, { spaces: 2 });
+  }
+
+  const mainTsPath = path.join(targetPath, 'packages', `${prefix}-boot`, 'src', 'main.ts');
+  if (await fs.pathExists(mainTsPath)) {
+    let mainTsContent = await fs.readFile(mainTsPath, 'utf8');
+
+    if (entConfig.mainTs.cssImports && entConfig.mainTs.cssImports.length > 0) {
+      mainTsContent = mainTsContent.replace(
+        "import '@oinone/kunlun-vue-ui-el/dist/oinone-kunlun-vue-ui-el.css';",
+        "import '@oinone/kunlun-vue-ui-el/dist/oinone-kunlun-vue-ui-el.css';\n" + entConfig.mainTs.cssImports.join('\n') + "\n"
+      );
+    }
+
+    if (entConfig.mainTs.scriptImports && entConfig.mainTs.scriptImports.length > 0) {
+      mainTsContent = mainTsContent.replace(
+        "// 标准能力",
+        entConfig.mainTs.scriptImports.join('\n') + "\n// 标准能力"
+      );
+    }
+
+    if (entConfig.mainTs.components && entConfig.mainTs.components.length > 0) {
+      mainTsContent = mainTsContent.replace(
+        "kunlunVueUiEl: import('@oinone/kunlun-vue-ui-el'),",
+        "kunlunVueUiEl: import('@oinone/kunlun-vue-ui-el'),\n      " + entConfig.mainTs.components.join('\n      ')
+      );
+    }
+
+    await fs.writeFile(mainTsPath, mainTsContent, 'utf8');
+  }
+
+  if (authToken && writeProjectCredential) {
+    let npmrcContent = '';
+    if (await fs.pathExists(newNpmrcPath)) {
+      npmrcContent = await fs.readFile(newNpmrcPath, 'utf8');
+    }
+    npmrcContent += `\n//nexus.shushi.pro/repository/pamirs-releases/:_authToken=${authToken}`;
+    await fs.writeFile(newNpmrcPath, npmrcContent, 'utf8');
+
+    let gitignoreContent = '';
+    if (await fs.pathExists(newGitignorePath)) {
+      gitignoreContent = await fs.readFile(newGitignorePath, 'utf8');
+    }
+    if (!gitignoreContent.includes('\n.npmrc') && !gitignoreContent.includes('\n/.npmrc')) {
+      const suffix = gitignoreContent.endsWith('\n') || gitignoreContent === '' ? '' : '\n';
+      gitignoreContent += `${suffix}.npmrc\n`;
+      await fs.writeFile(newGitignorePath, gitignoreContent, 'utf8');
+    }
+  } else if (authToken && !writeProjectCredential) {
+    console.log(chalk.yellow(t('create.skipProjectCredential')));
+  }
+}
+
+module.exports = { applyEnterpriseConfig };

package/bin/commands/create/index.js

@@ -0,0 +1,128 @@
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const packageJson = require('../../../package.json');
+const { t } = require('../../i18n');
+const { resolveCreateInputs } = require('./prompts');
+const { resolveTemplate } = require('./template');
+const { createProjectFromTemplate } = require('./project');
+const { applyEnterpriseConfig } = require('./enterprise');
+const { handleStaticResources } = require('./static-resources');
+const { fetchKunlunMinorVersionsFromMirror } = require('./version-source');
+const { startNpmDistTagLatestCheck, isNewerVersion } = require('./update-check');
+const { compareSemver, isAtLeast73 } = require('../../utils/oinone-version');
+
+async function createAction(projectNameArg, options) {
+  if (projectNameArg === 'cache') {
+    return;
+  }
+
+  const updateCheck = startNpmDistTagLatestCheck('@oinone/cli', 3000);
+
+  try {
+    const {
+      prefix,
+      fullProjectName,
+      oinoneVersion,
+      edition,
+      downloadStaticResources,
+      authToken,
+      isSilent
+    } = await resolveCreateInputs(projectNameArg, options);
+
+    const targetPath = path.resolve(process.cwd(), fullProjectName);
+
+    if (await fs.pathExists(targetPath)) {
+      if (options.force) {
+        console.log(chalk.yellow(`\n⚠️ ${t('create.overwritePrompt', { name: fullProjectName })}`));
+      } else {
+        const { overwrite } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'overwrite',
+          message: t('create.overwritePrompt', { name: fullProjectName }),
+          default: false
+        }]);
+        if (!overwrite) {
+          console.log(chalk.red(t('common.canceled')));
+          process.exit(1);
+        }
+      }
+    }
+
+    const { templatePath, selectedMinorVersion } = resolveTemplate(oinoneVersion, edition);
+
+    if (options.dryRun) {
+      console.log(chalk.yellow(t('common.dryRun')));
+      process.exit(0);
+    }
+
+    const spinner = ora(t('create.weavingMagic')).start();
+
+    const { newGitignorePath, newNpmrcPath } = await createProjectFromTemplate({
+      templatePath,
+      targetPath,
+      prefix,
+      fullProjectName
+    });
+
+    if (edition === 'enterprise') {
+      await applyEnterpriseConfig({
+        targetPath,
+        prefix,
+        oinoneVersion,
+        authToken,
+        writeProjectCredential: options.writeProjectCredential,
+        newNpmrcPath,
+        newGitignorePath
+      });
+    }
+
+    await handleStaticResources({ downloadStaticResources, spinner, prefix, targetPath, fullProjectName });
+
+    console.log(t('create.partyStarted'));
+    console.log(chalk.cyan(`  cd ${fullProjectName}`));
+    console.log(chalk.cyan(`  pnpm install`));
+    console.log(chalk.cyan(`  pnpm run dev\n`));
+    console.log(chalk.magenta(t('create.happyCoding')));
+
+    if (isSilent && selectedMinorVersion && compareSemver(selectedMinorVersion, '7.3.0') < 0) {
+      try {
+        const remoteMinorVersions = await fetchKunlunMinorVersionsFromMirror(200);
+        if (remoteMinorVersions && remoteMinorVersions.length) {
+          const latestNewMinor = remoteMinorVersions.find(v => isAtLeast73(v));
+          if (latestNewMinor && compareSemver(latestNewMinor, selectedMinorVersion) > 0) {
+            console.log(chalk.yellow(`====================================================`));
+            console.log(chalk.yellow(t('common.newMinorAvailable', { latest: chalk.green(latestNewMinor) })));
+            console.log(chalk.yellow(`====================================================\n`));
+          }
+        }
+      } catch (e) {
+      }
+    }
+
+    try {
+      const latestVersion = await Promise.race([
+        updateCheck.promise,
+        new Promise(resolve => setTimeout(() => {
+          updateCheck.cancel();
+          resolve(null);
+        }, 1000))
+      ]);
+
+      if (latestVersion && isNewerVersion(packageJson.version, latestVersion)) {
+        console.log(chalk.yellow(`====================================================`));
+        console.log(chalk.yellow(t('common.updateAvailable', { current: chalk.red(packageJson.version), latest: chalk.green(latestVersion) })));
+        console.log(chalk.yellow(t('common.runUpdate', { cmd: chalk.cyan('npm install -g @oinone/cli') })));
+        console.log(chalk.yellow(`====================================================\n`));
+      }
+    } catch (e) {
+    }
+  } catch (error) {
+    console.error(chalk.red(t('common.somethingBroke', { msg: error.message })));
+    process.exit(1);
+  }
+}
+
+module.exports = createAction;

package/bin/commands/create/project.js

@@ -0,0 +1,81 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+async function processDirectory(dirPath, prefix) {
+  const files = await fs.readdir(dirPath);
+  for (const file of files) {
+    const currentPath = path.join(dirPath, file);
+    const stat = await fs.stat(currentPath);
+
+    let newPath = currentPath;
+    if (file.startsWith('ss-')) {
+      const newFile = file.replace(/^ss-/, `${prefix}-`);
+      newPath = path.join(dirPath, newFile);
+      await fs.rename(currentPath, newPath);
+    }
+
+    if (stat.isDirectory()) {
+      await processDirectory(newPath, prefix);
+    } else {
+      const ext = path.extname(newPath);
+      const isTextFile = !['.png', '.ico', '.jpg', '.jpeg', '.gif'].includes(ext);
+
+      if (isTextFile) {
+        let content = await fs.readFile(newPath, 'utf8');
+        let hasChanges = false;
+
+        const regex = /(^|[^a-zA-Z])ss-/g;
+        if (regex.test(content)) {
+          content = content.replace(regex, `$1${prefix}-`);
+          hasChanges = true;
+        }
+
+        if (content.includes('@ss/')) {
+          content = content.replace(/@ss\//g, `@${prefix}/`);
+          hasChanges = true;
+        }
+
+        if (hasChanges) {
+          await fs.writeFile(newPath, content, 'utf8');
+        }
+      }
+    }
+  }
+}
+
+async function createProjectFromTemplate({ templatePath, targetPath, prefix, fullProjectName }) {
+  await fs.copy(templatePath, targetPath, {
+    filter: (src) => {
+      const relativePath = path.relative(templatePath, src);
+      if (relativePath.split(path.sep).includes('node_modules')) return false;
+      return true;
+    }
+  });
+
+  await processDirectory(targetPath, prefix);
+
+  const pkgPath = path.join(targetPath, '_package.json');
+  const newPkgPath = path.join(targetPath, 'package.json');
+  if (await fs.pathExists(pkgPath)) {
+    const pkgContent = await fs.readJson(pkgPath);
+    pkgContent.name = fullProjectName;
+    await fs.writeJson(newPkgPath, pkgContent, { spaces: 2 });
+    await fs.remove(pkgPath);
+  }
+
+  const gitignorePath = path.join(targetPath, 'gitignore');
+  const newGitignorePath = path.join(targetPath, '.gitignore');
+  if (await fs.pathExists(gitignorePath)) {
+    await fs.move(gitignorePath, newGitignorePath);
+  }
+
+  const npmrcPath = path.join(targetPath, 'npmrc');
+  const newNpmrcPath = path.join(targetPath, '.npmrc');
+  if (await fs.pathExists(npmrcPath)) {
+    await fs.move(npmrcPath, newNpmrcPath);
+  }
+
+  return { newGitignorePath, newNpmrcPath };
+}
+
+module.exports = { createProjectFromTemplate };

package/bin/commands/create/prompts.js

@@ -0,0 +1,126 @@
+const inquirer = require('inquirer');
+const { t } = require('../../i18n');
+const { fetchKunlunMinorVersionsFromMirror } = require('./version-source');
+const { compareSemver, normalizeToMinorVersion, isSupportedMinorVersion } = require('../../utils/oinone-version');
+
+async function resolveCreateInputs(projectNameArg, options) {
+  let prefix;
+  let fullProjectName;
+  let oinoneVersion;
+  let edition;
+  let downloadStaticResources;
+
+  const isSilent = !!(projectNameArg || (options.companyName && options.projectName));
+
+  if (isSilent) {
+    if (projectNameArg) {
+      prefix = projectNameArg.endsWith('-frontend')
+        ? projectNameArg.slice(0, -9)
+        : projectNameArg;
+      fullProjectName = projectNameArg;
+    } else {
+      prefix = options.companyName;
+      fullProjectName = `${options.companyName}-${options.projectName}-frontend`;
+    }
+    oinoneVersion = options.oinoneVersion;
+    const normalizedMinor = normalizeToMinorVersion(oinoneVersion);
+    if (normalizedMinor) {
+      oinoneVersion = `~${normalizedMinor}`;
+    } else if (oinoneVersion && !oinoneVersion.startsWith('~')) {
+      oinoneVersion = `~${oinoneVersion}`;
+    }
+    edition = options.edition;
+    downloadStaticResources = options.downloadStaticResource !== 'false';
+  } else {
+    const remoteMinorVersions = await fetchKunlunMinorVersionsFromMirror(900);
+    const versionChoices = [
+      { name: t('create.version720', { version: '7.2.0' }), value: '~7.2.0' },
+      { name: t('create.version640', { version: '6.4.0' }), value: '~6.4.0' }
+    ];
+    if (remoteMinorVersions && remoteMinorVersions.length) {
+      for (const v of remoteMinorVersions) {
+        if (v === '7.2.0' || v === '6.4.0') continue;
+        if (!isSupportedMinorVersion(v)) continue;
+        if (compareSemver(v, '7.2.0') < 0 && v !== '6.4.0') continue;
+        versionChoices.push({ name: t('create.versionOther', { version: v }), value: `~${v}` });
+      }
+    }
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'companyName',
+        message: t('create.promptCompany'),
+        default: 'ss',
+        validate: (input) => {
+          if (input.trim() === '') return t('create.errorCompanyEmpty');
+          return true;
+        }
+      },
+      {
+        type: 'input',
+        name: 'projectName',
+        message: t('create.promptProject'),
+        default: 'oms',
+        validate: (input) => {
+          if (input.trim() === '') return t('create.errorProjectEmpty');
+          return true;
+        }
+      },
+      {
+        type: 'list',
+        name: 'edition',
+        message: t('create.promptEdition'),
+        choices: [
+          { name: t('create.editionCommunity'), value: 'community' },
+          { name: t('create.editionEnterprise'), value: 'enterprise' }
+        ],
+        default: 'community'
+      },
+      {
+        type: 'list',
+        name: 'oinoneVersion',
+        message: t('create.promptVersion'),
+        choices: versionChoices,
+        default: '~7.2.0'
+      },
+      {
+        type: 'confirm',
+        name: 'downloadStaticResources',
+        message: t('create.promptDownload'),
+        default: true
+      }
+    ]);
+
+    prefix = answers.companyName;
+    fullProjectName = `${answers.companyName}-${answers.projectName}-frontend`;
+    oinoneVersion = answers.oinoneVersion;
+    const normalizedMinor = normalizeToMinorVersion(oinoneVersion);
+    if (normalizedMinor) {
+      oinoneVersion = `~${normalizedMinor}`;
+    }
+    edition = answers.edition;
+    downloadStaticResources = answers.downloadStaticResources;
+  }
+
+  let authToken = options.authToken;
+  if (edition === 'enterprise' && !isSilent) {
+    if (authToken === undefined) {
+      const { wantRepo } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'wantRepo',
+        message: t('create.promptWantRepo'),
+        default: true
+      }]);
+      if (wantRepo) {
+        const creds = await inquirer.prompt([
+          { type: 'password', name: 'authToken', message: t('create.promptAuthToken') }
+        ]);
+        authToken = creds.authToken;
+      }
+    }
+  }
+
+  return { prefix, fullProjectName, oinoneVersion, edition, downloadStaticResources, authToken, isSilent };
+}
+
+module.exports = { resolveCreateInputs };

package/bin/commands/create/static-resources.js

@@ -0,0 +1,159 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const https = require('https');
+const os = require('os');
+const AdmZip = require('adm-zip');
+const cliProgress = require('cli-progress');
+const { t } = require('../../i18n');
+
+function downloadAndExtractZip(url, targetDir) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(url, { method: 'HEAD' }, (headRes) => {
+      headRes.resume();
+
+      if (headRes.statusCode !== 200) {
+        reject(new Error(t('create.fetchFileInfoFailed', { status: headRes.statusCode })));
+        return;
+      }
+
+      let etag = headRes.headers['etag'];
+      if (etag) {
+        etag = etag.replace(/"/g, '');
+      } else {
+        etag = headRes.headers['last-modified'] ? Buffer.from(headRes.headers['last-modified']).toString('hex') : 'default';
+      }
+
+      const cacheDir = path.join(os.tmpdir(), 'oinone-cli-cache');
+      fs.ensureDirSync(cacheDir);
+
+      const cachedZipPath = path.join(cacheDir, `static-resources-${etag}.zip`);
+
+      if (fs.existsSync(cachedZipPath)) {
+        console.log(chalk.cyan(t('cache.usingCached')));
+        try {
+          const zip = new AdmZip(cachedZipPath);
+          zip.extractAllTo(targetDir, true);
+          resolve();
+        } catch (err) {
+          fs.unlinkSync(cachedZipPath);
+          reject(err);
+        }
+        return;
+      }
+
+      const file = fs.createWriteStream(cachedZipPath);
+
+      https.get(url, (response) => {
+        if (response.statusCode !== 200) {
+          response.resume();
+          reject(new Error(t('create.downloadFailed', { status: response.statusCode })));
+          return;
+        }
+
+        const totalBytes = parseInt(response.headers['content-length'], 10);
+        let isMB = false;
+        let totalDisplay = 0;
+        let unit = 'KB';
+
+        if (totalBytes > 10 * 1024 * 1024) {
+          isMB = true;
+          unit = 'MB';
+          totalDisplay = (totalBytes / (1024 * 1024)).toFixed(2);
+        } else {
+          totalDisplay = Math.round(totalBytes / 1024);
+        }
+
+        let downloadedBytes = 0;
+        let startTime = Date.now();
+
+        const progressBar = new cliProgress.SingleBar({
+          format: chalk.cyan(t('create.fetchingAwesomeness')) + `[{bar}] {percentage}% | ⏳ {eta}s ${t('create.progressLeft')} | 📦 {value}/{total} ${unit} | 💨 {speed} {speedUnit}/s`,
+          barCompleteChar: '\u2588',
+          barIncompleteChar: '\u2591',
+          hideCursor: true,
+          forceRedraw: true
+        });
+
+        progressBar.start(Number(totalDisplay), 0, { speed: '0.00', speedUnit: 'KB' });
+
+        response.on('data', (chunk) => {
+          downloadedBytes += chunk.length;
+          let downloadedDisplay = 0;
+          if (isMB) {
+            downloadedDisplay = Number((downloadedBytes / (1024 * 1024)).toFixed(2));
+          } else {
+            downloadedDisplay = Math.round(downloadedBytes / 1024);
+          }
+
+          const currentTime = Date.now();
+          const elapsedSeconds = (currentTime - startTime) / 1000;
+          let speed = 0;
+          let speedUnit = 'KB';
+
+          if (elapsedSeconds > 0) {
+            const speedInBytes = downloadedBytes / elapsedSeconds;
+            if (speedInBytes > 1024 * 1024) {
+              speed = speedInBytes / (1024 * 1024);
+              speedUnit = 'MB';
+            } else {
+              speed = speedInBytes / 1024;
+              speedUnit = 'KB';
+            }
+          }
+
+          progressBar.update(downloadedDisplay, { speed: speed.toFixed(2), speedUnit });
+        });
+
+        response.pipe(file);
+        file.on('finish', () => {
+          progressBar.stop();
+          file.close();
+          try {
+            const zip = new AdmZip(cachedZipPath);
+            zip.extractAllTo(targetDir, true);
+            resolve();
+          } catch (err) {
+            if (fs.existsSync(cachedZipPath)) fs.unlinkSync(cachedZipPath);
+            reject(err);
+          }
+        });
+      }).on('error', (err) => {
+        if (fs.existsSync(cachedZipPath)) fs.unlink(cachedZipPath, () => {});
+        reject(err);
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(err);
+    });
+
+    req.end();
+  });
+}
+
+async function handleStaticResources({ downloadStaticResources, spinner, prefix, targetPath, fullProjectName }) {
+  if (downloadStaticResources) {
+    spinner.succeed(chalk.green(t('create.structureReady')));
+    console.log(chalk.cyan(t('create.haulingStatic')));
+    try {
+      const ossDir = path.join(targetPath, 'packages', `${prefix}-boot`, 'public', 'oss');
+      await fs.ensureDir(ossDir);
+      await downloadAndExtractZip('https://pamirs.oss-cn-hangzhou.aliyuncs.com/oinone/installer/static-resources.zip', ossDir);
+      console.log(chalk.green(t('create.staticDownloaded')));
+    } catch (err) {
+      console.log(chalk.yellow(t('create.staticHiccup', { msg: err.message })));
+    }
+  } else {
+    spinner.succeed(chalk.green(t('create.projectCreated')));
+    const relativeOssDir = `packages/${prefix}-boot/public/oss`;
+    console.log(chalk.yellow(t('create.skipStaticWarning')));
+    console.log(chalk.yellow(t('create.manualStaticInstructions')));
+    console.log(chalk.cyan(`  mkdir -p ${fullProjectName}/${relativeOssDir}`));
+    console.log(chalk.cyan(`  curl -L https://pamirs.oss-cn-hangzhou.aliyuncs.com/oinone/installer/static-resources.zip -o static-resources.zip`));
+    console.log(chalk.cyan(`  unzip static-resources.zip -d ${fullProjectName}/${relativeOssDir}`));
+    console.log(chalk.cyan(`  rm static-resources.zip`));
+  }
+}
+
+module.exports = { handleStaticResources };

package/bin/commands/create/template.js

@@ -0,0 +1,38 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { t } = require('../../i18n');
+
+function resolveTemplate(oinoneVersion, edition) {
+  const versionStr = String(oinoneVersion || '').trim();
+  const normalizedVersionStr = versionStr.replace(/[^0-9.]/g, '');
+  const versionMatch = normalizedVersionStr.match(/^(\d+)\.(\d+)(?:\.(\d+))?/);
+  if (!versionMatch) {
+    console.log(chalk.red(t('create.unsupportedVersion', { version: versionStr })));
+    process.exit(1);
+  }
+
+  const major = Number(versionMatch[1]);
+  const minor = Number(versionMatch[2]);
+  const selectedMinorVersion = `${major}.${minor}.0`;
+
+  let templateName;
+  if (major > 7 || (major === 7 && minor >= 2)) {
+    templateName = 'template-7.2.0';
+  } else if (major === 6 && minor === 4) {
+    templateName = 'template-6.4.0';
+  } else {
+    console.log(chalk.red(t('create.unsupportedVersion', { version: versionStr })));
+    process.exit(1);
+  }
+
+  const templatePath = path.resolve(__dirname, '..', '..', '..', templateName);
+  if (!fs.existsSync(templatePath)) {
+    console.log(chalk.red(t('create.errorTemplateMissing', { version: normalizedVersionStr || versionStr, edition })));
+    process.exit(1);
+  }
+
+  return { templateName, templatePath, selectedMinorVersion, normalizedVersionStr, versionStr };
+}
+
+module.exports = { resolveTemplate };

package/bin/commands/create/update-check.js

@@ -0,0 +1,44 @@
+const https = require('https');
+
+function isNewerVersion(current, latest) {
+  const c = String(current || '').replace(/[^0-9.]/g, '').split('.').map(Number);
+  const l = String(latest || '').replace(/[^0-9.]/g, '').split('.').map(Number);
+  for (let i = 0; i < Math.max(c.length, l.length); i++) {
+    const numC = c[i] || 0;
+    const numL = l[i] || 0;
+    if (numL > numC) return true;
+    if (numL < numC) return false;
+  }
+  return false;
+}
+
+function startNpmDistTagLatestCheck(packageName, timeoutMs = 3000) {
+  let req = null;
+  const promise = new Promise((resolve) => {
+    req = https.get(`https://registry.npmjs.org/-/package/${packageName}/dist-tags`, { timeout: timeoutMs }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          resolve(parsed.latest);
+        } catch (e) {
+          resolve(null);
+        }
+      });
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.on('error', () => resolve(null));
+  });
+
+  const cancel = () => {
+    if (req) req.destroy();
+  };
+
+  return { promise, cancel };
+}
+
+module.exports = { startNpmDistTagLatestCheck, isNewerVersion };

package/bin/commands/create/version-source.js

@@ -0,0 +1,32 @@
+const https = require('https');
+const { toMinorVersions, isSupportedMinorVersion } = require('../../utils/oinone-version');
+
+function fetchKunlunMinorVersionsFromMirror(timeoutMs) {
+  return new Promise((resolve) => {
+    const req = https.get('https://registry.npmmirror.com/@oinone/kunlun-dependencies', { timeout: timeoutMs }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          resolve(null);
+          return;
+        }
+        try {
+          const parsed = JSON.parse(data);
+          const versions = parsed && parsed.versions ? Object.keys(parsed.versions) : [];
+          const minorVersions = toMinorVersions(versions).filter(isSupportedMinorVersion);
+          resolve(minorVersions.length ? minorVersions : null);
+        } catch (e) {
+          resolve(null);
+        }
+      });
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.on('error', () => resolve(null));
+  });
+}
+
+module.exports = { fetchKunlunMinorVersionsFromMirror };