@struggler/cli 1.0.2 → 1.0.5

package/command/upload.js

@@ -1,203 +1,142 @@
-var fs = require('fs');
-
-var path = require('path');
-
 var qiniu = require("qiniu");
 
 var qiniuPrefix = require("../lib/prefix")
 
 let { getQiniuConfig, getDir } = require('../lib/config')
-let { getJsonData, setJsonData } = require('../lib/files')
-
-
-function main(options) {
+let { getJsonData } = require('../lib/files')
+const { createIgnoreMatcher } = require('../lib/ignore');
+const {
+    collectDeployFiles,
+    createSummary,
+    ensureRequiredConfig,
+    finalizeOutput,
+    logPlan,
+    normalizeConcurrency,
+    runWithConcurrency,
+    toRemoteKey,
+} = require('../lib/deploy');
+const { printMessage } = require('../lib/output');
+
+async function main(options, runtime = {}) {
     const qiniuConfig = getJsonData(getQiniuConfig(options))
+    const prefix = runtime.prefix || qiniuPrefix.prefix(options);
+    let dir = getDir(options)
+    const startedAt = Date.now();
+    const ignoreMatcher = createIgnoreMatcher(dir, options);
+    const excludedPatterns = runtime.excludePatterns || ignoreMatcher.patterns;
+    const files = runtime.files || await collectDeployFiles(dir, options);
+    const plans = files.map((localFile) => {
+        const key = toRemoteKey(prefix, dir, localFile);
+        return {
+            localFile,
+            key,
+            target: `${qiniuConfig.domain || ''}${key}`,
+        };
+    });
+
+    if (options.dryRun) {
+        if (!runtime.suppressOutput) {
+            logPlan('upload', plans, options);
+        }
+        const summary = createSummary('upload', true, plans.map((plan) => ({
+            ok: true,
+            localFile: plan.localFile,
+            key: plan.key,
+            target: plan.target,
+        })), startedAt, {
+            prefix,
+            concurrency: normalizeConcurrency(options.concurrency),
+            excludedPatterns,
+        });
+        return runtime.suppressOutput ? summary : finalizeOutput(summary, options, runtime.manifestExtra);
+    }
 
-    //自己七牛云的秘钥
+    ensureRequiredConfig(
+        { ...qiniuConfig, 'publicPath(config.json)': prefix },
+        ['accessKey', 'secretKey', 'Bucket', 'zone', 'domain', 'publicPath(config.json)']
+    );
 
     var accessKey = qiniuConfig.accessKey
-
     var secretKey = qiniuConfig.secretKey;
-
     var mac = new qiniu.auth.digest.Mac(accessKey, secretKey);
-
     var config = new qiniu.conf.Config();
-
-    // 空间对应的机房，zone_z1代表华北，其他配置参见七牛云文档
-
     config.zone = qiniu.zone[qiniuConfig.zone];
-
-    // 是否使用https域名
-
     config.useHttpsDomain = true;
-
-    // 上传是否使用cdn加速
-
     config.useCdnDomain = true;
 
     var formUploader = new qiniu.form_up.FormUploader(config);
-
     var putExtra = new qiniu.form_up.PutExtra();
 
-    //文件前缀
-
-    const prefix = qiniuPrefix.prefix(options);
-
-    let dir = getDir(options)
-
-    function upload(key, localFile) {
-        //windows
-
-        /* let str = null;
-
-        if (localFile.indexOf("./dist\\") >= 0) {
-
-            str = localFile.replace("./dist\\", "");
-
-        } else if (localFile.indexOf("./dist/") >= 0) {
-
-            //苹果
-
-            str = localFile.replace("./dist/", "");
-
-        } else {
-
-            str = localFile;
-
-        } */
-
-        const str = path.relative(dir, localFile)
-
-        key = prefix + str
-
-        //上传之后的文件名
-        key = key.replace(/\\/g, "/")
-
-        //这里base-html是存储空间名
-
-        // var Bucket = `cfun:${key}`;
-
-        var Bucket = qiniuConfig.Bucket;
-
-        var options = {
-
-            // scope: Bucket,
-
-            // https://developer.qiniu.com/kodo/1289/nodejs#overwrite-uptoken
-            scope: Bucket + ":" + key
-
-            // detectMime:0
-
-            // MimeType: 'text/html;text/css;text/javascript;application/x-gzip',
-
+    function upload(plan, attempt = 1) {
+        var uploadOptions = {
+            scope: `${qiniuConfig.Bucket}:${plan.key}`
         };
-
-        var putPolicy = new qiniu.rs.PutPolicy(options);
-
+        var putPolicy = new qiniu.rs.PutPolicy(uploadOptions);
         var uploadToken = putPolicy.uploadToken(mac);
 
-        formUploader.putFile(uploadToken, key, localFile, null, function (respErr,
-
-            respBody, respInfo) {
-
-            if (respErr) {
-
-                // console.log(uploadToken);
-
-                console.log(localFile + "文件上传失败,正在重新上传-----------");
-
-                // console.log(respInfo.statusCode);
-
-                // console.log(respBody);
-
-                upload('file2', localFile);
-
-                throw respErr;
-
-            } else {
-
-                if (respInfo.statusCode == 200) {
-                    respBody.key = qiniuConfig.domain + respBody.key
-
-                    console.log(respBody);
-
-                } else {
-
-                    console.log(respInfo.statusCode);
-
-                    console.log(respBody);
-
-                    if (respBody.error) {
-
-                        console.log(respBody.error)
-
+        return new Promise((resolve, reject) => {
+            formUploader.putFile(uploadToken, plan.key, plan.localFile, putExtra, async function (respErr, respBody, respInfo) {
+                if (respErr || respInfo.statusCode !== 200) {
+                    if (attempt < 3) {
+                        console.log(`${plan.localFile} 上传失败，正在进行第 ${attempt + 1} 次重试`);
+                        try {
+                            const retryResult = await upload(plan, attempt + 1);
+                            resolve(retryResult);
+                        } catch (retryError) {
+                            reject(retryError);
+                        }
+                        return;
                     }
 
+                    const errorMessage = respErr || (respBody && respBody.error) || `statusCode=${respInfo && respInfo.statusCode}`;
+                    reject(new Error(errorMessage));
+                    return;
                 }
 
-            }
-
+                resolve({
+                    hash: respBody.hash,
+                    key: plan.key,
+                    target: plan.target,
+                });
+            });
         });
-
     }
 
-    //遍历文件夹
-
-    function displayFile(param) {
-
-        //转换为绝对路径
-
-        //var param = path.resolve(param);
-
-        fs.stat(param, function (err, stats) {
-
-            //如果是目录的话，遍历目录下的文件信息
-
-            if (stats.isDirectory()) {
-
-                fs.readdir(param, function (err, file) {
-
-                    file.forEach((e) => {
-
-                        //遍历之后递归调用查看文件函数
-
-                        //遍历目录得到的文件名称是不含路径的，需要将前面的绝对路径拼接
-
-                        var absolutePath = path.join(param, e);
-
-                        //var absolutePath = path.resolve(path.join(param, e));
-
-                        displayFile(absolutePath)
-
-                    })
-
-                })
-
-            } else {
-
-                //file2/这里是空间里的文件前缀
-
-                var key = 'file2';
-
-                var localFile = param;
-
-                if (!localFile.endsWith(".gz")) {
-
-                    upload(key, localFile);
-
-                }
-
+    const results = await runWithConcurrency(plans, normalizeConcurrency(options.concurrency), async (plan) => {
+        try {
+            const response = await upload(plan);
+            if (!runtime.suppressOutput) {
+                printMessage(options, `[uploaded] ${plan.localFile} -> ${plan.target}`);
             }
-
-        })
-
+            return {
+                ok: true,
+                localFile: plan.localFile,
+                key: response.key,
+                target: response.target,
+                hash: response.hash,
+            };
+        } catch (error) {
+            return {
+                ok: false,
+                localFile: plan.localFile,
+                key: plan.key,
+                target: plan.target,
+                error: error.message,
+            };
+        }
+    });
+
+    const summary = createSummary('upload', false, results, startedAt, {
+        prefix,
+        concurrency: normalizeConcurrency(options.concurrency),
+        excludedPatterns,
+    });
+    const finalSummary = runtime.suppressOutput ? summary : finalizeOutput(summary, options, runtime.manifestExtra);
+    if (finalSummary.failedCount > 0) {
+        throw new Error(`Upload finished with ${summary.failedCount} failures`);
     }
 
-    displayFile(dir);
-
+    return finalSummary;
 }
 
-
-
-
-module.exports = main
+module.exports = main

package/index.js

@@ -1,41 +1,102 @@
 #! /usr/bin/env node
-const { magentaBright } = require('chalk');
-const figlet = require('figlet');
-const clear = require('clear');
-const { program } = require('commander')
-const  command = require("./command")
+const { magentaBright } = require("chalk")
+const figlet = require("figlet")
+const clear = require("clear")
+const { program } = require("commander")
+const command = require("./command")
+const packageJson = require("./package.json")
+const { shouldUseJson, printError, printJson } = require("./lib/output")
+const { resolveLang, getLocale } = require("./lib/i18n")
 
+const lang = resolveLang(process.argv)
+const locale = getLocale(lang)
+const isJsonMode = process.argv.includes("--json")
 
 // 清除命令行
-clear();
+if (!shouldUseJson({ json: isJsonMode })) {
+	clear()
+}
 
 // 输出Logo
-console.log(magentaBright(figlet.textSync('struggler-cli', { horizontalLayout: 'full' })),'\n\n');
+if (!isJsonMode) {
+	console.log(magentaBright(figlet.textSync("struggler-cli", { horizontalLayout: "full" })), "\n\n")
+}
 
+function formatItems(items, getLeft, getRight) {
+	if (items.length === 0) {
+		return []
+	}
 
+	const width = items.reduce((max, item) => Math.max(max, getLeft(item).length), 0)
+	return items.map((item) => `  ${getLeft(item).padEnd(width)}  ${getRight(item)}`.trimEnd())
+}
 
-program
-.name('struggler-cli')
-.description('CLI to Upload vite packaged files to Qiniu Cloud OSS.')
-.version('1.0.2')
-.option('-c, --config <path>', 'Specify the path to upload configuration file.', './command/qiniu.json')
-.option('-d, --dir <path>', 'Specify the dir to upload.', './dist')
+program.configureHelp({
+	formatHelp: (cmd, helper) => {
+		const lines = []
+		lines.push(`${locale.help.usage}: ${helper.commandUsage(cmd)}`)
+
+		const description = helper.commandDescription(cmd)
+		if (description) {
+			lines.push("")
+			lines.push(`${locale.help.commandDescription} ${description}`)
+		}
+
+		const options = helper.visibleOptions(cmd)
+		if (options.length > 0) {
+			lines.push("")
+			lines.push(`${locale.help.options}:`)
+			lines.push(...formatItems(options, (option) => helper.optionTerm(option), (option) => option.description))
+		}
+
+		const commands = helper.visibleCommands(cmd)
+		if (commands.length > 0) {
+			lines.push("")
+			lines.push(`${locale.help.commands}:`)
+			lines.push(...formatItems(commands, (subcommand) => helper.subcommandTerm(subcommand), (subcommand) => subcommand.description()))
+		}
 
+		return lines.join("\n")
+	},
+})
+
+program.name("struggler-cli").description(locale.appDescription).version(packageJson.version, "-v, --version", locale.options.version).helpOption("-h, --help", locale.options.help).option("-c, --config <path>", locale.options.config, "./command/qiniu.json").option("-d, --dir <path>", locale.options.dir, "./dist").option("--dry-run", locale.options.dryRun).option("--concurrency <number>", locale.options.concurrency, "5").option("--exclude <pattern>", locale.options.exclude).option("--ignore-file <path>", locale.options.ignoreFile, ".strugglerignore").option("--manifest <path>", locale.options.manifest).option("--json", locale.options.json).option("--skip-init", locale.options.skipInit).option("--skip-refresh", locale.options.skipRefresh).option("--lang <lang>", locale.options.lang, lang)
+
+program
+	.command("init")
+	.description(locale.commands.init)
+	.action(async () => {
+		await command.init(program.opts())
+	})
 
 program
-.command('init')
-.description('Create upload configuration for specified path.')
-.action(()=>{command.init(program.opts())})
+	.command("upload")
+	.description(locale.commands.upload)
+	.action(async () => {
+		await command.upload(program.opts())
+	})
 
 program
-.command('upload')
-.description('Upload files under the specified file to Qiniu Cloud.')
-    .action(() => { command.upload(program.opts()) })
+	.command("refresh")
+	.description(locale.commands.refresh)
+	.action(async () => {
+		await command.refresh(program.opts())
+	})
 
 program
-    .command('addVersion')
-    .description('Package add version.')
-    .action(() => { command.addVersion(program.opts()) })
+	.command("deploy")
+	.description(locale.commands.deploy)
+	.action(async () => {
+		await command.deploy(program.opts())
+	})
 
-program.parse()
+program.addHelpCommand(true, locale.help.helpCommandDescription)
 
+program.parseAsync().catch(error => {
+	if (isJsonMode) {
+		printJson({ ok: false, error: error.message || String(error) })
+		return
+	}
+	printError({}, error.message || error)
+	process.exitCode = 1
+})

package/lib/config.js

@@ -1,15 +1,33 @@
-let fs = require('fs');
 let path = require('path')
 
+const DEFAULT_QINIU_CONFIG = './command/qiniu.json';
+const DEFAULT_CONFIG = './command/config.json';
+
+function resolveFromCwd(targetPath) {
+    return path.resolve(process.cwd(), targetPath);
+}
+
+function getQiniuConfigPath(options = {}) {
+    return resolveFromCwd(options.config || DEFAULT_QINIU_CONFIG);
+}
+
+function getConfigPath(options = {}) {
+    if (!options.config) {
+        return resolveFromCwd(DEFAULT_CONFIG);
+    }
+
+    const qiniuConfigPath = getQiniuConfigPath(options);
+    return path.join(path.dirname(qiniuConfigPath), 'config.json');
+}
 
 module.exports = {
     getConfig: (options) => {
-        return path.resolve(process.cwd(), './command/config.json')
+        return getConfigPath(options)
     },
     getQiniuConfig: (options) => {
-        return path.resolve(process.cwd(), options.config || './command/qiniu.json')
+        return getQiniuConfigPath(options)
     },
     getDir: (options) => {
-        return path.resolve(process.cwd(), options.dir || './dist')
+        return resolveFromCwd(options.dir || './dist')
     },
 };

package/lib/date.js

@@ -0,0 +1,14 @@
+function formatDate(date) {
+    const value = date || new Date();
+    const year = value.getFullYear();
+    const month = value.getMonth() + 1;
+    const day = value.getDate();
+    const hours = value.getHours();
+    const minutes = value.getMinutes();
+
+    return `${year}${month < 10 ? `0${month}` : month}${day < 10 ? `0${day}` : day}${hours < 10 ? `0${hours}` : hours}${minutes < 10 ? `0${minutes}` : minutes}`;
+}
+
+module.exports = {
+    formatDate,
+};

package/lib/deploy.js

@@ -0,0 +1,132 @@
+const path = require('path');
+const { listFiles } = require('./files');
+const { createIgnoreMatcher } = require('./ignore');
+const { printMessage, writeManifest, shouldUseJson, printJson } = require('./output');
+
+const DEFAULT_CONCURRENCY = 5;
+
+function normalizeConcurrency(value) {
+    const parsed = parseInt(value, 10);
+    if (Number.isNaN(parsed) || parsed < 1) {
+        return DEFAULT_CONCURRENCY;
+    }
+
+    return parsed;
+}
+
+function toRemoteKey(prefix, rootDir, localFile) {
+    return `${prefix}${path.relative(rootDir, localFile)}`.replace(/\\/g, '/');
+}
+
+async function collectDeployFiles(dir, options = {}) {
+    const files = await listFiles(dir);
+    const ignoreMatcher = createIgnoreMatcher(dir, options);
+    return files
+        .filter((filePath) => !filePath.endsWith('.gz'))
+        .filter((filePath) => !ignoreMatcher.shouldIgnore(filePath))
+        .sort((left, right) => left.localeCompare(right));
+}
+
+async function runWithConcurrency(items, concurrency, worker) {
+    const normalizedConcurrency = Math.min(normalizeConcurrency(concurrency), Math.max(items.length, 1));
+    const results = new Array(items.length);
+    let nextIndex = 0;
+
+    async function consume() {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await worker(items[currentIndex], currentIndex);
+        }
+    }
+
+    const tasks = Array.from({ length: normalizedConcurrency }, () => consume());
+    await Promise.all(tasks);
+    return results;
+}
+
+function createSummary(action, dryRun, results, startedAt, extra = {}) {
+    const succeeded = results.filter((item) => item.ok);
+    const failed = results.filter((item) => !item.ok);
+
+    return {
+        action,
+        dryRun,
+        total: results.length,
+        succeededCount: succeeded.length,
+        failedCount: failed.length,
+        durationMs: Date.now() - startedAt,
+        succeeded,
+        failed,
+        results,
+        ...extra,
+    };
+}
+
+function logPlan(action, items, options) {
+    printMessage(options, `[dry-run] ${action} plan (${items.length} files)`);
+    items.forEach((item) => {
+        printMessage(options, `- ${item.localFile} -> ${item.target}`);
+    });
+}
+
+function logSummary(summary, options) {
+    const mode = summary.dryRun ? 'dry-run' : 'live';
+    printMessage(options, `[summary] ${summary.action} mode=${mode} total=${summary.total} succeeded=${summary.succeededCount} failed=${summary.failedCount} duration=${summary.durationMs}ms`);
+    if (summary.failedCount > 0) {
+        summary.failed.forEach((item) => {
+            printMessage(options, `[failed] ${item.localFile}: ${item.error}`);
+        });
+    }
+}
+
+function maybeWriteManifest(summary, options, extra = {}) {
+    if (!options.manifest) {
+        return summary;
+    }
+
+    const manifestPath = writeManifest(options.manifest, {
+        ...summary,
+        ...extra,
+    });
+
+    return {
+        ...summary,
+        manifestPath,
+    };
+}
+
+function finalizeOutput(summary, options, extra = {}) {
+    const finalSummary = maybeWriteManifest(summary, options, extra);
+    if (shouldUseJson(options)) {
+        printJson(finalSummary);
+    } else {
+        logSummary(finalSummary, options);
+        if (finalSummary.manifestPath) {
+            printMessage(options, `[manifest] ${finalSummary.manifestPath}`);
+        }
+    }
+
+    return finalSummary;
+}
+
+function ensureRequiredConfig(config, requiredFields) {
+    const missingFields = requiredFields.filter((field) => !config[field]);
+    if (missingFields.length > 0) {
+        throw new Error(`Missing required config: ${missingFields.join(', ')}`);
+    }
+}
+
+module.exports = {
+    DEFAULT_CONCURRENCY,
+    normalizeConcurrency,
+    toRemoteKey,
+    collectDeployFiles,
+    runWithConcurrency,
+    createSummary,
+    logPlan,
+    logSummary,
+    maybeWriteManifest,
+    finalizeOutput,
+    ensureRequiredConfig,
+};

package/lib/files.js

@@ -2,6 +2,21 @@
 
 const fs = require('fs');
 const path = require('path');
+const fsp = fs.promises;
+
+async function walkFiles(filePath) {
+    const entries = await fsp.readdir(filePath, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const absolutePath = path.join(filePath, entry.name);
+        if (entry.isDirectory()) {
+            return walkFiles(absolutePath);
+        }
+
+        return [absolutePath];
+    }));
+
+    return files.flat();
+}
 
 module.exports = {
     // 获取目录名称
@@ -23,11 +38,10 @@ module.exports = {
 
     setJsonData: (filePath,data) => {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFile(
+        fs.writeFileSync(
             filePath,
             JSON.stringify(data, null, "\t"
-            ),
-            (err) => { }
+            )
         )
     },
     setSyncJsonData: (filePath, data) => {
@@ -36,5 +50,17 @@ module.exports = {
             filePath,
             JSON.stringify(data, null, "\t"),
         )
+    },
+    listFiles: async (filePath) => {
+        if (!fs.existsSync(filePath)) {
+            return [];
+        }
+
+        const stat = await fsp.stat(filePath);
+        if (!stat.isDirectory()) {
+            return [filePath];
+        }
+
+        return walkFiles(filePath);
     }
-};
+};