@struggler/cli 1.0.3 → 1.0.6

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);
     }
-};
+};

package/lib/i18n.js

@@ -0,0 +1,191 @@
+const LANGUAGES = {
+    zh: {
+        appDescription: '用于将前端打包产物上传到七牛云 OSS 的命令行工具。',
+        options: {
+            version: '显示版本号。',
+            config: '指定上传配置文件路径。',
+            dir: '指定要上传的目录。',
+            dryRun: '仅预览执行计划，不写文件也不调用七牛接口。',
+            concurrency: '设置上传并发数。',
+            exclude: '排除文件匹配规则，支持逗号分隔多个模式。',
+            ignoreFile: '指定自定义忽略文件。',
+            manifest: '将命令执行结果写入 manifest JSON 文件。',
+            json: '输出机器可读的 JSON 结果。',
+            skipInit: '在 deploy 时跳过 init 步骤。',
+            skipRefresh: '在 deploy 时跳过 refresh 步骤。',
+            noCache: '禁用上传缓存，强制重新上传所有文件。',
+            lang: '切换菜单语言，可选 zh / en。',
+            help: '显示帮助信息。',
+        },
+        commands: {
+            init: '为指定路径生成上传配置。',
+            upload: '将指定目录下文件上传到七牛云。',
+            refresh: '刷新七牛云 CDN 文件。',
+            deploy: '一次执行 init、upload 和 refresh。',
+        },
+        help: {
+            helpCommandDescription: '显示指定命令的帮助信息',
+            commandUsage: '用法：',
+            commandDescription: '说明：',
+            commandOptions: '参数：',
+            commandCommands: '命令：',
+            subcommandTerm: '命令',
+            optionTerm: '参数',
+            argumentTerm: '参数',
+            usage: '用法',
+            options: '参数',
+            commands: '命令',
+            arguments: '参数',
+        },
+    },
+    en: {
+        appDescription: 'CLI to upload front-end build files to Qiniu Cloud OSS.',
+        options: {
+            version: 'Display the version number.',
+            config: 'Specify the path to the upload configuration file.',
+            dir: 'Specify the directory to upload.',
+            dryRun: 'Preview actions without writing files or calling Qiniu APIs.',
+            concurrency: 'Set upload concurrency.',
+            exclude: 'Exclude file glob patterns, supports comma-separated values.',
+            ignoreFile: 'Specify a custom ignore file.',
+            manifest: 'Write the command summary to a manifest JSON file.',
+            json: 'Print machine-readable JSON output.',
+            skipInit: 'Skip init during deploy.',
+            skipRefresh: 'Skip refresh during deploy.',
+            noCache: 'Disable upload cache and force re-upload all files.',
+            lang: 'Switch menu language, supported values: zh / en.',
+            help: 'Display help information.',
+        },
+        commands: {
+            init: 'Create upload configuration for the specified path.',
+            upload: 'Upload files under the specified directory to Qiniu Cloud.',
+            refresh: 'Refresh Qiniu Cloud CDN files.',
+            deploy: 'Run init, upload, and refresh in one command.',
+        },
+        help: {
+            helpCommandDescription: 'display help for command',
+            commandUsage: 'Usage:',
+            commandDescription: 'Description:',
+            commandOptions: 'Options:',
+            commandCommands: 'Commands:',
+            subcommandTerm: 'command',
+            optionTerm: 'option',
+            argumentTerm: 'argument',
+            usage: 'Usage',
+            options: 'Options',
+            commands: 'Commands',
+            arguments: 'Arguments',
+        },
+    },
+};
+
+function normalizeLocaleTag(value) {
+    if (!value) {
+        return '';
+    }
+
+    return value.toLowerCase().replace('.', '_');
+}
+
+function detectLangFromLocale(localeValue) {
+    const normalized = normalizeLocaleTag(localeValue);
+    if (!normalized) {
+        return null;
+    }
+
+    if (normalized.startsWith('en')) {
+        return 'en';
+    }
+
+    if (normalized.startsWith('zh')) {
+        return 'zh';
+    }
+
+    return null;
+}
+
+function detectLangFromVSLang(value) {
+    if (!value) {
+        return null;
+    }
+
+    const normalized = String(value).trim();
+    const englishCodes = new Set(['1033', '2057', '4105', '5129', '6153']);
+    const chineseCodes = new Set(['2052', '1028', '3076', '4100']);
+
+    if (englishCodes.has(normalized)) {
+        return 'en';
+    }
+
+    if (chineseCodes.has(normalized)) {
+        return 'zh';
+    }
+
+    return null;
+}
+
+function detectLangFromWindowsValue(value) {
+    return detectLangFromLocale(value);
+}
+
+function detectSystemLang(env = process.env) {
+    const localeCandidates = [
+        env.LC_ALL,
+        env.LC_MESSAGES,
+        env.LANG,
+        env.PreferredUILanguages,
+        env.UILANG,
+        env.Culture,
+        env.UserLanguage,
+    ];
+
+    for (const candidate of localeCandidates) {
+        const detected = detectLangFromLocale(candidate);
+        if (detected) {
+            return detected;
+        }
+    }
+
+    const windowsSpecificCandidates = [
+        env.VSLANG,
+        env.PREFERRED_UI_LANGUAGES,
+        env.UI_LANG,
+    ];
+
+    for (const candidate of windowsSpecificCandidates) {
+        const detected = detectLangFromVSLang(candidate) || detectLangFromWindowsValue(candidate);
+        if (detected) {
+            return detected;
+        }
+    }
+
+    return 'zh';
+}
+
+function resolveLang(argv) {
+    const langFlagIndex = argv.findIndex((item) => item === '--lang');
+    if (langFlagIndex >= 0 && argv[langFlagIndex + 1] && LANGUAGES[argv[langFlagIndex + 1]]) {
+        return argv[langFlagIndex + 1];
+    }
+
+    const inlineFlag = argv.find((item) => item.startsWith('--lang='));
+    if (inlineFlag) {
+        const [, value] = inlineFlag.split('=');
+        if (LANGUAGES[value]) {
+            return value;
+        }
+    }
+
+    return detectSystemLang();
+}
+
+function getLocale(lang) {
+    return LANGUAGES[lang] || LANGUAGES.zh;
+}
+
+module.exports = {
+    LANGUAGES,
+    detectSystemLang,
+    resolveLang,
+    getLocale,
+};

package/lib/ignore.js

@@ -0,0 +1,69 @@
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_IGNORE_FILE = '.strugglerignore';
+
+function escapeRegExp(value) {
+    return value.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+}
+
+function patternToRegExp(pattern) {
+    const normalizedPattern = pattern.replace(/\\/g, '/');
+    const escaped = escapeRegExp(normalizedPattern)
+        .replace(/\\\*\\\*/g, '.*')
+        .replace(/\\\*/g, '[^/]*');
+    return new RegExp(`(^|/)${escaped}$`);
+}
+
+function parseIgnoreFile(ignoreFilePath) {
+    if (!fs.existsSync(ignoreFilePath)) {
+        return [];
+    }
+
+    return fs.readFileSync(ignoreFilePath, 'utf8')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'));
+}
+
+function normalizeExcludePatterns(value) {
+    if (!value) {
+        return [];
+    }
+
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => normalizeExcludePatterns(item));
+    }
+
+    return String(value)
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+
+function createIgnoreMatcher(rootDir, options = {}) {
+    const ignoreFilePath = path.resolve(process.cwd(), options.ignoreFile || DEFAULT_IGNORE_FILE);
+    const patterns = [
+        ...parseIgnoreFile(ignoreFilePath),
+        ...normalizeExcludePatterns(options.exclude),
+    ];
+    const matchers = patterns.map((pattern) => patternToRegExp(pattern));
+
+    return {
+        patterns,
+        shouldIgnore(filePath) {
+            if (matchers.length === 0) {
+                return false;
+            }
+
+            const relativePath = path.relative(rootDir, filePath).replace(/\\/g, '/');
+            return matchers.some((matcher) => matcher.test(relativePath));
+        },
+    };
+}
+
+module.exports = {
+    DEFAULT_IGNORE_FILE,
+    normalizeExcludePatterns,
+    createIgnoreMatcher,
+};

package/lib/output.js

@@ -0,0 +1,37 @@
+const fs = require('fs');
+const path = require('path');
+
+function shouldUseJson(options = {}) {
+    return Boolean(options.json);
+}
+
+function printMessage(options, message) {
+    if (!shouldUseJson(options)) {
+        console.log(message);
+    }
+}
+
+function printError(options, message) {
+    if (!shouldUseJson(options)) {
+        console.error(message);
+    }
+}
+
+function printJson(payload) {
+    console.log(JSON.stringify(payload, null, 2));
+}
+
+function writeManifest(filePath, payload) {
+    const resolvedPath = path.resolve(process.cwd(), filePath);
+    fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+    fs.writeFileSync(resolvedPath, JSON.stringify(payload, null, 2));
+    return resolvedPath;
+}
+
+module.exports = {
+    shouldUseJson,
+    printMessage,
+    printError,
+    printJson,
+    writeManifest,
+};

package/lib/prefix.js

@@ -1,24 +1,10 @@
 let { getConfig } = require('./config')
 let { getJsonData } = require('./files')
 
-//七牛文件上传前缀，使用时间戳作为文件上传前缀
-function formatDate(date) {
-    date  = date || new Date()
-    const year = date.getFullYear()
-    const month = date.getMonth() + 1
-    const day = date.getDate()
-    const hours = date.getHours()
-    const minutes = date.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 = {
     prefix: (options)=>{
         const { publicPath } = getJsonData(getConfig(options))
-        return publicPath
+        return publicPath || ''
     }
 
-}
+}

package/package.json

@@ -1,28 +1,29 @@
 {
-  "name": "@struggler/cli",
-  "version": "1.0.3",
-  "description": "CLI to Upload vite packaged files to Qiniu Cloud OSS.",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "bin": {
-    "struggler-cli": "./index.js"
-  },
-  "keywords": [
-    "Qiniu",
-    "OSS"
-  ],
-  "author": "moqi(str@li.cm)",
-  "license": "ISC",
-  "dependencies": {
-    "chalk": "^v4.1.2",
-    "clear": "^0.1.0",
-    "commander": "^11.0.0",
-    "figlet": "^1.6.0",
-    "qiniu": "^7.8.0"
-  },
-  "publicConfig": {
-    "registry": "http://registry.npmjs.org/"
-  }
-}
+	"name": "@struggler/cli",
+	"version": "1.0.6",
+	"description": "CLI to Upload vite packaged files to Qiniu Cloud OSS.",
+	"main": "index.js",
+	"scripts": {
+		"add-version": "node ./command/addVersion.js",
+		"test": "node --test"
+	},
+	"bin": {
+		"struggler-cli": "./index.js"
+	},
+	"keywords": [
+		"Qiniu",
+		"OSS"
+	],
+	"author": "moqi(str@li.cm)",
+	"license": "ISC",
+	"dependencies": {
+		"chalk": "^v4.1.2",
+		"clear": "^0.1.0",
+		"commander": "^11.0.0",
+		"figlet": "^1.6.0",
+		"qiniu": "^7.8.0"
+	},
+	"publicConfig": {
+		"registry": "http://registry.npmjs.org/"
+	}
+}

package/test/config.test.js

@@ -0,0 +1,41 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { getConfig, getQiniuConfig, getDir } = require('../lib/config');
+const { normalizeConcurrency, toRemoteKey } = require('../lib/deploy');
+const { normalizeExcludePatterns } = require('../lib/ignore');
+
+test('config helpers resolve qiniu and derived config paths together', () => {
+    const options = {
+        config: './test/command/qiniu.json',
+        dir: './test/dist3',
+    };
+
+    assert.equal(
+        getQiniuConfig(options),
+        `${process.cwd()}/test/command/qiniu.json`
+    );
+    assert.equal(
+        getConfig(options),
+        `${process.cwd()}/test/command/config.json`
+    );
+    assert.equal(
+        getDir(options),
+        `${process.cwd()}/test/dist3`
+    );
+});
+
+test('deploy helpers normalize concurrency and build remote keys', () => {
+    assert.equal(normalizeConcurrency('0'), 5);
+    assert.equal(normalizeConcurrency('3'), 3);
+    assert.equal(
+        toRemoteKey('release/20260313/', '/tmp/dist', '/tmp/dist/assets/app.js'),
+        'release/20260313/assets/app.js'
+    );
+});
+
+test('ignore helpers split exclude patterns consistently', () => {
+    assert.deepEqual(
+        normalizeExcludePatterns('*.map,.DS_Store, dist/**'),
+        ['*.map', '.DS_Store', 'dist/**']
+    );
+});

package/test/init.test.js

@@ -0,0 +1,52 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const init = require('../command/init');
+
+function createTempWorkspace() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'struggler-cli-init-'));
+}
+
+test('init dry-run does not create files and returns generated config', async () => {
+    const previousCwd = process.cwd();
+    const workspace = createTempWorkspace();
+
+    try {
+        process.chdir(workspace);
+
+        const config = await init({
+            config: './command/qiniu.json',
+            dryRun: true,
+        });
+
+        assert.equal(fs.existsSync(path.join(workspace, 'command/qiniu.json')), false);
+        assert.match(config.publicPath, /^\/\d{12}\/$/);
+        assert.match(config.base, /^\/\d{12}\/$/);
+    } finally {
+        process.chdir(previousCwd);
+        fs.rmSync(workspace, { recursive: true, force: true });
+    }
+});
+
+test('init writes qiniu template and deploy config when not in dry-run mode', async () => {
+    const previousCwd = process.cwd();
+    const workspace = createTempWorkspace();
+
+    try {
+        process.chdir(workspace);
+
+        const config = await init({
+            config: './command/qiniu.json',
+        });
+
+        assert.equal(fs.existsSync(path.join(workspace, 'command/qiniu.json')), true);
+        assert.equal(fs.existsSync(path.join(workspace, 'command/config.json')), true);
+        assert.equal(config.publicPath.endsWith('/'), true);
+        assert.equal(config.base.endsWith('/'), true);
+    } finally {
+        process.chdir(previousCwd);
+        fs.rmSync(workspace, { recursive: true, force: true });
+    }
+});

package/test/test.sh

@@ -1,5 +1,5 @@
 struggler-cli upload -d ./dist3
 
-struggler-cli addVersion  
+pnpm add-version
 
-struggler-cli init  
+struggler-cli init