spectrum-cli 3.2.0 → 4.0.0

package/src/release/start.js

@@ -0,0 +1,51 @@
+const { changelogBuildRelease, changelogRemoveFragments } = require('../changelog');
+const { requireReleaseState, requireReleaseFragments, appendOpenRelease } = require('../changelog/open-release');
+const { runCommand } = require('../cli/command-executor');
+const { requireGitRepo, requireCleanWorkingTree, requireCurrentBranchUpToDateWithRemote, requireMainAndDevBranches, requireOnDevBranch, requireDevContainsRemoteMain, requireReleaseVersionAvailable, requireLatestStableVersion, requireFileExists, requireChangelogFormatted } = require('../preflight');
+const { CHANGELOG_FILE } = require('../changelog/config');
+const { detectBumpType, resolveReleaseVersion } = require('./version');
+const { releaseFormatChangelog, releaseCheckChangelogLint, releaseCommit, releasePush } = require('./steps');
+function releaseStart() {
+    return runCommand({
+        name: 'release start',
+        checks: [
+            { name: 'git-repo', run: requireGitRepo },
+            { name: 'clean-working-tree', run: requireCleanWorkingTree },
+            { name: 'branch-up-to-date', run: requireCurrentBranchUpToDateWithRemote },
+            { name: 'main-and-dev-branches', run: requireMainAndDevBranches },
+            { name: 'on-dev-branch', run: requireOnDevBranch },
+            { name: 'dev-contains-main', run: requireDevContainsRemoteMain },
+            { name: 'stable-version', run: requireLatestStableVersion },
+            { name: 'changelog-exists', run: () => requireFileExists(CHANGELOG_FILE) },
+            { name: 'release-state', requires: ['mainBranch', 'stableVersion'], run: requireReleaseState },
+            { name: 'changelog-prettier-check', run: requireChangelogFormatted },
+            { name: 'changelog-fragments', run: requireReleaseFragments },
+            {
+                name: 'detect-bump-type',
+                requires: ['changelogFragments', 'stableVersion'],
+                run: (ctx) => {
+                    const resolved = ctx.openReleaseVersion
+                        ? { bumpType: detectBumpType(ctx.changelogFragments), newVersion: ctx.openReleaseVersion }
+                        : resolveReleaseVersion(ctx.stableVersion, ctx.changelogFragments);
+                    if (!resolved) {
+                        return { ok: false, reason: 'Не удалось вычислить release-версию от последнего стабильного тега.' };
+                    }
+
+                    const versionCheck = requireReleaseVersionAvailable(resolved.newVersion);
+                    if (!versionCheck.ok) return versionCheck;
+                    return { ok: true, data: resolved };
+                }
+            }
+        ],
+        steps: [
+            { name: 'build-release-changelog', run: (ctx) => ctx.openReleaseVersion ? appendOpenRelease(ctx) : changelogBuildRelease(ctx) },
+            { name: 'format-changelog', run: releaseFormatChangelog },
+            { name: 'lint-changelog', run: releaseCheckChangelogLint },
+            { name: 'remove-changelog-fragments', run: (ctx) => !ctx.changelogFragments.length || changelogRemoveFragments(ctx) },
+            { name: 'commit-release', run: releaseCommit },
+            { name: 'push-dev-and-main', run: releasePush }
+        ]
+    });
+}
+
+module.exports = { releaseStart };

package/src/release/steps.js

@@ -0,0 +1,83 @@
+const { logSuccess, logError, execCommand, execSilent, getCurrentBranch, getMainBranch } = require('../common/utils');
+const { requireChangelogFormatted, getPrettierRunner } = require('../preflight');
+const { CHANGELOG_FILE, CHANGELOG_DIR } = require('../changelog/config');
+function releaseFormatChangelog() {
+    const runner = getPrettierRunner();
+    if (!runner) {
+        logError('❌', 'Prettier недоступен.');
+        return false;
+    }
+    if (!execCommand(`${runner} --write ${CHANGELOG_FILE}`)) {
+        logError('❌', 'Не удалось отформатировать %s с помощью Prettier.', CHANGELOG_FILE);
+        return false;
+    }
+    logSuccess('🎨', 'Файл %s отформатирован.', CHANGELOG_FILE);
+    return true;
+}
+
+function releaseCheckChangelogLint() {
+    const result = requireChangelogFormatted();
+    if (!result.ok) {
+        logError('❌', result.reason || 'Файл CHANGELOG.md не прошел линтинг.');
+        return false;
+    }
+    return true;
+}
+
+function releaseCommit(context) {
+    const paths = context.changelogFragments?.length ? `${CHANGELOG_FILE} ${CHANGELOG_DIR}` : CHANGELOG_FILE;
+    if (!execCommand(`git add --all -- ${paths}`)) return false;
+    const staged = execSilent('git diff --cached --name-only');
+    if (staged === null) return false;
+    if (!staged.trim()) {
+        logSuccess('📋', 'Новых changelog-записей нет; пустой коммит не создаётся.');
+        return true;
+    }
+    if (!execCommand(`git commit --message "📝 Подготовить релиз ${context.newVersion}." --no-verify`)) return false;
+
+    logSuccess('📝', 'Коммит со схлопнутыми changelog fragments создан.');
+    return true;
+}
+
+function getReleasePushCommand(context) {
+    const devBranch = context && context.devBranch;
+    const targetBranch = (context && context.mainBranch) || getMainBranch();
+    if (!devBranch || !targetBranch) return null;
+
+    return `git push --atomic origin ${devBranch}:${devBranch} ${devBranch}:${targetBranch}`;
+}
+
+function releasePush(context) {
+    const command = getReleasePushCommand(context);
+    if (!command) {
+        logError('❌', 'Не удалось сформировать команду публикации релиза.');
+        return false;
+    }
+
+    if (!execCommand(command)) {
+        logError(
+            '❌',
+            'Релиз не отправлен в dev и main/master. Убедитесь, что dev содержит актуальный main/master и прямой push разрешен. Повторите: %s',
+            command
+        );
+        return false;
+    }
+
+    const devBranch = context.devBranch;
+    const targetBranch = context.mainBranch || getMainBranch();
+    logSuccess('📤', 'Релиз атомарно отправлен в origin/%s и origin/%s.', devBranch, targetBranch);
+    return true;
+}
+
+function pushDev(context) {
+    const devBranch = context.devBranch || getCurrentBranch();
+    const command = `git push origin ${devBranch}`;
+    if (!execCommand(command)) {
+        logError('❌', 'Dev-ветка не отправлена. Повторите: %s', command);
+        return false;
+    }
+    logSuccess('📤', 'Ветка %s отправлена.', devBranch);
+    return true;
+}
+
+module.exports = { releaseFormatChangelog, releaseCheckChangelogLint, releaseCommit, getReleasePushCommand, releasePush, pushDev };

package/src/release/version.js

@@ -0,0 +1,20 @@
+const { upVersion } = require('../common/version');
+function detectBumpType(fragments) {
+    const bumpTypes = new Set((fragments || []).map((fragment) => fragment.bump));
+    if (bumpTypes.has('major')) {
+        return 'major';
+    }
+    if (bumpTypes.has('minor')) {
+        return 'minor';
+    }
+    return 'patch';
+}
+
+function resolveReleaseVersion(stableVersion, fragments) {
+    const bumpType = detectBumpType(fragments);
+    const newVersion = upVersion(stableVersion, bumpType);
+    if (!newVersion) return null;
+    return { bumpType, newVersion };
+}
+
+module.exports = { detectBumpType, resolveReleaseVersion };

package/src/token/config.js

@@ -0,0 +1,163 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { logSuccess } = require('../common/utils');
+const { isDryRun } = require('../cli/command-executor');
+const { parseGitlabUrl } = require('../integrations/gitlab-url');
+const TOKEN_NAME = 'GITLAB_PRIVATE_TOKEN';
+
+function getConfigPath() {
+    return path.join(os.homedir(), '.config', 'spectrum-cli', 'config.yaml');
+}
+
+function defaultConfigContent() {
+    return [
+        'bot: bot',
+        'token_ttl_months: 12',
+        'groups: []',
+        'projects: []',
+        ''
+    ].join('\n');
+}
+
+function stripQuotes(value) {
+    const text = String(value || '').trim();
+    if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+        return text.slice(1, -1);
+    }
+    return text;
+}
+
+function parseConfig(content) {
+    const result = { bot: null, tokenTtlMonths: null, groups: [], projects: [] };
+    let section = null;
+
+    for (const rawLine of String(content || '').split('\n')) {
+        const line = rawLine.replace(/\r$/, '');
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+
+        const isTopLevel = !line.startsWith(' ') && !line.startsWith('\t');
+        const botMatch = trimmed.match(/^bot:\s*(.+)$/);
+        if (isTopLevel && botMatch) {
+            result.bot = stripQuotes(botMatch[1]);
+            section = null;
+            continue;
+        }
+
+        const ttlMatch = trimmed.match(/^token_ttl_months:\s*(.+)$/);
+        if (isTopLevel && ttlMatch) {
+            result.tokenTtlMonths = Number(stripQuotes(ttlMatch[1]));
+            section = null;
+            continue;
+        }
+
+        if (isTopLevel && /^groups:\s*(?:\[\s*\])?\s*$/.test(trimmed)) {
+            section = 'groups';
+            continue;
+        }
+
+        if (isTopLevel && /^projects:\s*(?:\[\s*\])?\s*$/.test(trimmed)) {
+            section = 'projects';
+            continue;
+        }
+
+        const itemMatch = line.match(/^\s*-\s+(.+)$/);
+        if (itemMatch && (section === 'groups' || section === 'projects')) {
+            result[section].push(stripQuotes(itemMatch[1]));
+        }
+    }
+
+    return result;
+}
+
+function addMonths(date, months) {
+    const result = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + Number(months), date.getUTCDate()));
+    return result.toISOString().slice(0, 10);
+}
+
+function buildDescription(bot, expiresAt) {
+    return `PAT от бота ${bot}, владелец Колосов. Истекает ${expiresAt}.`;
+}
+
+function validateConfig(config) {
+    if (!config.bot) {
+        return { ok: false, reason: 'В конфиге отсутствует поле bot.' };
+    }
+    if (!Number.isInteger(config.tokenTtlMonths) || config.tokenTtlMonths <= 0) {
+        return { ok: false, reason: 'В конфиге поле token_ttl_months должно быть положительным целым числом.' };
+    }
+    if (config.groups.length === 0 && config.projects.length === 0) {
+        return { ok: false, reason: 'В конфиге пустые списки groups и projects.' };
+    }
+    return { ok: true };
+}
+
+function parseTargets(urls, kind) {
+    const targets = [];
+    for (const raw of urls) {
+        try {
+            targets.push({ kind, ...parseGitlabUrl(raw) });
+        } catch (error) {
+            return { ok: false, reason: `Некорректный URL ${kind}: ${raw}` };
+        }
+    }
+    return { ok: true, targets };
+}
+
+function loadOrCreateConfig() {
+    const configPath = getConfigPath();
+    const configDir = path.dirname(configPath);
+
+    if (!fs.existsSync(configPath)) {
+        if (isDryRun()) {
+            return { ok: false, reason: `Конфиг ${configPath} не найден. В режиме --dry он не создаётся.` };
+        }
+        logSuccess('📄', 'Конфиг не найден, создаю %s', configPath);
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.writeFileSync(configPath, defaultConfigContent(), 'utf8');
+        logSuccess('📄', 'Конфиг создан. Проверьте groups и projects перед следующей ротацией.');
+    } else {
+        logSuccess('📄', 'Читаю конфиг %s', configPath);
+    }
+
+    let content = '';
+    try {
+        content = fs.readFileSync(configPath, 'utf8');
+    } catch (error) {
+        return { ok: false, reason: `Не удалось прочитать конфиг ${configPath}.` };
+    }
+
+    const parsed = parseConfig(content);
+    const valid = validateConfig(parsed);
+    if (!valid.ok) {
+        return valid;
+    }
+
+    const groups = parseTargets(parsed.groups, 'группы');
+    if (!groups.ok) {
+        return groups;
+    }
+    const projects = parseTargets(parsed.projects, 'проекта');
+    if (!projects.ok) {
+        return projects;
+    }
+
+    const targets = groups.targets.concat(projects.targets);
+    logSuccess('📄', 'Конфиг загружен: bot=%s, ttl=%s мес., групп=%s, проектов=%s', parsed.bot, String(parsed.tokenTtlMonths), String(parsed.groups.length), String(parsed.projects.length));
+
+    return {
+        ok: true,
+        data: {
+            configPath,
+            bot: parsed.bot,
+            tokenTtlMonths: parsed.tokenTtlMonths,
+            origin: targets[0].origin,
+            targets
+        }
+    };
+}
+
+module.exports = { TOKEN_NAME, getConfigPath, defaultConfigContent, parseConfig, addMonths, buildDescription, validateConfig, loadOrCreateConfig };

package/src/token/gitlab-api.js

@@ -0,0 +1,59 @@
+
+async function gitlabRequest(origin, accessToken, method, apiPath, body) {
+    const url = `${origin}/api/v4${apiPath}`;
+    const headers = { 'PRIVATE-TOKEN': accessToken };
+    const options = { method, headers };
+    if (body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+        options.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(url, options);
+    const text = await response.text();
+    let data = null;
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        } catch (error) {
+            data = null;
+        }
+    }
+
+    return {
+        ok: response.ok,
+        status: response.status,
+        data,
+        headers: response.headers
+    };
+}
+
+async function gitlabGetAll(origin, accessToken, apiPath) {
+    const items = [];
+    let page = 1;
+
+    while (true) {
+        const separator = apiPath.includes('?') ? '&' : '?';
+        const result = await gitlabRequest(origin, accessToken, 'GET', `${apiPath}${separator}per_page=100&page=${page}`);
+        if (!result.ok) {
+            return result;
+        }
+
+        const batch = Array.isArray(result.data) ? result.data : [];
+        items.push(...batch);
+
+        const nextPage = result.headers && typeof result.headers.get === 'function'
+            ? result.headers.get('x-next-page')
+            : '';
+        if (!nextPage) {
+            break;
+        }
+        page = Number(nextPage);
+        if (!page) {
+            break;
+        }
+    }
+
+    return { ok: true, status: 200, data: items };
+}
+
+module.exports = { gitlabRequest, gitlabGetAll };

package/src/token/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+module.exports = {
+    ...require('./config'),
+    ...require('./rotate'),
+    parseGitlabUrl: require('../integrations/gitlab-url').parseGitlabUrl
+};

package/src/token/rotate.js

@@ -0,0 +1,157 @@
+const readline = require('readline');
+const { logSuccess, logError } = require('../common/utils');
+const { runCommand } = require('../cli/command-executor');
+const { TOKEN_NAME, addMonths, buildDescription, loadOrCreateConfig } = require('./config');
+const { gitlabRequest, gitlabGetAll } = require('./gitlab-api');
+async function promptHidden(message) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        stdout.write(message);
+
+        if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') {
+            const rl = readline.createInterface({ input: stdin, output: stdout });
+            rl.question('', (answer) => {
+                rl.close();
+                resolve(String(answer || '').trim());
+            });
+            return;
+        }
+
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        let value = '';
+        const onData = (char) => {
+            if (char === '\n' || char === '\r' || char === '\u0004') {
+                stdin.setRawMode(false);
+                stdin.pause();
+                stdin.removeListener('data', onData);
+                stdout.write('\n');
+                resolve(value.trim());
+                return;
+            }
+            if (char === '\u0003') {
+                stdin.setRawMode(false);
+                process.exit(1);
+            }
+            if (char === '\u007f' || char === '\b') {
+                value = value.slice(0, -1);
+                return;
+            }
+            value += char;
+        };
+        stdin.on('data', onData);
+    });
+}
+
+async function askTokens(ctx) {
+    logSuccess('🔑', 'Запрашиваю owner PAT для работы с CI variables. Значение останется только в памяти.');
+    const ownerToken = await require('./index').promptHidden('🔑 Введите owner PAT: ');
+    if (!ownerToken) {
+        return { ok: false, reason: 'Owner PAT не указан.' };
+    }
+    logSuccess('🔑', 'Owner PAT принят в память.');
+
+    logSuccess('🔑', 'Запрашиваю %s для записи в CI variables. Значение останется только в памяти.', TOKEN_NAME);
+    const ciToken = await require('./index').promptHidden(`🔑 Введите ${TOKEN_NAME}: `);
+    if (!ciToken) {
+        return { ok: false, reason: `${TOKEN_NAME} не указан.` };
+    }
+
+    const expiresAt = addMonths(new Date(), ctx.tokenTtlMonths);
+    logSuccess('🔑', '%s принят в память. Description будет с датой %s.', TOKEN_NAME, expiresAt);
+    return {
+        ok: true,
+        data: {
+            ownerToken,
+            ciToken,
+            expiresAt,
+            variableDescription: buildDescription(ctx.bot, expiresAt)
+        }
+    };
+}
+
+async function checkTargetsAccess(ctx) {
+    const total = ctx.targets.length;
+    for (let index = 0; index < total; index += 1) {
+        const target = ctx.targets[index];
+        const endpoint = target.kind === 'группы' ? 'groups' : 'projects';
+        logSuccess('🔍', '[%s/%s] Проверяю доступ к %s %s', String(index + 1), String(total), target.kind, target.url);
+        const result = await gitlabRequest(ctx.origin, ctx.ownerToken, 'GET', `/${endpoint}/${target.encodedPath}`);
+        if (!result.ok) {
+            return { ok: false, reason: `${target.kind === 'группы' ? 'Группа' : 'Проект'} недоступен: ${target.url} (HTTP ${result.status}).` };
+        }
+        logSuccess('✅', '[%s/%s] %s доступна: %s', String(index + 1), String(total), target.kind === 'группы' ? 'Группа' : 'Проект', target.path);
+    }
+    return { ok: true };
+}
+
+async function updateTargetVariable(ctx, target, index, total) {
+    const endpoint = target.kind === 'группы' ? 'groups' : 'projects';
+    const label = target.kind === 'группы' ? 'группе' : 'проекте';
+    logSuccess('📦', '[%s/%s] Обновляю CI variable %s в %s %s', String(index + 1), String(total), TOKEN_NAME, label, target.path);
+
+    const listed = await gitlabGetAll(ctx.origin, ctx.ownerToken, `/${endpoint}/${target.encodedPath}/variables`);
+    if (!listed.ok) {
+        logError('❌', 'Не удалось получить CI variables для %s (HTTP %s).', target.path, String(listed.status));
+        return false;
+    }
+
+    const exists = (listed.data || []).some((variable) => variable.key === TOKEN_NAME);
+    if (exists) {
+        logSuccess('🗑', '[%s/%s] Удаляю старую CI variable %s в %s %s', String(index + 1), String(total), TOKEN_NAME, label, target.path);
+        const deleted = await gitlabRequest(ctx.origin, ctx.ownerToken, 'DELETE', `/${endpoint}/${target.encodedPath}/variables/${TOKEN_NAME}`);
+        if (!deleted.ok && deleted.status !== 204) {
+            logError('❌', 'Не удалось удалить CI variable в %s (HTTP %s).', target.path, String(deleted.status));
+            return false;
+        }
+        logSuccess('🗑', '[%s/%s] Старая CI variable удалена в %s %s', String(index + 1), String(total), label, target.path);
+    } else {
+        logSuccess('🔎', '[%s/%s] CI variable %s в %s %s отсутствует, будет создана.', String(index + 1), String(total), TOKEN_NAME, label, target.path);
+    }
+
+    logSuccess('📝', '[%s/%s] Создаю CI variable %s в %s %s', String(index + 1), String(total), TOKEN_NAME, label, target.path);
+    const created = await gitlabRequest(ctx.origin, ctx.ownerToken, 'POST', `/${endpoint}/${target.encodedPath}/variables`, {
+        key: TOKEN_NAME,
+        value: ctx.ciToken,
+        masked_and_hidden: true,
+        description: ctx.variableDescription
+    });
+    if (!created.ok) {
+        logError('❌', 'Не удалось создать CI variable в %s (HTTP %s).', target.path, String(created.status));
+        return false;
+    }
+
+    logSuccess('📝', '[%s/%s] CI variable обновлена в %s %s', String(index + 1), String(total), label, target.path);
+    return true;
+}
+
+async function updateCiVariables(ctx) {
+    const total = ctx.targets.length;
+    logSuccess('📦', 'Начинаю обновление CI variables: целей %s', String(total));
+    for (let index = 0; index < total; index += 1) {
+        const ok = await updateTargetVariable(ctx, ctx.targets[index], index, total);
+        if (!ok) {
+            return false;
+        }
+    }
+    logSuccess('📦', 'Все CI variables обновлены (%s).', String(total));
+    return true;
+}
+
+function tokenRotate() {
+    return runCommand({
+        name: 'token rotate',
+        checks: [
+            { name: 'load-config', run: loadOrCreateConfig },
+            { name: 'ask-tokens', requires: ['tokenTtlMonths', 'bot'], run: askTokens },
+            { name: 'check-access', requires: ['targets', 'origin', 'ownerToken'], run: checkTargetsAccess }
+        ],
+        steps: [
+            { name: 'update-ci-variables', run: updateCiVariables }
+        ]
+    });
+}
+
+module.exports = { promptHidden, askTokens, checkTargetsAccess, updateCiVariables, tokenRotate };