@struggler/cli 1.0.3 → 1.0.5

package/lib/i18n.js

@@ -0,0 +1,189 @@
+const LANGUAGES = {
+    zh: {
+        appDescription: '用于将前端打包产物上传到七牛云 OSS 的命令行工具。',
+        options: {
+            version: '显示版本号。',
+            config: '指定上传配置文件路径。',
+            dir: '指定要上传的目录。',
+            dryRun: '仅预览执行计划，不写文件也不调用七牛接口。',
+            concurrency: '设置上传并发数。',
+            exclude: '排除文件匹配规则，支持逗号分隔多个模式。',
+            ignoreFile: '指定自定义忽略文件。',
+            manifest: '将命令执行结果写入 manifest JSON 文件。',
+            json: '输出机器可读的 JSON 结果。',
+            skipInit: '在 deploy 时跳过 init 步骤。',
+            skipRefresh: '在 deploy 时跳过 refresh 步骤。',
+            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.',
+            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.5",
+	"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  

package/test/upload.test.js

@@ -0,0 +1,113 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const upload = require('../command/upload');
+const deploy = require('../command/deploy');
+
+function createWorkspace() {
+    const workspace = fs.mkdtempSync(path.join(os.tmpdir(), 'struggler-cli-upload-'));
+    fs.mkdirSync(path.join(workspace, 'command'), { recursive: true });
+    fs.mkdirSync(path.join(workspace, 'dist/assets'), { recursive: true });
+
+    fs.writeFileSync(path.join(workspace, 'command/qiniu.json'), JSON.stringify({
+        path: 'demo-app',
+        domain: 'https://cdn.example.com/',
+    }, null, 2));
+    fs.writeFileSync(path.join(workspace, 'command/config.json'), JSON.stringify({
+        publicPath: 'demo-app/202603131600/',
+        base: 'https://cdn.example.com/demo-app/202603131600/',
+    }, null, 2));
+    fs.writeFileSync(path.join(workspace, 'dist/index.html'), '<html></html>');
+    fs.writeFileSync(path.join(workspace, 'dist/assets/app.js'), 'console.log("ok")');
+    fs.writeFileSync(path.join(workspace, 'dist/assets/app.js.gz'), 'gzip');
+    fs.writeFileSync(path.join(workspace, 'dist/.DS_Store'), 'noise');
+    fs.writeFileSync(path.join(workspace, '.strugglerignore'), '.DS_Store\n');
+
+    return workspace;
+}
+
+test('upload dry-run plans files, skips gz assets, and returns summary', async () => {
+    const previousCwd = process.cwd();
+    const workspace = createWorkspace();
+
+    try {
+        process.chdir(workspace);
+
+        const summary = await upload({
+            config: './command/qiniu.json',
+            dir: './dist',
+            dryRun: true,
+            concurrency: '2',
+        });
+
+        assert.equal(summary.action, 'upload');
+        assert.equal(summary.dryRun, true);
+        assert.equal(summary.total, 2);
+        assert.equal(summary.failedCount, 0);
+        assert.deepEqual(
+            summary.succeeded.map((item) => item.key),
+            [
+                'demo-app/202603131600/assets/app.js',
+                'demo-app/202603131600/index.html',
+            ]
+        );
+        assert.equal(summary.excludedPatterns.includes('.DS_Store'), true);
+    } finally {
+        process.chdir(previousCwd);
+        fs.rmSync(workspace, { recursive: true, force: true });
+    }
+});
+
+test('upload dry-run can write a manifest file', async () => {
+    const previousCwd = process.cwd();
+    const workspace = createWorkspace();
+
+    try {
+        process.chdir(workspace);
+
+        const summary = await upload({
+            config: './command/qiniu.json',
+            dir: './dist',
+            dryRun: true,
+            manifest: './artifacts/upload.json',
+        });
+
+        const manifestPath = path.resolve(workspace, 'artifacts/upload.json');
+        assert.equal(fs.existsSync(manifestPath), true);
+        assert.equal(summary.manifestPath, fs.realpathSync(manifestPath));
+
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        assert.equal(manifest.action, 'upload');
+        assert.equal(manifest.total, 2);
+    } finally {
+        process.chdir(previousCwd);
+        fs.rmSync(workspace, { recursive: true, force: true });
+    }
+});
+
+test('deploy dry-run supports skip-refresh and json-friendly summary data', async () => {
+    const previousCwd = process.cwd();
+    const workspace = createWorkspace();
+
+    try {
+        process.chdir(workspace);
+
+        const summary = await deploy({
+            config: './command/qiniu.json',
+            dir: './dist',
+            dryRun: true,
+            json: true,
+            skipRefresh: true,
+        });
+
+        assert.equal(summary.action, 'deploy');
+        assert.equal(summary.upload.total, 2);
+        assert.equal(summary.refresh.skipped, true);
+        assert.equal(summary.excludedPatterns.includes('.DS_Store'), true);
+    } finally {
+        process.chdir(previousCwd);
+        fs.rmSync(workspace, { recursive: true, force: true });
+    }
+});